From 9fd33200e54e10e04c277dcb464ab6552c510e82 Mon Sep 17 00:00:00 2001 From: stevemessick Date: Fri, 23 Aug 2024 17:42:49 +0000 Subject: [PATCH] Add kagglesdk (#623) This is generated code. To the extent that it has been tested, it is used in some of the public API code, which is exercised by the unit tests. It might be nice if there was a way to allow both this repo and `kagglehub` to share this package without publishing to pypi. --- kagglesdk/__init__.py | 2 + kagglesdk/common/__init__.py | 0 kagglesdk/common/types/__init__.py | 0 kagglesdk/common/types/file_download.py | 98 + kagglesdk/common/types/http_redirect.py | 105 + kagglesdk/competitions/__init__.py | 0 kagglesdk/competitions/services/__init__.py | 0 .../services/competition_api_service.py | 117 + kagglesdk/competitions/types/__init__.py | 0 .../types/competition_api_service.py | 1751 +++++++++++ .../competitions/types/competition_enums.py | 52 + .../competitions/types/submission_status.py | 9 + kagglesdk/datasets/__init__.py | 0 kagglesdk/datasets/services/__init__.py | 0 .../datasets/services/dataset_api_service.py | 170 ++ kagglesdk/datasets/types/__init__.py | 0 .../datasets/types/dataset_api_service.py | 2713 +++++++++++++++++ kagglesdk/datasets/types/dataset_enums.py | 82 + kagglesdk/datasets/types/dataset_types.py | 628 ++++ kagglesdk/kaggle_client.py | 43 + kagglesdk/kaggle_env.py | 36 + kagglesdk/kaggle_http_client.py | 196 ++ kagglesdk/kaggle_object.py | 263 ++ kagglesdk/kernels/__init__.py | 0 kagglesdk/kernels/services/__init__.py | 0 .../kernels/services/kernels_api_service.py | 79 + kagglesdk/kernels/types/__init__.py | 0 .../kernels/types/kernels_api_service.py | 1748 +++++++++++ kagglesdk/kernels/types/kernels_enums.py | 33 + kagglesdk/models/__init__.py | 0 kagglesdk/models/services/__init__.py | 0 .../models/services/model_api_service.py | 178 ++ kagglesdk/models/services/model_service.py | 19 + kagglesdk/models/types/__init__.py | 0 kagglesdk/models/types/model_api_service.py | 2683 ++++++++++++++++ kagglesdk/models/types/model_enums.py | 44 + kagglesdk/models/types/model_service.py | 271 ++ kagglesdk/models/types/model_types.py | 226 ++ kagglesdk/users/__init__.py | 0 kagglesdk/users/types/__init__.py | 0 kagglesdk/users/types/users_enums.py | 22 + 41 files changed, 11568 insertions(+) create mode 100644 kagglesdk/__init__.py create mode 100644 kagglesdk/common/__init__.py create mode 100644 kagglesdk/common/types/__init__.py create mode 100644 kagglesdk/common/types/file_download.py create mode 100644 kagglesdk/common/types/http_redirect.py create mode 100644 kagglesdk/competitions/__init__.py create mode 100644 kagglesdk/competitions/services/__init__.py create mode 100644 kagglesdk/competitions/services/competition_api_service.py create mode 100644 kagglesdk/competitions/types/__init__.py create mode 100644 kagglesdk/competitions/types/competition_api_service.py create mode 100644 kagglesdk/competitions/types/competition_enums.py create mode 100644 kagglesdk/competitions/types/submission_status.py create mode 100644 kagglesdk/datasets/__init__.py create mode 100644 kagglesdk/datasets/services/__init__.py create mode 100644 kagglesdk/datasets/services/dataset_api_service.py create mode 100644 kagglesdk/datasets/types/__init__.py create mode 100644 kagglesdk/datasets/types/dataset_api_service.py create mode 100644 kagglesdk/datasets/types/dataset_enums.py create mode 100644 kagglesdk/datasets/types/dataset_types.py create mode 100644 kagglesdk/kaggle_client.py create mode 100644 kagglesdk/kaggle_env.py create mode 100644 kagglesdk/kaggle_http_client.py create mode 100644 kagglesdk/kaggle_object.py create mode 100644 kagglesdk/kernels/__init__.py create mode 100644 kagglesdk/kernels/services/__init__.py create mode 100644 kagglesdk/kernels/services/kernels_api_service.py create mode 100644 kagglesdk/kernels/types/__init__.py create mode 100644 kagglesdk/kernels/types/kernels_api_service.py create mode 100644 kagglesdk/kernels/types/kernels_enums.py create mode 100644 kagglesdk/models/__init__.py create mode 100644 kagglesdk/models/services/__init__.py create mode 100644 kagglesdk/models/services/model_api_service.py create mode 100644 kagglesdk/models/services/model_service.py create mode 100644 kagglesdk/models/types/__init__.py create mode 100644 kagglesdk/models/types/model_api_service.py create mode 100644 kagglesdk/models/types/model_enums.py create mode 100644 kagglesdk/models/types/model_service.py create mode 100644 kagglesdk/models/types/model_types.py create mode 100644 kagglesdk/users/__init__.py create mode 100644 kagglesdk/users/types/__init__.py create mode 100644 kagglesdk/users/types/users_enums.py diff --git a/kagglesdk/__init__.py b/kagglesdk/__init__.py new file mode 100644 index 0000000..4e6bb7f --- /dev/null +++ b/kagglesdk/__init__.py @@ -0,0 +1,2 @@ +from kagglesdk.kaggle_client import KaggleClient +from kagglesdk.kaggle_env import KaggleEnv \ No newline at end of file diff --git a/kagglesdk/common/__init__.py b/kagglesdk/common/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/common/types/__init__.py b/kagglesdk/common/types/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/common/types/file_download.py b/kagglesdk/common/types/file_download.py new file mode 100644 index 0000000..478ccd1 --- /dev/null +++ b/kagglesdk/common/types/file_download.py @@ -0,0 +1,98 @@ +from kagglesdk.kaggle_object import * +from typing import Optional + +class FileDownload(KaggleObject): + r""" + Standard response object representing a file download. + See http://go/kaggle-proto-handler-file-downloads + Some field names/descriptions borrowed from + google3/gdata/rosy/proto/data.proto + + Attributes: + content_type (str) + MIME type of the data + TODO(aip.dev/143): (-- api-linter: core::0143::standardized-codes=disabled + --) + file_name (str) + Original file name + token (str) + A unique fingerprint for the file/media data + content_length (int) + Size of the data, in bytes (if known) + """ + + def __init__(self): + self._content_type = "" + self._file_name = "" + self._token = "" + self._content_length = None + self._freeze() + + @property + def content_type(self) -> str: + r""" + MIME type of the data + TODO(aip.dev/143): (-- api-linter: core::0143::standardized-codes=disabled + --) + """ + return self._content_type + + @content_type.setter + def content_type(self, content_type: str): + if content_type is None: + del self.content_type + return + if not isinstance(content_type, str): + raise TypeError('content_type must be of type str') + self._content_type = content_type + + @property + def file_name(self) -> str: + """Original file name""" + return self._file_name + + @file_name.setter + def file_name(self, file_name: str): + if file_name is None: + del self.file_name + return + if not isinstance(file_name, str): + raise TypeError('file_name must be of type str') + self._file_name = file_name + + @property + def token(self) -> str: + """A unique fingerprint for the file/media data""" + return self._token + + @token.setter + def token(self, token: str): + if token is None: + del self.token + return + if not isinstance(token, str): + raise TypeError('token must be of type str') + self._token = token + + @property + def content_length(self) -> int: + """Size of the data, in bytes (if known)""" + return self._content_length or 0 + + @content_length.setter + def content_length(self, content_length: int): + if content_length is None: + del self.content_length + return + if not isinstance(content_length, int): + raise TypeError('content_length must be of type int') + self._content_length = content_length + + +FileDownload._fields = [ + FieldMetadata("contentType", "content_type", "_content_type", str, "", PredefinedSerializer()), + FieldMetadata("fileName", "file_name", "_file_name", str, "", PredefinedSerializer()), + FieldMetadata("token", "token", "_token", str, "", PredefinedSerializer()), + FieldMetadata("contentLength", "content_length", "_content_length", int, None, PredefinedSerializer(), optional=True), +] + diff --git a/kagglesdk/common/types/http_redirect.py b/kagglesdk/common/types/http_redirect.py new file mode 100644 index 0000000..6a0f01b --- /dev/null +++ b/kagglesdk/common/types/http_redirect.py @@ -0,0 +1,105 @@ +from datetime import timedelta +from kagglesdk.kaggle_object import * +from typing import Optional + +class HttpRedirect(KaggleObject): + r""" + Represents an HTTP redirect (e.g. 301 or 302) response. + Patterned after ASP.NET MVC's RedirectResult. + + Attributes: + url (str) + Destination URL for the redirect. + permanent (bool) + Should it be an HTTP 301 (permanent) redirect or just temporary (HTTP + 302)?. + bypass_encoding (bool) + When `true`, the `url` is already encoded, so bypass `UriHelper.Encode`. + Otherwise, invoke `UriHelper.Encode` on the `url` before returning to the + client. + expiry (timedelta) + Specifies how long the redirected url can be cached. + """ + + def __init__(self): + self._url = "" + self._permanent = False + self._bypass_encoding = None + self._expiry = None + self._freeze() + + @property + def url(self) -> str: + """Destination URL for the redirect.""" + 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 permanent(self) -> bool: + r""" + Should it be an HTTP 301 (permanent) redirect or just temporary (HTTP + 302)?. + """ + return self._permanent + + @permanent.setter + def permanent(self, permanent: bool): + if permanent is None: + del self.permanent + return + if not isinstance(permanent, bool): + raise TypeError('permanent must be of type bool') + self._permanent = permanent + + @property + def bypass_encoding(self) -> bool: + r""" + When `true`, the `url` is already encoded, so bypass `UriHelper.Encode`. + Otherwise, invoke `UriHelper.Encode` on the `url` before returning to the + client. + """ + return self._bypass_encoding or False + + @bypass_encoding.setter + def bypass_encoding(self, bypass_encoding: bool): + if bypass_encoding is None: + del self.bypass_encoding + return + if not isinstance(bypass_encoding, bool): + raise TypeError('bypass_encoding must be of type bool') + self._bypass_encoding = bypass_encoding + + @property + def expiry(self) -> timedelta: + """Specifies how long the redirected url can be cached.""" + return self._expiry + + @expiry.setter + def expiry(self, expiry: timedelta): + if expiry is None: + del self.expiry + return + if not isinstance(expiry, timedelta): + raise TypeError('expiry must be of type timedelta') + self._expiry = expiry + + + @classmethod + def prepare_from(cls, http_response): + return http_response + +HttpRedirect._fields = [ + FieldMetadata("url", "url", "_url", str, "", PredefinedSerializer()), + FieldMetadata("permanent", "permanent", "_permanent", bool, False, PredefinedSerializer()), + FieldMetadata("bypassEncoding", "bypass_encoding", "_bypass_encoding", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("expiry", "expiry", "_expiry", timedelta, None, TimeDeltaSerializer()), +] + diff --git a/kagglesdk/competitions/__init__.py b/kagglesdk/competitions/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/competitions/services/__init__.py b/kagglesdk/competitions/services/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/competitions/services/competition_api_service.py b/kagglesdk/competitions/services/competition_api_service.py new file mode 100644 index 0000000..2bf6cf3 --- /dev/null +++ b/kagglesdk/competitions/services/competition_api_service.py @@ -0,0 +1,117 @@ +from kagglesdk.common.types.file_download import FileDownload +from kagglesdk.common.types.http_redirect import HttpRedirect +from kagglesdk.competitions.types.competition_api_service import ApiCreateSubmissionRequest, ApiCreateSubmissionResponse, ApiDownloadDataFileRequest, ApiDownloadDataFilesRequest, ApiDownloadLeaderboardRequest, ApiGetLeaderboardRequest, ApiGetLeaderboardResponse, ApiListCompetitionsRequest, ApiListCompetitionsResponse, ApiListDataFilesRequest, ApiListDataFilesResponse, ApiListSubmissionsRequest, ApiListSubmissionsResponse, ApiStartSubmissionUploadRequest, ApiStartSubmissionUploadResponse +from kagglesdk.kaggle_http_client import KaggleHttpClient + +class CompetitionApiClient(object): + + def __init__(self, client: KaggleHttpClient): + self._client = client + + def list_competitions(self, request: ApiListCompetitionsRequest = None) -> ApiListCompetitionsResponse: + r""" + Args: + request (ApiListCompetitionsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListCompetitionsRequest() + + return self._client.call("competitions.CompetitionApiService", "ApiListCompetitions", request, ApiListCompetitionsResponse) + + def list_submissions(self, request: ApiListSubmissionsRequest = None) -> ApiListSubmissionsResponse: + r""" + Args: + request (ApiListSubmissionsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListSubmissionsRequest() + + return self._client.call("competitions.CompetitionApiService", "ApiListSubmissions", request, ApiListSubmissionsResponse) + + def list_data_files(self, request: ApiListDataFilesRequest = None) -> ApiListDataFilesResponse: + r""" + Args: + request (ApiListDataFilesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListDataFilesRequest() + + return self._client.call("competitions.CompetitionApiService", "ApiListDataFiles", request, ApiListDataFilesResponse) + + def get_leaderboard(self, request: ApiGetLeaderboardRequest = None) -> ApiGetLeaderboardResponse: + r""" + Args: + request (ApiGetLeaderboardRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetLeaderboardRequest() + + return self._client.call("competitions.CompetitionApiService", "ApiGetLeaderboard", request, ApiGetLeaderboardResponse) + + def download_leaderboard(self, request: ApiDownloadLeaderboardRequest = None) -> FileDownload: + r""" + Args: + request (ApiDownloadLeaderboardRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDownloadLeaderboardRequest() + + return self._client.call("competitions.CompetitionApiService", "ApiDownloadLeaderboard", request, FileDownload) + + def create_submission(self, request: ApiCreateSubmissionRequest = None) -> ApiCreateSubmissionResponse: + r""" + Args: + request (ApiCreateSubmissionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateSubmissionRequest() + + return self._client.call("competitions.CompetitionApiService", "ApiCreateSubmission", request, ApiCreateSubmissionResponse) + + def start_submission_upload(self, request: ApiStartSubmissionUploadRequest = None) -> ApiStartSubmissionUploadResponse: + r""" + Args: + request (ApiStartSubmissionUploadRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiStartSubmissionUploadRequest() + + return self._client.call("competitions.CompetitionApiService", "ApiStartSubmissionUpload", request, ApiStartSubmissionUploadResponse) + + def download_data_files(self, request: ApiDownloadDataFilesRequest = None) -> HttpRedirect: + r""" + Args: + request (ApiDownloadDataFilesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDownloadDataFilesRequest() + + return self._client.call("competitions.CompetitionApiService", "ApiDownloadDataFiles", request, HttpRedirect) + + def download_data_file(self, request: ApiDownloadDataFileRequest = None) -> HttpRedirect: + r""" + Args: + request (ApiDownloadDataFileRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDownloadDataFileRequest() + + return self._client.call("competitions.CompetitionApiService", "ApiDownloadDataFile", request, HttpRedirect) diff --git a/kagglesdk/competitions/types/__init__.py b/kagglesdk/competitions/types/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/competitions/types/competition_api_service.py b/kagglesdk/competitions/types/competition_api_service.py new file mode 100644 index 0000000..59bc67d --- /dev/null +++ b/kagglesdk/competitions/types/competition_api_service.py @@ -0,0 +1,1751 @@ +from datetime import datetime +from kagglesdk.competitions.types.competition_enums import CompetitionListTab, CompetitionSortBy, HostSegment, SubmissionGroup, SubmissionSortBy +from kagglesdk.competitions.types.submission_status import SubmissionStatus +from kagglesdk.kaggle_object import * +from typing import Optional, List + +class ApiCreateSubmissionRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + Competition name. Example: 'titanic'. + blob_file_tokens (str) + Token identifying location of uploaded submission file. + submission_description (str) + Description of competition submission. + """ + + def __init__(self): + self._competition_name = "" + self._blob_file_tokens = "" + self._submission_description = None + self._freeze() + + @property + def competition_name(self) -> str: + """Competition name. Example: 'titanic'.""" + 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_file_tokens(self) -> str: + """Token identifying location of uploaded submission file.""" + return self._blob_file_tokens + + @blob_file_tokens.setter + def blob_file_tokens(self, blob_file_tokens: str): + if blob_file_tokens is None: + del self.blob_file_tokens + return + if not isinstance(blob_file_tokens, str): + raise TypeError('blob_file_tokens must be of type str') + self._blob_file_tokens = blob_file_tokens + + @property + def submission_description(self) -> str: + """Description of competition submission.""" + return self._submission_description or "" + + @submission_description.setter + def submission_description(self, submission_description: str): + if submission_description is None: + del self.submission_description + return + if not isinstance(submission_description, str): + raise TypeError('submission_description must be of type str') + self._submission_description = submission_description + + + def endpoint(self): + path = '/api/v1/competitions/submissions/submit/{competition_name}' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiCreateSubmissionResponse(KaggleObject): + r""" + Attributes: + message (str) + """ + + def __init__(self): + self._message = "" + self._freeze() + + @property + def message(self) -> str: + return self._message + + @message.setter + def message(self, message: str): + if message is None: + del self.message + return + if not isinstance(message, str): + raise TypeError('message must be of type str') + self._message = message + + +class ApiDownloadDataFileRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + Competition name. Example: 'titanic'. + file_name (str) + Name of the file to download. Example: 'train/foo/bar.png'. + """ + + def __init__(self): + self._competition_name = "" + self._file_name = "" + self._freeze() + + @property + def competition_name(self) -> str: + """Competition name. Example: 'titanic'.""" + 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 file_name(self) -> str: + """Name of the file to download. Example: 'train/foo/bar.png'.""" + return self._file_name + + @file_name.setter + def file_name(self, file_name: str): + if file_name is None: + del self.file_name + return + if not isinstance(file_name, str): + raise TypeError('file_name must be of type str') + self._file_name = file_name + + + def endpoint(self): + path = '/api/v1/competitions/data/download/{competition_name}/{file_name}' + return path.format_map(self.to_field_map(self)) + +class ApiDownloadDataFilesRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + Competition name. Example: 'titanic'. + """ + + def __init__(self): + self._competition_name = "" + self._freeze() + + @property + def competition_name(self) -> str: + """Competition name. Example: 'titanic'.""" + 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 + + + def endpoint(self): + path = '/api/v1/competitions/data/download-all/{competition_name}' + return path.format_map(self.to_field_map(self)) + +class ApiDownloadLeaderboardRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + """ + + def __init__(self): + self._competition_name = "" + 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 + + + def endpoint(self): + path = '/api/v1/competitions/{competition_name}/leaderboard/download' + return path.format_map(self.to_field_map(self)) + +class ApiGetLeaderboardRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + Competition name. Example: 'titanic'. + """ + + def __init__(self): + self._competition_name = "" + self._freeze() + + @property + def competition_name(self) -> str: + """Competition name. Example: 'titanic'.""" + 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 + + + def endpoint(self): + path = '/api/v1/competitions/{competition_name}/leaderboard/view' + return path.format_map(self.to_field_map(self)) + +class ApiGetLeaderboardResponse(KaggleObject): + r""" + Attributes: + submissions (ApiLeaderboardSubmission) + """ + + def __init__(self): + self._submissions = [] + self._freeze() + + @property + def submissions(self) -> Optional[List[Optional['ApiLeaderboardSubmission']]]: + return self._submissions + + @submissions.setter + def submissions(self, submissions: Optional[List[Optional['ApiLeaderboardSubmission']]]): + 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, ApiLeaderboardSubmission) for t in submissions]): + raise TypeError('submissions must contain only items of type ApiLeaderboardSubmission') + self._submissions = submissions + + +class ApiLeaderboardSubmission(KaggleObject): + r""" + Attributes: + team_id (int) + team_name (str) + submission_date (datetime) + score (str) + """ + + def __init__(self): + self._team_id = 0 + self._team_name = None + self._submission_date = None + self._score = None + 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 team_name(self) -> str: + return self._team_name or "" + + @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 + + @property + def submission_date(self) -> datetime: + return self._submission_date + + @submission_date.setter + def submission_date(self, submission_date: datetime): + if submission_date is None: + del self.submission_date + return + if not isinstance(submission_date, datetime): + raise TypeError('submission_date must be of type datetime') + self._submission_date = submission_date + + @property + def score(self) -> str: + return self._score or "" + + @score.setter + def score(self, score: str): + if score is None: + del self.score + return + if not isinstance(score, str): + raise TypeError('score must be of type str') + self._score = score + + +class ApiListCompetitionsRequest(KaggleObject): + r""" + Attributes: + group (CompetitionListTab) + Filter competitions by a particular group (default is 'general'). + One of 'general', 'entered' and 'inClass'. + category (HostSegment) + Filter competitions by a particular category (default is 'all'). + One of 'all', 'featured', 'research', 'recruitment', 'gettingStarted', + 'masters', 'playground'. + sort_by (CompetitionSortBy) + Sort the results (default is 'latestDeadline'). + One of 'grouped', 'prize', 'earliestDeadline', 'latestDeadline', + 'numberOfTeams', 'recentlyCreated'. + search (str) + Filter competitions by search terms. + page (int) + Page number (default is 1). + """ + + def __init__(self): + self._group = None + self._category = None + self._sort_by = None + self._search = None + self._page = None + self._freeze() + + @property + def group(self) -> 'CompetitionListTab': + r""" + Filter competitions by a particular group (default is 'general'). + One of 'general', 'entered' and 'inClass'. + """ + return self._group or CompetitionListTab.COMPETITION_LIST_TAB_GENERAL + + @group.setter + def group(self, group: 'CompetitionListTab'): + if group is None: + del self.group + return + if not isinstance(group, CompetitionListTab): + raise TypeError('group must be of type CompetitionListTab') + self._group = group + + @property + def category(self) -> 'HostSegment': + r""" + Filter competitions by a particular category (default is 'all'). + One of 'all', 'featured', 'research', 'recruitment', 'gettingStarted', + 'masters', 'playground'. + """ + return self._category or HostSegment.HOST_SEGMENT_UNSPECIFIED + + @category.setter + def category(self, category: 'HostSegment'): + if category is None: + del self.category + return + if not isinstance(category, HostSegment): + raise TypeError('category must be of type HostSegment') + self._category = category + + @property + def sort_by(self) -> 'CompetitionSortBy': + r""" + Sort the results (default is 'latestDeadline'). + One of 'grouped', 'prize', 'earliestDeadline', 'latestDeadline', + 'numberOfTeams', 'recentlyCreated'. + """ + return self._sort_by or CompetitionSortBy.COMPETITION_SORT_BY_GROUPED + + @sort_by.setter + def sort_by(self, sort_by: 'CompetitionSortBy'): + if sort_by is None: + del self.sort_by + return + if not isinstance(sort_by, CompetitionSortBy): + raise TypeError('sort_by must be of type CompetitionSortBy') + self._sort_by = sort_by + + @property + def search(self) -> str: + """Filter competitions by search terms.""" + return self._search or "" + + @search.setter + def search(self, search: str): + if search is None: + del self.search + return + if not isinstance(search, str): + raise TypeError('search must be of type str') + self._search = search + + @property + def page(self) -> int: + """Page number (default is 1).""" + return self._page or 0 + + @page.setter + def page(self, page: int): + if page is None: + del self.page + return + if not isinstance(page, int): + raise TypeError('page must be of type int') + self._page = page + + + def endpoint(self): + path = '/api/v1/competitions/list' + return path.format_map(self.to_field_map(self)) + +class ApiListCompetitionsResponse(KaggleObject): + r""" + Attributes: + competitions (ApiCompetition) + """ + + def __init__(self): + self._competitions = [] + self._freeze() + + @property + def competitions(self) -> Optional[List[Optional['ApiCompetition']]]: + return self._competitions + + @competitions.setter + def competitions(self, competitions: Optional[List[Optional['ApiCompetition']]]): + if competitions is None: + del self.competitions + return + if not isinstance(competitions, list): + raise TypeError('competitions must be of type list') + if not all([isinstance(t, ApiCompetition) for t in competitions]): + raise TypeError('competitions must contain only items of type ApiCompetition') + self._competitions = competitions + + + @classmethod + def prepare_from(cls, http_response): + return cls.from_dict({'competitions': json.loads(http_response.text)}) + +class ApiListDataFilesRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + Competition name. Example: 'titanic'. + page_size (int) + page_token (str) + """ + + def __init__(self): + self._competition_name = "" + self._page_size = None + self._page_token = None + self._freeze() + + @property + def competition_name(self) -> str: + """Competition name. Example: 'titanic'.""" + return self._competition_name + + @competition_name.setter + def competition_name(self, competition_name: str): + if competition_name is None: + del self.competition_name + return + if not isinstance(competition_name, str): + raise TypeError('competition_name must be of type str') + self._competition_name = competition_name + + @property + def page_size(self) -> int: + return self._page_size or 0 + + @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 or "" + + @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 + + + def endpoint(self): + path = '/api/v1/competitions/data/list/{competition_name}' + return path.format_map(self.to_field_map(self)) + +class ApiListDataFilesResponse(KaggleObject): + r""" + Attributes: + files (ApiDataFile) + next_page_token (str) + """ + + def __init__(self): + self._files = [] + self._next_page_token = "" + self._freeze() + + @property + def files(self) -> Optional[List[Optional['ApiDataFile']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiDataFile']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiDataFile) for t in files]): + raise TypeError('files must contain only items of type ApiDataFile') + self._files = files + + @property + def next_page_token(self) -> str: + return self._next_page_token + + @next_page_token.setter + def next_page_token(self, next_page_token: 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 + + +class ApiListSubmissionsRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + sort_by (SubmissionSortBy) + group (SubmissionGroup) + page (int) + """ + + def __init__(self): + self._competition_name = "" + self._sort_by = SubmissionSortBy.SUBMISSION_SORT_BY_DATE + self._group = SubmissionGroup.SUBMISSION_GROUP_ALL + self._page = None + self._freeze() + + @property + def competition_name(self) -> str: + return self._competition_name + + @competition_name.setter + def competition_name(self, competition_name: str): + if competition_name is None: + del self.competition_name + return + if not isinstance(competition_name, str): + raise TypeError('competition_name must be of type str') + self._competition_name = competition_name + + @property + def sort_by(self) -> 'SubmissionSortBy': + return self._sort_by + + @sort_by.setter + def sort_by(self, sort_by: 'SubmissionSortBy'): + if sort_by is None: + del self.sort_by + return + if not isinstance(sort_by, SubmissionSortBy): + raise TypeError('sort_by must be of type SubmissionSortBy') + self._sort_by = sort_by + + @property + def group(self) -> 'SubmissionGroup': + return self._group + + @group.setter + def group(self, group: 'SubmissionGroup'): + if group is None: + del self.group + return + if not isinstance(group, SubmissionGroup): + raise TypeError('group must be of type SubmissionGroup') + self._group = group + + @property + def page(self) -> int: + return self._page or 0 + + @page.setter + def page(self, page: int): + if page is None: + del self.page + return + if not isinstance(page, int): + raise TypeError('page must be of type int') + self._page = page + + + def endpoint(self): + path = '/api/v1/competitions/submissions/list/{competition_name}' + return path.format_map(self.to_field_map(self)) + +class ApiListSubmissionsResponse(KaggleObject): + r""" + Attributes: + submissions (ApiSubmission) + """ + + def __init__(self): + self._submissions = [] + self._freeze() + + @property + def submissions(self) -> Optional[List[Optional['ApiSubmission']]]: + return self._submissions + + @submissions.setter + def submissions(self, submissions: Optional[List[Optional['ApiSubmission']]]): + 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, ApiSubmission) for t in submissions]): + raise TypeError('submissions must contain only items of type ApiSubmission') + self._submissions = submissions + + + @classmethod + def prepare_from(cls, http_response): + return cls.from_dict({'submissions': json.loads(http_response.text)}) + +class ApiStartSubmissionUploadRequest(KaggleObject): + r""" + Attributes: + competition_name (str) + content_length (int) + last_modified_epoch_seconds (int) + file_name (str) + Comes from form upload + """ + + def __init__(self): + self._competition_name = None + self._content_length = 0 + self._last_modified_epoch_seconds = 0 + self._file_name = "" + self._freeze() + + @property + def competition_name(self) -> str: + return self._competition_name or "" + + @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 content_length(self) -> int: + return self._content_length + + @content_length.setter + def content_length(self, content_length: int): + if content_length is None: + del self.content_length + return + if not isinstance(content_length, int): + raise TypeError('content_length must be of type int') + self._content_length = content_length + + @property + def last_modified_epoch_seconds(self) -> int: + return self._last_modified_epoch_seconds + + @last_modified_epoch_seconds.setter + def last_modified_epoch_seconds(self, last_modified_epoch_seconds: int): + if last_modified_epoch_seconds is None: + del self.last_modified_epoch_seconds + return + if not isinstance(last_modified_epoch_seconds, int): + raise TypeError('last_modified_epoch_seconds must be of type int') + self._last_modified_epoch_seconds = last_modified_epoch_seconds + + @property + def file_name(self) -> str: + """Comes from form upload""" + return self._file_name + + @file_name.setter + def file_name(self, file_name: str): + if file_name is None: + del self.file_name + return + if not isinstance(file_name, str): + raise TypeError('file_name must be of type str') + self._file_name = file_name + + + def endpoint(self): + path = '/api/v1/competitions/{competition_name}/submissions/url/{content_length}/{last_modified_epoch_seconds}' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiStartSubmissionUploadResponse(KaggleObject): + r""" + Currently identical to StartBlobUploadResponse, but keeping separate since + they could change independently and this is a legacy V1 type. + + Attributes: + token (str) + create_url (str) + """ + + def __init__(self): + self._token = "" + self._create_url = "" + self._freeze() + + @property + def token(self) -> str: + return self._token + + @token.setter + def token(self, token: str): + if token is None: + del self.token + return + if not isinstance(token, str): + raise TypeError('token must be of type str') + self._token = token + + @property + def create_url(self) -> str: + return self._create_url + + @create_url.setter + def create_url(self, create_url: str): + if create_url is None: + del self.create_url + return + if not isinstance(create_url, str): + raise TypeError('create_url must be of type str') + self._create_url = create_url + + +class ApiSubmission(KaggleObject): + r""" + Attributes: + ref (int) + total_bytes (int) + date (datetime) + description (str) + error_description (str) + file_name (str) + public_score (str) + private_score (str) + status (SubmissionStatus) + submitted_by (str) + submitted_by_ref (str) + team_name (str) + url (str) + """ + + def __init__(self): + self._ref = 0 + self._total_bytes = None + self._date = None + self._description = None + self._error_description = None + self._file_name = None + self._public_score = None + self._private_score = None + self._status = SubmissionStatus.PENDING + self._submitted_by = None + self._submitted_by_ref = None + self._team_name = None + self._url = None + self._freeze() + + @property + def ref(self) -> int: + return self._ref + + @ref.setter + def ref(self, ref: int): + if ref is None: + del self.ref + return + if not isinstance(ref, int): + raise TypeError('ref must be of type int') + self._ref = ref + + @property + def total_bytes(self) -> int: + return self._total_bytes or 0 + + @total_bytes.setter + def total_bytes(self, total_bytes: int): + if total_bytes is None: + del self.total_bytes + return + if not isinstance(total_bytes, int): + raise TypeError('total_bytes must be of type int') + self._total_bytes = total_bytes + + @property + def date(self) -> datetime: + return self._date + + @date.setter + def date(self, date: datetime): + if date is None: + del self.date + return + if not isinstance(date, datetime): + raise TypeError('date must be of type datetime') + self._date = date + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def error_description(self) -> str: + return self._error_description or "" + + @error_description.setter + def error_description(self, error_description: str): + if error_description is None: + del self.error_description + return + if not isinstance(error_description, str): + raise TypeError('error_description must be of type str') + self._error_description = error_description + + @property + def file_name(self) -> str: + return self._file_name or "" + + @file_name.setter + def file_name(self, file_name: str): + if file_name is None: + del self.file_name + return + if not isinstance(file_name, str): + raise TypeError('file_name must be of type str') + self._file_name = file_name + + @property + def public_score(self) -> str: + return self._public_score or "" + + @public_score.setter + def public_score(self, public_score: str): + if public_score is None: + del self.public_score + return + if not isinstance(public_score, str): + raise TypeError('public_score must be of type str') + self._public_score = public_score + + @property + def private_score(self) -> str: + return self._private_score or "" + + @private_score.setter + def private_score(self, private_score: str): + if private_score is None: + del self.private_score + return + if not isinstance(private_score, str): + raise TypeError('private_score must be of type str') + self._private_score = private_score + + @property + def status(self) -> 'SubmissionStatus': + return self._status + + @status.setter + def status(self, status: 'SubmissionStatus'): + if status is None: + del self.status + return + if not isinstance(status, SubmissionStatus): + raise TypeError('status must be of type SubmissionStatus') + self._status = status + + @property + def submitted_by(self) -> str: + return self._submitted_by or "" + + @submitted_by.setter + def submitted_by(self, submitted_by: str): + if submitted_by is None: + del self.submitted_by + return + if not isinstance(submitted_by, str): + raise TypeError('submitted_by must be of type str') + self._submitted_by = submitted_by + + @property + def submitted_by_ref(self) -> str: + return self._submitted_by_ref or "" + + @submitted_by_ref.setter + def submitted_by_ref(self, submitted_by_ref: str): + if submitted_by_ref is None: + del self.submitted_by_ref + return + if not isinstance(submitted_by_ref, str): + raise TypeError('submitted_by_ref must be of type str') + self._submitted_by_ref = submitted_by_ref + + @property + def team_name(self) -> str: + return self._team_name or "" + + @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 + + @property + def url(self) -> str: + return self._url or "" + + @url.setter + def url(self, url: str): + if url is None: + del self.url + return + if not isinstance(url, str): + raise TypeError('url must be of type str') + self._url = url + + +class ApiCompetition(KaggleObject): + r""" + Attributes: + id (int) + ref (str) + title (str) + url (str) + description (str) + organization_name (str) + organization_ref (str) + category (str) + reward (str) + tags (ApiCategory) + deadline (datetime) + kernel_count (int) + team_count (int) + user_has_entered (bool) + user_rank (int) + merger_deadline (datetime) + new_entrant_deadline (datetime) + enabled_date (datetime) + max_daily_submissions (int) + max_team_size (int) + evaluation_metric (str) + awards_points (bool) + is_kernels_submissions_only (bool) + submissions_disabled (bool) + """ + + def __init__(self): + self._id = 0 + self._ref = "" + self._title = None + self._url = None + self._description = None + self._organization_name = None + self._organization_ref = None + self._category = None + self._reward = None + self._tags = [] + self._deadline = None + self._kernel_count = 0 + self._team_count = 0 + self._user_has_entered = False + self._user_rank = None + self._merger_deadline = None + self._new_entrant_deadline = None + self._enabled_date = None + self._max_daily_submissions = 0 + self._max_team_size = None + self._evaluation_metric = None + self._awards_points = False + self._is_kernels_submissions_only = False + self._submissions_disabled = False + self._freeze() + + @property + def id(self) -> int: + return self._id + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def ref(self) -> str: + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def title(self) -> str: + return self._title or "" + + @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 url(self) -> str: + return self._url or "" + + @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 description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def organization_name(self) -> str: + return self._organization_name or "" + + @organization_name.setter + def organization_name(self, organization_name: str): + if organization_name is None: + del self.organization_name + return + if not isinstance(organization_name, str): + raise TypeError('organization_name must be of type str') + self._organization_name = organization_name + + @property + def organization_ref(self) -> str: + return self._organization_ref or "" + + @organization_ref.setter + def organization_ref(self, organization_ref: str): + if organization_ref is None: + del self.organization_ref + return + if not isinstance(organization_ref, str): + raise TypeError('organization_ref must be of type str') + self._organization_ref = organization_ref + + @property + def category(self) -> str: + return self._category or "" + + @category.setter + def category(self, category: str): + if category is None: + del self.category + return + if not isinstance(category, str): + raise TypeError('category must be of type str') + self._category = category + + @property + def reward(self) -> str: + return self._reward or "" + + @reward.setter + def reward(self, reward: str): + if reward is None: + del self.reward + return + if not isinstance(reward, str): + raise TypeError('reward must be of type str') + self._reward = reward + + @property + def tags(self) -> Optional[List[Optional['ApiCategory']]]: + return self._tags + + @tags.setter + def tags(self, tags: Optional[List[Optional['ApiCategory']]]): + if tags is None: + del self.tags + return + if not isinstance(tags, list): + raise TypeError('tags must be of type list') + if not all([isinstance(t, ApiCategory) for t in tags]): + raise TypeError('tags must contain only items of type ApiCategory') + self._tags = tags + + @property + def deadline(self) -> datetime: + return self._deadline + + @deadline.setter + def deadline(self, deadline: datetime): + if deadline is None: + del self.deadline + return + if not isinstance(deadline, datetime): + raise TypeError('deadline must be of type datetime') + self._deadline = deadline + + @property + def kernel_count(self) -> int: + return self._kernel_count + + @kernel_count.setter + def kernel_count(self, kernel_count: int): + if kernel_count is None: + del self.kernel_count + return + if not isinstance(kernel_count, int): + raise TypeError('kernel_count must be of type int') + self._kernel_count = kernel_count + + @property + def team_count(self) -> int: + return self._team_count + + @team_count.setter + def team_count(self, team_count: int): + if team_count is None: + del self.team_count + return + if not isinstance(team_count, int): + raise TypeError('team_count must be of type int') + self._team_count = team_count + + @property + def user_has_entered(self) -> bool: + return self._user_has_entered + + @user_has_entered.setter + def user_has_entered(self, user_has_entered: bool): + if user_has_entered is None: + del self.user_has_entered + return + if not isinstance(user_has_entered, bool): + raise TypeError('user_has_entered must be of type bool') + self._user_has_entered = user_has_entered + + @property + def user_rank(self) -> int: + return self._user_rank or 0 + + @user_rank.setter + def user_rank(self, user_rank: int): + if user_rank is None: + del self.user_rank + return + if not isinstance(user_rank, int): + raise TypeError('user_rank must be of type int') + self._user_rank = user_rank + + @property + def merger_deadline(self) -> datetime: + return self._merger_deadline + + @merger_deadline.setter + def merger_deadline(self, merger_deadline: datetime): + if merger_deadline is None: + del self.merger_deadline + return + if not isinstance(merger_deadline, datetime): + raise TypeError('merger_deadline must be of type datetime') + self._merger_deadline = merger_deadline + + @property + def new_entrant_deadline(self) -> datetime: + return self._new_entrant_deadline + + @new_entrant_deadline.setter + def new_entrant_deadline(self, new_entrant_deadline: datetime): + if new_entrant_deadline is None: + del self.new_entrant_deadline + return + if not isinstance(new_entrant_deadline, datetime): + raise TypeError('new_entrant_deadline must be of type datetime') + self._new_entrant_deadline = new_entrant_deadline + + @property + def enabled_date(self) -> datetime: + return self._enabled_date + + @enabled_date.setter + def enabled_date(self, enabled_date: datetime): + if enabled_date is None: + del self.enabled_date + return + if not isinstance(enabled_date, datetime): + raise TypeError('enabled_date must be of type datetime') + self._enabled_date = enabled_date + + @property + def max_daily_submissions(self) -> int: + return self._max_daily_submissions + + @max_daily_submissions.setter + def max_daily_submissions(self, max_daily_submissions: int): + if max_daily_submissions is None: + del self.max_daily_submissions + return + if not isinstance(max_daily_submissions, int): + raise TypeError('max_daily_submissions must be of type int') + self._max_daily_submissions = max_daily_submissions + + @property + def max_team_size(self) -> int: + return self._max_team_size or 0 + + @max_team_size.setter + def max_team_size(self, max_team_size: int): + if max_team_size is None: + del self.max_team_size + return + if not isinstance(max_team_size, int): + raise TypeError('max_team_size must be of type int') + self._max_team_size = max_team_size + + @property + def evaluation_metric(self) -> str: + return self._evaluation_metric or "" + + @evaluation_metric.setter + def evaluation_metric(self, evaluation_metric: str): + if evaluation_metric is None: + del self.evaluation_metric + return + if not isinstance(evaluation_metric, str): + raise TypeError('evaluation_metric must be of type str') + self._evaluation_metric = evaluation_metric + + @property + def awards_points(self) -> bool: + return self._awards_points + + @awards_points.setter + def awards_points(self, awards_points: bool): + if awards_points is None: + del self.awards_points + return + if not isinstance(awards_points, bool): + raise TypeError('awards_points must be of type bool') + self._awards_points = awards_points + + @property + def is_kernels_submissions_only(self) -> bool: + return self._is_kernels_submissions_only + + @is_kernels_submissions_only.setter + def is_kernels_submissions_only(self, is_kernels_submissions_only: bool): + if is_kernels_submissions_only is None: + del self.is_kernels_submissions_only + return + if not isinstance(is_kernels_submissions_only, bool): + raise TypeError('is_kernels_submissions_only must be of type bool') + self._is_kernels_submissions_only = is_kernels_submissions_only + + @property + def submissions_disabled(self) -> bool: + return self._submissions_disabled + + @submissions_disabled.setter + def submissions_disabled(self, submissions_disabled: bool): + if submissions_disabled is None: + del self.submissions_disabled + return + if not isinstance(submissions_disabled, bool): + raise TypeError('submissions_disabled must be of type bool') + self._submissions_disabled = submissions_disabled + + +class ApiDataFile(KaggleObject): + r""" + Attributes: + ref (str) + name (str) + description (str) + total_bytes (int) + url (str) + creation_date (datetime) + """ + + def __init__(self): + self._ref = "" + self._name = None + self._description = None + self._total_bytes = 0 + self._url = None + self._creation_date = None + self._freeze() + + @property + def ref(self) -> str: + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def name(self) -> str: + return self._name or "" + + @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 description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def total_bytes(self) -> int: + return self._total_bytes + + @total_bytes.setter + def total_bytes(self, total_bytes: int): + if total_bytes is None: + del self.total_bytes + return + if not isinstance(total_bytes, int): + raise TypeError('total_bytes must be of type int') + self._total_bytes = total_bytes + + @property + def url(self) -> str: + return self._url or "" + + @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 creation_date(self) -> datetime: + return self._creation_date + + @creation_date.setter + def creation_date(self, creation_date: datetime): + if creation_date is None: + del self.creation_date + return + if not isinstance(creation_date, datetime): + raise TypeError('creation_date must be of type datetime') + self._creation_date = creation_date + + +class ApiCategory(KaggleObject): + r""" + TODO(erdalsivri): Consider reusing with Kaggle.Sdk.Datasets.ApiCategory. + + Attributes: + ref (str) + name (str) + description (str) + full_path (str) + competition_count (int) + dataset_count (int) + script_count (int) + total_count (int) + """ + + def __init__(self): + self._ref = "" + self._name = None + self._description = None + self._full_path = None + self._competition_count = 0 + self._dataset_count = 0 + self._script_count = 0 + self._total_count = 0 + self._freeze() + + @property + def ref(self) -> str: + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def name(self) -> str: + return self._name or "" + + @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 description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def full_path(self) -> str: + return self._full_path or "" + + @full_path.setter + def full_path(self, full_path: str): + if full_path is None: + del self.full_path + return + if not isinstance(full_path, str): + raise TypeError('full_path must be of type str') + self._full_path = full_path + + @property + def competition_count(self) -> int: + return self._competition_count + + @competition_count.setter + def competition_count(self, competition_count: int): + if competition_count is None: + del self.competition_count + return + if not isinstance(competition_count, int): + raise TypeError('competition_count must be of type int') + self._competition_count = competition_count + + @property + def dataset_count(self) -> int: + return self._dataset_count + + @dataset_count.setter + def dataset_count(self, dataset_count: int): + if dataset_count is None: + del self.dataset_count + return + if not isinstance(dataset_count, int): + raise TypeError('dataset_count must be of type int') + self._dataset_count = dataset_count + + @property + def script_count(self) -> int: + return self._script_count + + @script_count.setter + def script_count(self, script_count: int): + if script_count is None: + del self.script_count + return + if not isinstance(script_count, int): + raise TypeError('script_count must be of type int') + self._script_count = script_count + + @property + def total_count(self) -> int: + return self._total_count + + @total_count.setter + def total_count(self, total_count: int): + if total_count is None: + del self.total_count + return + if not isinstance(total_count, int): + raise TypeError('total_count must be of type int') + self._total_count = total_count + + +ApiCreateSubmissionRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), + FieldMetadata("blobFileTokens", "blob_file_tokens", "_blob_file_tokens", str, "", PredefinedSerializer()), + FieldMetadata("submissionDescription", "submission_description", "_submission_description", str, None, PredefinedSerializer(), optional=True), +] + +ApiCreateSubmissionResponse._fields = [ + FieldMetadata("message", "message", "_message", str, "", PredefinedSerializer()), +] + +ApiDownloadDataFileRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), + FieldMetadata("fileName", "file_name", "_file_name", str, "", PredefinedSerializer()), +] + +ApiDownloadDataFilesRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), +] + +ApiDownloadLeaderboardRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), +] + +ApiGetLeaderboardRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), +] + +ApiGetLeaderboardResponse._fields = [ + FieldMetadata("submissions", "submissions", "_submissions", ApiLeaderboardSubmission, [], ListSerializer(KaggleObjectSerializer())), +] + +ApiLeaderboardSubmission._fields = [ + FieldMetadata("teamId", "team_id", "_team_id", int, 0, PredefinedSerializer()), + FieldMetadata("teamName", "team_name", "_team_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("submissionDate", "submission_date", "_submission_date", datetime, None, DateTimeSerializer()), + FieldMetadata("score", "score", "_score", str, None, PredefinedSerializer(), optional=True), +] + +ApiListCompetitionsRequest._fields = [ + FieldMetadata("group", "group", "_group", CompetitionListTab, None, EnumSerializer(), optional=True), + FieldMetadata("category", "category", "_category", HostSegment, None, EnumSerializer(), optional=True), + FieldMetadata("sortBy", "sort_by", "_sort_by", CompetitionSortBy, None, EnumSerializer(), optional=True), + FieldMetadata("search", "search", "_search", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("page", "page", "_page", int, None, PredefinedSerializer(), optional=True), +] + +ApiListCompetitionsResponse._fields = [ + FieldMetadata("competitions", "competitions", "_competitions", ApiCompetition, [], ListSerializer(KaggleObjectSerializer())), +] + +ApiListDataFilesRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), + FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True), +] + +ApiListDataFilesResponse._fields = [ + FieldMetadata("files", "files", "_files", ApiDataFile, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()), +] + +ApiListSubmissionsRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), + FieldMetadata("sortBy", "sort_by", "_sort_by", SubmissionSortBy, SubmissionSortBy.SUBMISSION_SORT_BY_DATE, EnumSerializer()), + FieldMetadata("group", "group", "_group", SubmissionGroup, SubmissionGroup.SUBMISSION_GROUP_ALL, EnumSerializer()), + FieldMetadata("page", "page", "_page", int, None, PredefinedSerializer(), optional=True), +] + +ApiListSubmissionsResponse._fields = [ + FieldMetadata("submissions", "submissions", "_submissions", ApiSubmission, [], ListSerializer(KaggleObjectSerializer())), +] + +ApiStartSubmissionUploadRequest._fields = [ + FieldMetadata("competitionName", "competition_name", "_competition_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("contentLength", "content_length", "_content_length", int, 0, PredefinedSerializer()), + FieldMetadata("lastModifiedEpochSeconds", "last_modified_epoch_seconds", "_last_modified_epoch_seconds", int, 0, PredefinedSerializer()), + FieldMetadata("fileName", "file_name", "_file_name", str, "", PredefinedSerializer()), +] + +ApiStartSubmissionUploadResponse._fields = [ + FieldMetadata("token", "token", "_token", str, "", PredefinedSerializer()), + FieldMetadata("createUrl", "create_url", "_create_url", str, "", PredefinedSerializer()), +] + +ApiSubmission._fields = [ + FieldMetadata("ref", "ref", "_ref", int, 0, PredefinedSerializer()), + FieldMetadata("totalBytes", "total_bytes", "_total_bytes", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("date", "date", "_date", datetime, None, DateTimeSerializer()), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("errorDescription", "error_description", "_error_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("fileName", "file_name", "_file_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("publicScore", "public_score", "_public_score", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("privateScore", "private_score", "_private_score", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("status", "status", "_status", SubmissionStatus, SubmissionStatus.PENDING, EnumSerializer()), + FieldMetadata("submittedBy", "submitted_by", "_submitted_by", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("submittedByRef", "submitted_by_ref", "_submitted_by_ref", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("teamName", "team_name", "_team_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True), +] + +ApiCompetition._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("title", "title", "_title", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("organizationName", "organization_name", "_organization_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("organizationRef", "organization_ref", "_organization_ref", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("category", "category", "_category", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("reward", "reward", "_reward", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("tags", "tags", "_tags", ApiCategory, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("deadline", "deadline", "_deadline", datetime, None, DateTimeSerializer()), + FieldMetadata("kernelCount", "kernel_count", "_kernel_count", int, 0, PredefinedSerializer()), + FieldMetadata("teamCount", "team_count", "_team_count", int, 0, PredefinedSerializer()), + FieldMetadata("userHasEntered", "user_has_entered", "_user_has_entered", bool, False, PredefinedSerializer()), + FieldMetadata("userRank", "user_rank", "_user_rank", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("mergerDeadline", "merger_deadline", "_merger_deadline", datetime, None, DateTimeSerializer()), + FieldMetadata("newEntrantDeadline", "new_entrant_deadline", "_new_entrant_deadline", datetime, None, DateTimeSerializer()), + FieldMetadata("enabledDate", "enabled_date", "_enabled_date", datetime, None, DateTimeSerializer()), + FieldMetadata("maxDailySubmissions", "max_daily_submissions", "_max_daily_submissions", int, 0, PredefinedSerializer()), + FieldMetadata("maxTeamSize", "max_team_size", "_max_team_size", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("evaluationMetric", "evaluation_metric", "_evaluation_metric", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("awardsPoints", "awards_points", "_awards_points", bool, False, PredefinedSerializer()), + FieldMetadata("isKernelsSubmissionsOnly", "is_kernels_submissions_only", "_is_kernels_submissions_only", bool, False, PredefinedSerializer()), + FieldMetadata("submissionsDisabled", "submissions_disabled", "_submissions_disabled", bool, False, PredefinedSerializer()), +] + +ApiDataFile._fields = [ + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("totalBytes", "total_bytes", "_total_bytes", int, 0, PredefinedSerializer()), + FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("creationDate", "creation_date", "_creation_date", datetime, None, DateTimeSerializer()), +] + +ApiCategory._fields = [ + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("fullPath", "full_path", "_full_path", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("competitionCount", "competition_count", "_competition_count", int, 0, PredefinedSerializer()), + FieldMetadata("datasetCount", "dataset_count", "_dataset_count", int, 0, PredefinedSerializer()), + FieldMetadata("scriptCount", "script_count", "_script_count", int, 0, PredefinedSerializer()), + FieldMetadata("totalCount", "total_count", "_total_count", int, 0, PredefinedSerializer()), +] + diff --git a/kagglesdk/competitions/types/competition_enums.py b/kagglesdk/competitions/types/competition_enums.py new file mode 100644 index 0000000..ea52f12 --- /dev/null +++ b/kagglesdk/competitions/types/competition_enums.py @@ -0,0 +1,52 @@ +import enum + +class CompetitionListTab(enum.Enum): + COMPETITION_LIST_TAB_GENERAL = 0 + """TODO(aip.dev/126): (-- api-linter: core::0126::unspecified=disabled --)""" + COMPETITION_LIST_TAB_ENTERED = 1 + COMPETITION_LIST_TAB_COMMUNITY = 2 + COMPETITION_LIST_TAB_HOSTED = 3 + COMPETITION_LIST_TAB_UNLAUNCHED = 4 + COMPETITION_LIST_TAB_UNLAUNCHED_COMMUNITY = 5 + +class CompetitionSortBy(enum.Enum): + COMPETITION_SORT_BY_GROUPED = 0 + """TODO(aip.dev/126): (-- api-linter: core::0126::unspecified=disabled --)""" + COMPETITION_SORT_BY_BEST = 1 + COMPETITION_SORT_BY_PRIZE = 2 + COMPETITION_SORT_BY_EARLIEST_DEADLINE = 3 + COMPETITION_SORT_BY_LATEST_DEADLINE = 4 + COMPETITION_SORT_BY_NUMBER_OF_TEAMS = 5 + COMPETITION_SORT_BY_RELEVANCE = 6 + COMPETITION_SORT_BY_RECENTLY_CREATED = 7 + +class HostSegment(enum.Enum): + r""" + NOTE: Keep in Sync with Kaggle.Entities.HostSegment until migrated! Also keep + the comment in + competition_service.ListCompetitionsRequest.Selector.host_segment_id_filter + up to date + """ + HOST_SEGMENT_UNSPECIFIED = 0 + HOST_SEGMENT_FEATURED = 1 + HOST_SEGMENT_GETTING_STARTED = 5 + HOST_SEGMENT_MASTERS = 6 + HOST_SEGMENT_PLAYGROUND = 8 + HOST_SEGMENT_RECRUITMENT = 3 + HOST_SEGMENT_RESEARCH = 2 + HOST_SEGMENT_COMMUNITY = 10 + HOST_SEGMENT_ANALYTICS = 11 + +class SubmissionGroup(enum.Enum): + SUBMISSION_GROUP_ALL = 0 + """TODO(aip.dev/126): (-- api-linter: core::0126::unspecified=disabled --)""" + SUBMISSION_GROUP_SUCCESSFUL = 1 + SUBMISSION_GROUP_SELECTED = 2 + +class SubmissionSortBy(enum.Enum): + SUBMISSION_SORT_BY_DATE = 0 + """TODO(aip.dev/126): (-- api-linter: core::0126::unspecified=disabled --)""" + SUBMISSION_SORT_BY_NAME = 1 + SUBMISSION_SORT_BY_PRIVATE_SCORE = 2 + SUBMISSION_SORT_BY_PUBLIC_SCORE = 3 + diff --git a/kagglesdk/competitions/types/submission_status.py b/kagglesdk/competitions/types/submission_status.py new file mode 100644 index 0000000..14aea36 --- /dev/null +++ b/kagglesdk/competitions/types/submission_status.py @@ -0,0 +1,9 @@ +import enum + +class SubmissionStatus(enum.Enum): + """TODO(aip.dev/216): (-- api-linter: core::0216::synonyms=disabled --)""" + PENDING = 0 + """TODO(aip.dev/126): (-- api-linter: core::0126::unspecified=disabled --)""" + COMPLETE = 1 + ERROR = 2 + diff --git a/kagglesdk/datasets/__init__.py b/kagglesdk/datasets/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/datasets/services/__init__.py b/kagglesdk/datasets/services/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/datasets/services/dataset_api_service.py b/kagglesdk/datasets/services/dataset_api_service.py new file mode 100644 index 0000000..a80e6d0 --- /dev/null +++ b/kagglesdk/datasets/services/dataset_api_service.py @@ -0,0 +1,170 @@ +from kagglesdk.common.types.http_redirect import HttpRedirect +from kagglesdk.datasets.types.dataset_api_service import ApiCreateDatasetRequest, ApiCreateDatasetResponse, ApiCreateDatasetVersionByIdRequest, ApiCreateDatasetVersionRequest, ApiDataset, ApiDeleteDatasetRequest, ApiDeleteDatasetResponse, ApiDownloadDatasetRawRequest, ApiDownloadDatasetRequest, ApiGetDatasetMetadataRequest, ApiGetDatasetMetadataResponse, ApiGetDatasetRequest, ApiGetDatasetStatusRequest, ApiGetDatasetStatusResponse, ApiListDatasetFilesRequest, ApiListDatasetFilesResponse, ApiListDatasetsRequest, ApiListDatasetsResponse, ApiUpdateDatasetMetadataRequest, ApiUpdateDatasetMetadataResponse, ApiUploadDatasetFileRequest, ApiUploadDatasetFileResponse +from kagglesdk.kaggle_http_client import KaggleHttpClient + +class DatasetApiClient(object): + + def __init__(self, client: KaggleHttpClient): + self._client = client + + def list_datasets(self, request: ApiListDatasetsRequest = None) -> ApiListDatasetsResponse: + r""" + Args: + request (ApiListDatasetsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListDatasetsRequest() + + return self._client.call("datasets.DatasetApiService", "ApiListDatasets", request, ApiListDatasetsResponse) + + def get_dataset(self, request: ApiGetDatasetRequest = None) -> ApiDataset: + r""" + Args: + request (ApiGetDatasetRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetDatasetRequest() + + return self._client.call("datasets.DatasetApiService", "ApiGetDataset", request, ApiDataset) + + def list_dataset_files(self, request: ApiListDatasetFilesRequest = None) -> ApiListDatasetFilesResponse: + r""" + Args: + request (ApiListDatasetFilesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListDatasetFilesRequest() + + return self._client.call("datasets.DatasetApiService", "ApiListDatasetFiles", request, ApiListDatasetFilesResponse) + + def get_dataset_metadata(self, request: ApiGetDatasetMetadataRequest = None) -> ApiGetDatasetMetadataResponse: + r""" + Args: + request (ApiGetDatasetMetadataRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetDatasetMetadataRequest() + + return self._client.call("datasets.DatasetApiService", "ApiGetDatasetMetadata", request, ApiGetDatasetMetadataResponse) + + def update_dataset_metadata(self, request: ApiUpdateDatasetMetadataRequest = None) -> ApiUpdateDatasetMetadataResponse: + r""" + Args: + request (ApiUpdateDatasetMetadataRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiUpdateDatasetMetadataRequest() + + return self._client.call("datasets.DatasetApiService", "ApiUpdateDatasetMetadata", request, ApiUpdateDatasetMetadataResponse) + + def download_dataset(self, request: ApiDownloadDatasetRequest = None) -> HttpRedirect: + r""" + Args: + request (ApiDownloadDatasetRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDownloadDatasetRequest() + + return self._client.call("datasets.DatasetApiService", "ApiDownloadDataset", request, HttpRedirect) + + def download_dataset_raw(self, request: ApiDownloadDatasetRawRequest = None) -> HttpRedirect: + r""" + Note: This API method has extremely low usage, and can be considered for + deprecation. The existing DownloadDataset RPC, with `raw=true` set on the + request, is equivalent. + + Args: + request (ApiDownloadDatasetRawRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDownloadDatasetRawRequest() + + return self._client.call("datasets.DatasetApiService", "ApiDownloadDatasetRaw", request, HttpRedirect) + + def create_dataset_version(self, request: ApiCreateDatasetVersionRequest = None) -> ApiCreateDatasetResponse: + r""" + Args: + request (ApiCreateDatasetVersionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateDatasetVersionRequest() + + return self._client.call("datasets.DatasetApiService", "ApiCreateDatasetVersion", request, ApiCreateDatasetResponse) + + def create_dataset_version_by_id(self, request: ApiCreateDatasetVersionByIdRequest = None) -> ApiCreateDatasetResponse: + r""" + Args: + request (ApiCreateDatasetVersionByIdRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateDatasetVersionByIdRequest() + + return self._client.call("datasets.DatasetApiService", "ApiCreateDatasetVersionById", request, ApiCreateDatasetResponse) + + def create_dataset(self, request: ApiCreateDatasetRequest = None) -> ApiCreateDatasetResponse: + r""" + Args: + request (ApiCreateDatasetRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateDatasetRequest() + + return self._client.call("datasets.DatasetApiService", "ApiCreateDataset", request, ApiCreateDatasetResponse) + + def get_dataset_status(self, request: ApiGetDatasetStatusRequest = None) -> ApiGetDatasetStatusResponse: + r""" + Args: + request (ApiGetDatasetStatusRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetDatasetStatusRequest() + + return self._client.call("datasets.DatasetApiService", "ApiGetDatasetStatus", request, ApiGetDatasetStatusResponse) + + def upload_dataset_file(self, request: ApiUploadDatasetFileRequest = None) -> ApiUploadDatasetFileResponse: + r""" + Deprecated. Use the new unified BlobApiService#StartBlobUpload rpc. + + Args: + request (ApiUploadDatasetFileRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiUploadDatasetFileRequest() + + return self._client.call("datasets.DatasetApiService", "ApiUploadDatasetFile", request, ApiUploadDatasetFileResponse) + + def delete_dataset(self, request: ApiDeleteDatasetRequest = None) -> ApiDeleteDatasetResponse: + r""" + Args: + request (ApiDeleteDatasetRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDeleteDatasetRequest() + + return self._client.call("datasets.DatasetApiService", "ApiDeleteDataset", request, ApiDeleteDatasetResponse) diff --git a/kagglesdk/datasets/types/__init__.py b/kagglesdk/datasets/types/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/datasets/types/dataset_api_service.py b/kagglesdk/datasets/types/dataset_api_service.py new file mode 100644 index 0000000..b190b52 --- /dev/null +++ b/kagglesdk/datasets/types/dataset_api_service.py @@ -0,0 +1,2713 @@ +from datetime import datetime +from kagglesdk.datasets.types.dataset_enums import DatabundleVersionStatus, DatasetFileTypeGroup, DatasetLicenseGroup, DatasetSelectionGroup, DatasetSizeGroup, DatasetSortBy, DatasetViewedGroup +from kagglesdk.datasets.types.dataset_types import DatasetInfo, DatasetSettings +from kagglesdk.kaggle_object import * +from typing import Optional, List + +class ApiCreateDatasetRequest(KaggleObject): + r""" + Attributes: + id (int) + owner_slug (str) + slug (str) + title (str) + license_name (str) + is_private (bool) + files (ApiDatasetNewFile) + subtitle (str) + description (str) + category_ids (str) + """ + + def __init__(self): + self._id = None + self._owner_slug = None + self._slug = None + self._title = None + self._license_name = None + self._is_private = False + self._files = [] + self._subtitle = None + self._description = None + self._category_ids = [] + self._freeze() + + @property + def id(self) -> int: + return self._id or 0 + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def owner_slug(self) -> str: + return self._owner_slug or "" + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def slug(self) -> str: + return self._slug or "" + + @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 title(self) -> str: + return self._title or "" + + @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 license_name(self) -> str: + return self._license_name or "" + + @license_name.setter + def license_name(self, license_name: str): + if license_name is None: + del self.license_name + return + if not isinstance(license_name, str): + raise TypeError('license_name must be of type str') + self._license_name = license_name + + @property + def is_private(self) -> bool: + return self._is_private + + @is_private.setter + def is_private(self, is_private: bool): + if is_private is None: + del self.is_private + return + if not isinstance(is_private, bool): + raise TypeError('is_private must be of type bool') + self._is_private = is_private + + @property + def files(self) -> Optional[List[Optional['ApiDatasetNewFile']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiDatasetNewFile']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiDatasetNewFile) for t in files]): + raise TypeError('files must contain only items of type ApiDatasetNewFile') + self._files = files + + @property + def subtitle(self) -> str: + return self._subtitle or "" + + @subtitle.setter + def subtitle(self, subtitle: str): + if subtitle is None: + del self.subtitle + return + if not isinstance(subtitle, str): + raise TypeError('subtitle must be of type str') + self._subtitle = subtitle + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def category_ids(self) -> Optional[List[str]]: + return self._category_ids + + @category_ids.setter + def category_ids(self, category_ids: Optional[List[str]]): + if category_ids is None: + del self.category_ids + return + if not isinstance(category_ids, list): + raise TypeError('category_ids must be of type list') + if not all([isinstance(t, str) for t in category_ids]): + raise TypeError('category_ids must contain only items of type str') + self._category_ids = category_ids + + + def endpoint(self): + path = '/api/v1/datasets/create/new' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiCreateDatasetResponse(KaggleObject): + r""" + Attributes: + ref (str) + url (str) + status (str) + error (str) + invalid_tags (str) + """ + + def __init__(self): + self._ref = None + self._url = None + self._status = None + self._error = None + self._invalid_tags = [] + self._freeze() + + @property + def ref(self) -> str: + return self._ref or "" + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def url(self) -> str: + return self._url or "" + + @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 status(self) -> str: + return self._status or "" + + @status.setter + def status(self, status: str): + if status is None: + del self.status + return + if not isinstance(status, str): + raise TypeError('status must be of type str') + self._status = status + + @property + def error(self) -> str: + return self._error or "" + + @error.setter + def error(self, error: str): + if error is None: + del self.error + return + if not isinstance(error, str): + raise TypeError('error must be of type str') + self._error = error + + @property + def invalid_tags(self) -> Optional[List[str]]: + return self._invalid_tags + + @invalid_tags.setter + def invalid_tags(self, invalid_tags: Optional[List[str]]): + if invalid_tags is None: + del self.invalid_tags + return + if not isinstance(invalid_tags, list): + raise TypeError('invalid_tags must be of type list') + if not all([isinstance(t, str) for t in invalid_tags]): + raise TypeError('invalid_tags must contain only items of type str') + self._invalid_tags = invalid_tags + + +class ApiCreateDatasetVersionByIdRequest(KaggleObject): + r""" + Attributes: + id (int) + body (ApiCreateDatasetVersionRequestBody) + """ + + def __init__(self): + self._id = 0 + self._body = None + self._freeze() + + @property + def id(self) -> int: + return self._id + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def body(self) -> Optional['ApiCreateDatasetVersionRequestBody']: + return self._body + + @body.setter + def body(self, body: Optional['ApiCreateDatasetVersionRequestBody']): + if body is None: + del self.body + return + if not isinstance(body, ApiCreateDatasetVersionRequestBody): + raise TypeError('body must be of type ApiCreateDatasetVersionRequestBody') + self._body = body + + + def endpoint(self): + path = '/api/v1/datasets/create/version/{id}' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiCreateDatasetVersionRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + dataset_slug (str) + body (ApiCreateDatasetVersionRequestBody) + """ + + def __init__(self): + self._owner_slug = "" + self._dataset_slug = "" + self._body = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def dataset_slug(self) -> str: + return self._dataset_slug + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + @property + def body(self) -> Optional['ApiCreateDatasetVersionRequestBody']: + return self._body + + @body.setter + def body(self, body: Optional['ApiCreateDatasetVersionRequestBody']): + if body is None: + del self.body + return + if not isinstance(body, ApiCreateDatasetVersionRequestBody): + raise TypeError('body must be of type ApiCreateDatasetVersionRequestBody') + self._body = body + + + def endpoint(self): + path = '/api/v1/datasets/create/version/{owner_slug}/{dataset_slug}' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiCreateDatasetVersionRequestBody(KaggleObject): + r""" + Attributes: + version_notes (str) + delete_old_versions (bool) + files (ApiDatasetNewFile) + subtitle (str) + description (str) + category_ids (str) + """ + + def __init__(self): + self._version_notes = None + self._delete_old_versions = False + self._files = [] + self._subtitle = None + self._description = None + self._category_ids = [] + self._freeze() + + @property + def version_notes(self) -> str: + return self._version_notes or "" + + @version_notes.setter + def version_notes(self, version_notes: str): + if version_notes is None: + del self.version_notes + return + if not isinstance(version_notes, str): + raise TypeError('version_notes must be of type str') + self._version_notes = version_notes + + @property + def delete_old_versions(self) -> bool: + return self._delete_old_versions + + @delete_old_versions.setter + def delete_old_versions(self, delete_old_versions: bool): + if delete_old_versions is None: + del self.delete_old_versions + return + if not isinstance(delete_old_versions, bool): + raise TypeError('delete_old_versions must be of type bool') + self._delete_old_versions = delete_old_versions + + @property + def files(self) -> Optional[List[Optional['ApiDatasetNewFile']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiDatasetNewFile']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiDatasetNewFile) for t in files]): + raise TypeError('files must contain only items of type ApiDatasetNewFile') + self._files = files + + @property + def subtitle(self) -> str: + return self._subtitle or "" + + @subtitle.setter + def subtitle(self, subtitle: str): + if subtitle is None: + del self.subtitle + return + if not isinstance(subtitle, str): + raise TypeError('subtitle must be of type str') + self._subtitle = subtitle + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def category_ids(self) -> Optional[List[str]]: + return self._category_ids + + @category_ids.setter + def category_ids(self, category_ids: Optional[List[str]]): + if category_ids is None: + del self.category_ids + return + if not isinstance(category_ids, list): + raise TypeError('category_ids must be of type list') + if not all([isinstance(t, str) for t in category_ids]): + raise TypeError('category_ids must contain only items of type str') + self._category_ids = category_ids + + +class ApiDataset(KaggleObject): + r""" + Attributes: + id (int) + ref (str) + subtitle (str) + creator_name (str) + creator_url (str) + total_bytes (int) + url (str) + last_updated (datetime) + download_count (int) + is_private (bool) + is_featured (bool) + license_name (str) + description (str) + owner_name (str) + owner_ref (str) + kernel_count (int) + title (str) + topic_count (int) + view_count (int) + vote_count (int) + current_version_number (int) + usability_rating (float) + tags (ApiCategory) + files (ApiDatasetFile) + versions (ApiDatasetVersion) + """ + + def __init__(self): + self._id = 0 + self._ref = "" + self._subtitle = None + self._creator_name = None + self._creator_url = None + self._total_bytes = None + self._url = None + self._last_updated = None + self._download_count = 0 + self._is_private = False + self._is_featured = False + self._license_name = None + self._description = None + self._owner_name = None + self._owner_ref = None + self._kernel_count = 0 + self._title = None + self._topic_count = 0 + self._view_count = 0 + self._vote_count = 0 + self._current_version_number = None + self._usability_rating = None + self._tags = [] + self._files = [] + self._versions = [] + self._freeze() + + @property + def id(self) -> int: + return self._id + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def ref(self) -> str: + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def subtitle(self) -> str: + return self._subtitle or "" + + @subtitle.setter + def subtitle(self, subtitle: str): + if subtitle is None: + del self.subtitle + return + if not isinstance(subtitle, str): + raise TypeError('subtitle must be of type str') + self._subtitle = subtitle + + @property + def creator_name(self) -> str: + return self._creator_name or "" + + @creator_name.setter + def creator_name(self, creator_name: str): + if creator_name is None: + del self.creator_name + return + if not isinstance(creator_name, str): + raise TypeError('creator_name must be of type str') + self._creator_name = creator_name + + @property + def creator_url(self) -> str: + return self._creator_url or "" + + @creator_url.setter + def creator_url(self, creator_url: str): + if creator_url is None: + del self.creator_url + return + if not isinstance(creator_url, str): + raise TypeError('creator_url must be of type str') + self._creator_url = creator_url + + @property + def total_bytes(self) -> int: + return self._total_bytes or 0 + + @total_bytes.setter + def total_bytes(self, total_bytes: int): + if total_bytes is None: + del self.total_bytes + return + if not isinstance(total_bytes, int): + raise TypeError('total_bytes must be of type int') + self._total_bytes = total_bytes + + @property + def url(self) -> str: + return self._url or "" + + @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 last_updated(self) -> datetime: + return self._last_updated + + @last_updated.setter + def last_updated(self, last_updated: datetime): + if last_updated is None: + del self.last_updated + return + if not isinstance(last_updated, datetime): + raise TypeError('last_updated must be of type datetime') + self._last_updated = last_updated + + @property + def download_count(self) -> int: + return self._download_count + + @download_count.setter + def download_count(self, download_count: int): + if download_count is None: + del self.download_count + return + if not isinstance(download_count, int): + raise TypeError('download_count must be of type int') + self._download_count = download_count + + @property + def is_private(self) -> bool: + return self._is_private + + @is_private.setter + def is_private(self, is_private: bool): + if is_private is None: + del self.is_private + return + if not isinstance(is_private, bool): + raise TypeError('is_private must be of type bool') + self._is_private = is_private + + @property + def is_featured(self) -> bool: + return self._is_featured + + @is_featured.setter + def is_featured(self, is_featured: bool): + if is_featured is None: + del self.is_featured + return + if not isinstance(is_featured, bool): + raise TypeError('is_featured must be of type bool') + self._is_featured = is_featured + + @property + def license_name(self) -> str: + return self._license_name or "" + + @license_name.setter + def license_name(self, license_name: str): + if license_name is None: + del self.license_name + return + if not isinstance(license_name, str): + raise TypeError('license_name must be of type str') + self._license_name = license_name + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def owner_name(self) -> str: + return self._owner_name or "" + + @owner_name.setter + def owner_name(self, owner_name: str): + if owner_name is None: + del self.owner_name + return + if not isinstance(owner_name, str): + raise TypeError('owner_name must be of type str') + self._owner_name = owner_name + + @property + def owner_ref(self) -> str: + return self._owner_ref or "" + + @owner_ref.setter + def owner_ref(self, owner_ref: str): + if owner_ref is None: + del self.owner_ref + return + if not isinstance(owner_ref, str): + raise TypeError('owner_ref must be of type str') + self._owner_ref = owner_ref + + @property + def kernel_count(self) -> int: + return self._kernel_count + + @kernel_count.setter + def kernel_count(self, kernel_count: int): + if kernel_count is None: + del self.kernel_count + return + if not isinstance(kernel_count, int): + raise TypeError('kernel_count must be of type int') + self._kernel_count = kernel_count + + @property + def title(self) -> str: + return self._title or "" + + @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 topic_count(self) -> int: + return self._topic_count + + @topic_count.setter + def topic_count(self, topic_count: int): + if topic_count is None: + del self.topic_count + return + if not isinstance(topic_count, int): + raise TypeError('topic_count must be of type int') + self._topic_count = topic_count + + @property + def view_count(self) -> int: + return self._view_count + + @view_count.setter + def view_count(self, view_count: int): + if view_count is None: + del self.view_count + return + if not isinstance(view_count, int): + raise TypeError('view_count must be of type int') + self._view_count = view_count + + @property + def vote_count(self) -> int: + return self._vote_count + + @vote_count.setter + def vote_count(self, vote_count: int): + if vote_count is None: + del self.vote_count + return + if not isinstance(vote_count, int): + raise TypeError('vote_count must be of type int') + self._vote_count = vote_count + + @property + def current_version_number(self) -> int: + return self._current_version_number or 0 + + @current_version_number.setter + def current_version_number(self, current_version_number: int): + if current_version_number is None: + del self.current_version_number + return + if not isinstance(current_version_number, int): + raise TypeError('current_version_number must be of type int') + self._current_version_number = current_version_number + + @property + def usability_rating(self) -> float: + return self._usability_rating or 0.0 + + @usability_rating.setter + def usability_rating(self, usability_rating: float): + if usability_rating is None: + del self.usability_rating + return + if not isinstance(usability_rating, float): + raise TypeError('usability_rating must be of type float') + self._usability_rating = usability_rating + + @property + def tags(self) -> Optional[List[Optional['ApiCategory']]]: + return self._tags + + @tags.setter + def tags(self, tags: Optional[List[Optional['ApiCategory']]]): + if tags is None: + del self.tags + return + if not isinstance(tags, list): + raise TypeError('tags must be of type list') + if not all([isinstance(t, ApiCategory) for t in tags]): + raise TypeError('tags must contain only items of type ApiCategory') + self._tags = tags + + @property + def files(self) -> Optional[List[Optional['ApiDatasetFile']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiDatasetFile']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiDatasetFile) for t in files]): + raise TypeError('files must contain only items of type ApiDatasetFile') + self._files = files + + @property + def versions(self) -> Optional[List[Optional['ApiDatasetVersion']]]: + return self._versions + + @versions.setter + def versions(self, versions: Optional[List[Optional['ApiDatasetVersion']]]): + if versions is None: + del self.versions + return + if not isinstance(versions, list): + raise TypeError('versions must be of type list') + if not all([isinstance(t, ApiDatasetVersion) for t in versions]): + raise TypeError('versions must contain only items of type ApiDatasetVersion') + self._versions = versions + + +class ApiDatasetFile(KaggleObject): + r""" + Attributes: + ref (str) + dataset_ref (str) + owner_ref (str) + name (str) + creation_date (datetime) + description (str) + file_type (str) + url (str) + total_bytes (int) + columns (ApiDatasetColumn) + """ + + def __init__(self): + self._ref = "" + self._dataset_ref = None + self._owner_ref = None + self._name = None + self._creation_date = None + self._description = None + self._file_type = None + self._url = None + self._total_bytes = 0 + self._columns = [] + self._freeze() + + @property + def ref(self) -> str: + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def dataset_ref(self) -> str: + return self._dataset_ref or "" + + @dataset_ref.setter + def dataset_ref(self, dataset_ref: str): + if dataset_ref is None: + del self.dataset_ref + return + if not isinstance(dataset_ref, str): + raise TypeError('dataset_ref must be of type str') + self._dataset_ref = dataset_ref + + @property + def owner_ref(self) -> str: + return self._owner_ref or "" + + @owner_ref.setter + def owner_ref(self, owner_ref: str): + if owner_ref is None: + del self.owner_ref + return + if not isinstance(owner_ref, str): + raise TypeError('owner_ref must be of type str') + self._owner_ref = owner_ref + + @property + def name(self) -> str: + return self._name or "" + + @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 creation_date(self) -> datetime: + return self._creation_date + + @creation_date.setter + def creation_date(self, creation_date: datetime): + if creation_date is None: + del self.creation_date + return + if not isinstance(creation_date, datetime): + raise TypeError('creation_date must be of type datetime') + self._creation_date = creation_date + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def file_type(self) -> str: + return self._file_type or "" + + @file_type.setter + def file_type(self, file_type: str): + if file_type is None: + del self.file_type + return + if not isinstance(file_type, str): + raise TypeError('file_type must be of type str') + self._file_type = file_type + + @property + def url(self) -> str: + return self._url or "" + + @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 total_bytes(self) -> int: + return self._total_bytes + + @total_bytes.setter + def total_bytes(self, total_bytes: int): + if total_bytes is None: + del self.total_bytes + return + if not isinstance(total_bytes, int): + raise TypeError('total_bytes must be of type int') + self._total_bytes = total_bytes + + @property + def columns(self) -> Optional[List[Optional['ApiDatasetColumn']]]: + return self._columns + + @columns.setter + def columns(self, columns: Optional[List[Optional['ApiDatasetColumn']]]): + if columns is None: + del self.columns + return + if not isinstance(columns, list): + raise TypeError('columns must be of type list') + if not all([isinstance(t, ApiDatasetColumn) for t in columns]): + raise TypeError('columns must contain only items of type ApiDatasetColumn') + self._columns = columns + + +class ApiDatasetNewFile(KaggleObject): + r""" + Attributes: + token (str) + description (str) + columns (ApiDatasetColumn) + """ + + def __init__(self): + self._token = None + self._description = None + self._columns = [] + self._freeze() + + @property + def token(self) -> str: + return self._token or "" + + @token.setter + def token(self, token: str): + if token is None: + del self.token + return + if not isinstance(token, str): + raise TypeError('token must be of type str') + self._token = token + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def columns(self) -> Optional[List[Optional['ApiDatasetColumn']]]: + return self._columns + + @columns.setter + def columns(self, columns: Optional[List[Optional['ApiDatasetColumn']]]): + if columns is None: + del self.columns + return + if not isinstance(columns, list): + raise TypeError('columns must be of type list') + if not all([isinstance(t, ApiDatasetColumn) for t in columns]): + raise TypeError('columns must contain only items of type ApiDatasetColumn') + self._columns = columns + + +class ApiDatasetVersion(KaggleObject): + r""" + Attributes: + version_number (int) + creation_date (datetime) + creator_name (str) + creator_ref (str) + version_notes (str) + status (str) + """ + + def __init__(self): + self._version_number = 0 + self._creation_date = None + self._creator_name = None + self._creator_ref = None + self._version_notes = None + self._status = None + self._freeze() + + @property + def version_number(self) -> int: + return self._version_number + + @version_number.setter + def version_number(self, version_number: int): + if version_number is None: + del self.version_number + return + if not isinstance(version_number, int): + raise TypeError('version_number must be of type int') + self._version_number = version_number + + @property + def creation_date(self) -> datetime: + return self._creation_date + + @creation_date.setter + def creation_date(self, creation_date: datetime): + if creation_date is None: + del self.creation_date + return + if not isinstance(creation_date, datetime): + raise TypeError('creation_date must be of type datetime') + self._creation_date = creation_date + + @property + def creator_name(self) -> str: + return self._creator_name or "" + + @creator_name.setter + def creator_name(self, creator_name: str): + if creator_name is None: + del self.creator_name + return + if not isinstance(creator_name, str): + raise TypeError('creator_name must be of type str') + self._creator_name = creator_name + + @property + def creator_ref(self) -> str: + return self._creator_ref or "" + + @creator_ref.setter + def creator_ref(self, creator_ref: str): + if creator_ref is None: + del self.creator_ref + return + if not isinstance(creator_ref, str): + raise TypeError('creator_ref must be of type str') + self._creator_ref = creator_ref + + @property + def version_notes(self) -> str: + return self._version_notes or "" + + @version_notes.setter + def version_notes(self, version_notes: str): + if version_notes is None: + del self.version_notes + return + if not isinstance(version_notes, str): + raise TypeError('version_notes must be of type str') + self._version_notes = version_notes + + @property + def status(self) -> str: + return self._status or "" + + @status.setter + def status(self, status: str): + if status is None: + del self.status + return + if not isinstance(status, str): + raise TypeError('status must be of type str') + self._status = status + + +class ApiDeleteDatasetRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + dataset_slug (str) + """ + + def __init__(self): + self._owner_slug = "" + self._dataset_slug = "" + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def dataset_slug(self) -> str: + return self._dataset_slug + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + + def endpoint(self): + path = '/api/v1/dataset/{owner_slug}/{dataset_slug}/delete' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiDeleteDatasetResponse(KaggleObject): + r""" + Attributes: + error (str) + """ + + def __init__(self): + self._error = None + self._freeze() + + @property + def error(self) -> str: + return self._error or "" + + @error.setter + def error(self, error: str): + if error is None: + del self.error + return + if not isinstance(error, str): + raise TypeError('error must be of type str') + self._error = error + + +class ApiDownloadDatasetRawRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + dataset_slug (str) + file_name (str) + dataset_version_number (int) + """ + + def __init__(self): + self._owner_slug = "" + self._dataset_slug = "" + self._file_name = None + self._dataset_version_number = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def dataset_slug(self) -> str: + return self._dataset_slug + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + @property + def file_name(self) -> str: + return self._file_name or "" + + @file_name.setter + def file_name(self, file_name: str): + if file_name is None: + del self.file_name + return + if not isinstance(file_name, str): + raise TypeError('file_name must be of type str') + self._file_name = file_name + + @property + def dataset_version_number(self) -> int: + return self._dataset_version_number or 0 + + @dataset_version_number.setter + def dataset_version_number(self, dataset_version_number: int): + if dataset_version_number is None: + del self.dataset_version_number + return + if not isinstance(dataset_version_number, int): + raise TypeError('dataset_version_number must be of type int') + self._dataset_version_number = dataset_version_number + + + def endpoint(self): + path = '/api/v1/datasets/download-raw/{owner_slug}/{dataset_slug}/{file_name}' + return path.format_map(self.to_field_map(self)) + +class ApiDownloadDatasetRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + dataset_slug (str) + file_name (str) + dataset_version_number (int) + raw (bool) + """ + + def __init__(self): + self._owner_slug = "" + self._dataset_slug = "" + self._file_name = None + self._dataset_version_number = None + self._raw = False + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def dataset_slug(self) -> str: + return self._dataset_slug + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + @property + def file_name(self) -> str: + return self._file_name or "" + + @file_name.setter + def file_name(self, file_name: str): + if file_name is None: + del self.file_name + return + if not isinstance(file_name, str): + raise TypeError('file_name must be of type str') + self._file_name = file_name + + @property + def dataset_version_number(self) -> int: + return self._dataset_version_number or 0 + + @dataset_version_number.setter + def dataset_version_number(self, dataset_version_number: int): + if dataset_version_number is None: + del self.dataset_version_number + return + if not isinstance(dataset_version_number, int): + raise TypeError('dataset_version_number must be of type int') + self._dataset_version_number = dataset_version_number + + @property + def raw(self) -> bool: + return self._raw + + @raw.setter + def raw(self, raw: bool): + if raw is None: + del self.raw + return + if not isinstance(raw, bool): + raise TypeError('raw must be of type bool') + self._raw = raw + + + def endpoint(self): + if self.file_name: + path = '/api/v1/datasets/download/{owner_slug}/{dataset_slug}/{file_name}' + else: + path = '/api/v1/datasets/download/{owner_slug}/{dataset_slug}' + return path.format_map(self.to_field_map(self)) + +class ApiGetDatasetMetadataRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + dataset_slug (str) + """ + + def __init__(self): + self._owner_slug = "" + self._dataset_slug = "" + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def dataset_slug(self) -> str: + return self._dataset_slug + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + + def endpoint(self): + path = '/api/v1/datasets/metadata/{owner_slug}/{dataset_slug}' + return path.format_map(self.to_field_map(self)) + +class ApiGetDatasetMetadataResponse(KaggleObject): + r""" + Attributes: + info (DatasetInfo) + error_message (str) + Required for backwards-compatibility. See + https://github.com/Kaggle/kaggle-api/issues/235 + """ + + def __init__(self): + self._info = None + self._error_message = None + self._freeze() + + @property + def info(self) -> Optional['DatasetInfo']: + return self._info + + @info.setter + def info(self, info: Optional['DatasetInfo']): + if info is None: + del self.info + return + if not isinstance(info, DatasetInfo): + raise TypeError('info must be of type DatasetInfo') + self._info = info + + @property + def error_message(self) -> str: + r""" + Required for backwards-compatibility. See + https://github.com/Kaggle/kaggle-api/issues/235 + """ + return self._error_message or "" + + @error_message.setter + def error_message(self, error_message: str): + if error_message is None: + del self.error_message + return + if not isinstance(error_message, str): + raise TypeError('error_message must be of type str') + self._error_message = error_message + + +class ApiGetDatasetRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + dataset_slug (str) + """ + + def __init__(self): + self._owner_slug = "" + self._dataset_slug = "" + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def dataset_slug(self) -> str: + return self._dataset_slug + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + + def endpoint(self): + path = '/api/v1/datasets/view/{owner_slug}/{dataset_slug}' + return path.format_map(self.to_field_map(self)) + +class ApiGetDatasetStatusRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + dataset_slug (str) + """ + + def __init__(self): + self._owner_slug = "" + self._dataset_slug = "" + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def dataset_slug(self) -> str: + return self._dataset_slug + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + + def endpoint(self): + path = '/api/v1/datasets/status/{owner_slug}/{dataset_slug}' + return path.format_map(self.to_field_map(self)) + +class ApiGetDatasetStatusResponse(KaggleObject): + r""" + Attributes: + status (DatabundleVersionStatus) + """ + + def __init__(self): + self._status = DatabundleVersionStatus.NOT_YET_PERSISTED + self._freeze() + + @property + def status(self) -> 'DatabundleVersionStatus': + return self._status + + @status.setter + def status(self, status: 'DatabundleVersionStatus'): + if status is None: + del self.status + return + if not isinstance(status, DatabundleVersionStatus): + raise TypeError('status must be of type DatabundleVersionStatus') + self._status = status + + + @classmethod + def prepare_from(cls, http_response): + return cls.from_dict({'status': json.loads(http_response.text)}) + +class ApiListDatasetFilesRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + dataset_slug (str) + dataset_version_number (int) + page_token (str) + page_size (int) + """ + + def __init__(self): + self._owner_slug = "" + self._dataset_slug = "" + self._dataset_version_number = None + self._page_token = None + self._page_size = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def dataset_slug(self) -> str: + return self._dataset_slug + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + @property + def dataset_version_number(self) -> int: + return self._dataset_version_number or 0 + + @dataset_version_number.setter + def dataset_version_number(self, dataset_version_number: int): + if dataset_version_number is None: + del self.dataset_version_number + return + if not isinstance(dataset_version_number, int): + raise TypeError('dataset_version_number must be of type int') + self._dataset_version_number = dataset_version_number + + @property + def page_token(self) -> str: + return self._page_token or "" + + @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 page_size(self) -> int: + return self._page_size or 0 + + @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 + + + def endpoint(self): + path = '/api/v1/datasets/list/{owner_slug}/{dataset_slug}' + return path.format_map(self.to_field_map(self)) + +class ApiListDatasetFilesResponse(KaggleObject): + r""" + Attributes: + dataset_files (ApiDatasetFile) + error_message (str) + next_page_token (str) + """ + + def __init__(self): + self._dataset_files = [] + self._error_message = None + self._next_page_token = None + self._freeze() + + @property + def dataset_files(self) -> Optional[List[Optional['ApiDatasetFile']]]: + return self._dataset_files + + @dataset_files.setter + def dataset_files(self, dataset_files: Optional[List[Optional['ApiDatasetFile']]]): + if dataset_files is None: + del self.dataset_files + return + if not isinstance(dataset_files, list): + raise TypeError('dataset_files must be of type list') + if not all([isinstance(t, ApiDatasetFile) for t in dataset_files]): + raise TypeError('dataset_files must contain only items of type ApiDatasetFile') + self._dataset_files = dataset_files + + @property + def error_message(self) -> str: + return self._error_message or "" + + @error_message.setter + def error_message(self, error_message: str): + if error_message is None: + del self.error_message + return + if not isinstance(error_message, str): + raise TypeError('error_message must be of type str') + self._error_message = error_message + + @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: 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 + + +class ApiListDatasetsRequest(KaggleObject): + r""" + Attributes: + group (DatasetSelectionGroup) + sort_by (DatasetSortBy) + size (DatasetSizeGroup) + file_type (DatasetFileTypeGroup) + license (DatasetLicenseGroup) + viewed (DatasetViewedGroup) + tag_ids (str) + search (str) + user (str) + min_size (int) + max_size (int) + page (int) + page_token (str) + page_size (int) + """ + + def __init__(self): + self._group = DatasetSelectionGroup.DATASET_SELECTION_GROUP_PUBLIC + self._sort_by = DatasetSortBy.DATASET_SORT_BY_HOTTEST + self._size = DatasetSizeGroup.DATASET_SIZE_GROUP_ALL + self._file_type = DatasetFileTypeGroup.DATASET_FILE_TYPE_GROUP_ALL + self._license = DatasetLicenseGroup.DATASET_LICENSE_GROUP_ALL + self._viewed = DatasetViewedGroup.DATASET_VIEWED_GROUP_UNSPECIFIED + self._tag_ids = None + self._search = None + self._user = None + self._min_size = None + self._max_size = None + self._page = None + self._page_token = None + self._page_size = None + self._freeze() + + @property + def group(self) -> 'DatasetSelectionGroup': + return self._group + + @group.setter + def group(self, group: 'DatasetSelectionGroup'): + if group is None: + del self.group + return + if not isinstance(group, DatasetSelectionGroup): + raise TypeError('group must be of type DatasetSelectionGroup') + self._group = group + + @property + def sort_by(self) -> 'DatasetSortBy': + return self._sort_by + + @sort_by.setter + def sort_by(self, sort_by: 'DatasetSortBy'): + if sort_by is None: + del self.sort_by + return + if not isinstance(sort_by, DatasetSortBy): + raise TypeError('sort_by must be of type DatasetSortBy') + self._sort_by = sort_by + + @property + def size(self) -> 'DatasetSizeGroup': + return self._size + + @size.setter + def size(self, size: 'DatasetSizeGroup'): + if size is None: + del self.size + return + if not isinstance(size, DatasetSizeGroup): + raise TypeError('size must be of type DatasetSizeGroup') + self._size = size + + @property + def file_type(self) -> 'DatasetFileTypeGroup': + return self._file_type + + @file_type.setter + def file_type(self, file_type: 'DatasetFileTypeGroup'): + if file_type is None: + del self.file_type + return + if not isinstance(file_type, DatasetFileTypeGroup): + raise TypeError('file_type must be of type DatasetFileTypeGroup') + self._file_type = file_type + + @property + def license(self) -> 'DatasetLicenseGroup': + return self._license + + @license.setter + def license(self, license: 'DatasetLicenseGroup'): + if license is None: + del self.license + return + if not isinstance(license, DatasetLicenseGroup): + raise TypeError('license must be of type DatasetLicenseGroup') + self._license = license + + @property + def viewed(self) -> 'DatasetViewedGroup': + return self._viewed + + @viewed.setter + def viewed(self, viewed: 'DatasetViewedGroup'): + if viewed is None: + del self.viewed + return + if not isinstance(viewed, DatasetViewedGroup): + raise TypeError('viewed must be of type DatasetViewedGroup') + self._viewed = viewed + + @property + def tag_ids(self) -> str: + return self._tag_ids or "" + + @tag_ids.setter + def tag_ids(self, tag_ids: str): + if tag_ids is None: + del self.tag_ids + return + if not isinstance(tag_ids, str): + raise TypeError('tag_ids must be of type str') + self._tag_ids = tag_ids + + @property + def search(self) -> str: + return self._search or "" + + @search.setter + def search(self, search: str): + if search is None: + del self.search + return + if not isinstance(search, str): + raise TypeError('search must be of type str') + self._search = search + + @property + def user(self) -> str: + return self._user or "" + + @user.setter + def user(self, user: str): + if user is None: + del self.user + return + if not isinstance(user, str): + raise TypeError('user must be of type str') + self._user = user + + @property + def min_size(self) -> int: + return self._min_size or 0 + + @min_size.setter + def min_size(self, min_size: int): + if min_size is None: + del self.min_size + return + if not isinstance(min_size, int): + raise TypeError('min_size must be of type int') + self._min_size = min_size + + @property + def max_size(self) -> int: + return self._max_size or 0 + + @max_size.setter + def max_size(self, max_size: int): + if max_size is None: + del self.max_size + return + if not isinstance(max_size, int): + raise TypeError('max_size must be of type int') + self._max_size = max_size + + @property + def page(self) -> int: + return self._page or 0 + + @page.setter + def page(self, page: int): + if page is None: + del self.page + return + if not isinstance(page, int): + raise TypeError('page must be of type int') + self._page = page + + @property + def page_token(self) -> str: + return self._page_token or "" + + @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 page_size(self) -> int: + return self._page_size or 0 + + @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 + + + def endpoint(self): + path = '/api/v1/datasets/list' + return path.format_map(self.to_field_map(self)) + +class ApiListDatasetsResponse(KaggleObject): + r""" + Attributes: + datasets (ApiDataset) + """ + + def __init__(self): + self._datasets = [] + self._freeze() + + @property + def datasets(self) -> Optional[List[Optional['ApiDataset']]]: + return self._datasets + + @datasets.setter + def datasets(self, datasets: Optional[List[Optional['ApiDataset']]]): + if datasets is None: + del self.datasets + return + if not isinstance(datasets, list): + raise TypeError('datasets must be of type list') + if not all([isinstance(t, ApiDataset) for t in datasets]): + raise TypeError('datasets must contain only items of type ApiDataset') + self._datasets = datasets + + + @classmethod + def prepare_from(cls, http_response): + return cls.from_dict({'datasets': json.loads(http_response.text)}) + +class ApiUpdateDatasetMetadataRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + dataset_slug (str) + settings (DatasetSettings) + """ + + def __init__(self): + self._owner_slug = "" + self._dataset_slug = "" + self._settings = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def dataset_slug(self) -> str: + return self._dataset_slug + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + @property + def settings(self) -> Optional['DatasetSettings']: + return self._settings + + @settings.setter + def settings(self, settings: Optional['DatasetSettings']): + if settings is None: + del self.settings + return + if not isinstance(settings, DatasetSettings): + raise TypeError('settings must be of type DatasetSettings') + self._settings = settings + + + def endpoint(self): + path = '/api/v1/datasets/metadata/{owner_slug}/{dataset_slug}' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiUpdateDatasetMetadataResponse(KaggleObject): + r""" + Attributes: + errors (str) + Required for backwards-compatibility. + """ + + def __init__(self): + self._errors = [] + self._freeze() + + @property + def errors(self) -> Optional[List[str]]: + """Required for backwards-compatibility.""" + return self._errors + + @errors.setter + def errors(self, errors: Optional[List[str]]): + if errors is None: + del self.errors + return + if not isinstance(errors, list): + raise TypeError('errors must be of type list') + if not all([isinstance(t, str) for t in errors]): + raise TypeError('errors must contain only items of type str') + self._errors = errors + + +class ApiUploadDatasetFileRequest(KaggleObject): + r""" + Attributes: + file_name (str) + content_length (int) + last_modified_epoch_seconds (int) + """ + + def __init__(self): + self._file_name = "" + self._content_length = 0 + self._last_modified_epoch_seconds = 0 + self._freeze() + + @property + def file_name(self) -> str: + return self._file_name + + @file_name.setter + def file_name(self, file_name: str): + if file_name is None: + del self.file_name + return + if not isinstance(file_name, str): + raise TypeError('file_name must be of type str') + self._file_name = file_name + + @property + def content_length(self) -> int: + return self._content_length + + @content_length.setter + def content_length(self, content_length: int): + if content_length is None: + del self.content_length + return + if not isinstance(content_length, int): + raise TypeError('content_length must be of type int') + self._content_length = content_length + + @property + def last_modified_epoch_seconds(self) -> int: + return self._last_modified_epoch_seconds + + @last_modified_epoch_seconds.setter + def last_modified_epoch_seconds(self, last_modified_epoch_seconds: int): + if last_modified_epoch_seconds is None: + del self.last_modified_epoch_seconds + return + if not isinstance(last_modified_epoch_seconds, int): + raise TypeError('last_modified_epoch_seconds must be of type int') + self._last_modified_epoch_seconds = last_modified_epoch_seconds + + + def endpoint(self): + path = '/api/v1/datasets/upload/file/{content_length}/{last_modified_epoch_seconds}' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiUploadDatasetFileResponse(KaggleObject): + r""" + Attributes: + token (str) + Opaque string token used to reference the new BlobFile. + create_url (str) + URL to use to start the upload + """ + + def __init__(self): + self._token = "" + self._create_url = "" + self._freeze() + + @property + def token(self) -> str: + """Opaque string token used to reference the new BlobFile.""" + return self._token + + @token.setter + def token(self, token: str): + if token is None: + del self.token + return + if not isinstance(token, str): + raise TypeError('token must be of type str') + self._token = token + + @property + def create_url(self) -> str: + """URL to use to start the upload""" + return self._create_url + + @create_url.setter + def create_url(self, create_url: str): + if create_url is None: + del self.create_url + return + if not isinstance(create_url, str): + raise TypeError('create_url must be of type str') + self._create_url = create_url + + +class ApiCategory(KaggleObject): + r""" + Attributes: + ref (str) + name (str) + description (str) + full_path (str) + competition_count (int) + dataset_count (int) + script_count (int) + total_count (int) + """ + + def __init__(self): + self._ref = "" + self._name = None + self._description = None + self._full_path = None + self._competition_count = 0 + self._dataset_count = 0 + self._script_count = 0 + self._total_count = 0 + self._freeze() + + @property + def ref(self) -> str: + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def name(self) -> str: + return self._name or "" + + @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 description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def full_path(self) -> str: + return self._full_path or "" + + @full_path.setter + def full_path(self, full_path: str): + if full_path is None: + del self.full_path + return + if not isinstance(full_path, str): + raise TypeError('full_path must be of type str') + self._full_path = full_path + + @property + def competition_count(self) -> int: + return self._competition_count + + @competition_count.setter + def competition_count(self, competition_count: int): + if competition_count is None: + del self.competition_count + return + if not isinstance(competition_count, int): + raise TypeError('competition_count must be of type int') + self._competition_count = competition_count + + @property + def dataset_count(self) -> int: + return self._dataset_count + + @dataset_count.setter + def dataset_count(self, dataset_count: int): + if dataset_count is None: + del self.dataset_count + return + if not isinstance(dataset_count, int): + raise TypeError('dataset_count must be of type int') + self._dataset_count = dataset_count + + @property + def script_count(self) -> int: + return self._script_count + + @script_count.setter + def script_count(self, script_count: int): + if script_count is None: + del self.script_count + return + if not isinstance(script_count, int): + raise TypeError('script_count must be of type int') + self._script_count = script_count + + @property + def total_count(self) -> int: + return self._total_count + + @total_count.setter + def total_count(self, total_count: int): + if total_count is None: + del self.total_count + return + if not isinstance(total_count, int): + raise TypeError('total_count must be of type int') + self._total_count = total_count + + +class ApiDatasetColumn(KaggleObject): + r""" + Attributes: + order (int) + name (str) + type (str) + original_type (str) + description (str) + """ + + def __init__(self): + self._order = None + self._name = None + self._type = None + self._original_type = None + self._description = None + self._freeze() + + @property + def order(self) -> int: + return self._order or 0 + + @order.setter + def order(self, order: int): + if order is None: + del self.order + return + if not isinstance(order, int): + raise TypeError('order must be of type int') + self._order = order + + @property + def name(self) -> str: + return self._name or "" + + @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 type(self) -> str: + return self._type or "" + + @type.setter + def type(self, type: str): + if type is None: + del self.type + return + if not isinstance(type, str): + raise TypeError('type must be of type str') + self._type = type + + @property + def original_type(self) -> str: + return self._original_type or "" + + @original_type.setter + def original_type(self, original_type: str): + if original_type is None: + del self.original_type + return + if not isinstance(original_type, str): + raise TypeError('original_type must be of type str') + self._original_type = original_type + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + +class ApiUploadDirectoryInfo(KaggleObject): + r""" + Attributes: + name (str) + directories (ApiUploadDirectoryInfo) + files (ApiDatasetNewFile) + """ + + def __init__(self): + self._name = "" + self._directories = [] + self._files = [] + 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 directories(self) -> Optional[List[Optional['ApiUploadDirectoryInfo']]]: + return self._directories + + @directories.setter + def directories(self, directories: Optional[List[Optional['ApiUploadDirectoryInfo']]]): + if directories is None: + del self.directories + return + if not isinstance(directories, list): + raise TypeError('directories must be of type list') + if not all([isinstance(t, ApiUploadDirectoryInfo) for t in directories]): + raise TypeError('directories must contain only items of type ApiUploadDirectoryInfo') + self._directories = directories + + @property + def files(self) -> Optional[List[Optional['ApiDatasetNewFile']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiDatasetNewFile']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiDatasetNewFile) for t in files]): + raise TypeError('files must contain only items of type ApiDatasetNewFile') + self._files = files + + +ApiCreateDatasetRequest._fields = [ + FieldMetadata("id", "id", "_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("slug", "slug", "_slug", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("title", "title", "_title", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("licenseName", "license_name", "_license_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("isPrivate", "is_private", "_is_private", bool, False, PredefinedSerializer()), + FieldMetadata("files", "files", "_files", ApiDatasetNewFile, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("subtitle", "subtitle", "_subtitle", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("categoryIds", "category_ids", "_category_ids", str, [], ListSerializer(PredefinedSerializer())), +] + +ApiCreateDatasetResponse._fields = [ + FieldMetadata("ref", "ref", "_ref", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("status", "status", "_status", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("error", "error", "_error", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("invalidTags", "invalid_tags", "_invalid_tags", str, [], ListSerializer(PredefinedSerializer())), +] + +ApiCreateDatasetVersionByIdRequest._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("body", "body", "_body", ApiCreateDatasetVersionRequestBody, None, KaggleObjectSerializer()), +] + +ApiCreateDatasetVersionRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, "", PredefinedSerializer()), + FieldMetadata("body", "body", "_body", ApiCreateDatasetVersionRequestBody, None, KaggleObjectSerializer()), +] + +ApiCreateDatasetVersionRequestBody._fields = [ + FieldMetadata("versionNotes", "version_notes", "_version_notes", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("deleteOldVersions", "delete_old_versions", "_delete_old_versions", bool, False, PredefinedSerializer()), + FieldMetadata("files", "files", "_files", ApiDatasetNewFile, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("subtitle", "subtitle", "_subtitle", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("categoryIds", "category_ids", "_category_ids", str, [], ListSerializer(PredefinedSerializer())), +] + +ApiDataset._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("subtitle", "subtitle", "_subtitle", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("creatorName", "creator_name", "_creator_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("creatorUrl", "creator_url", "_creator_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("totalBytes", "total_bytes", "_total_bytes", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("lastUpdated", "last_updated", "_last_updated", datetime, None, DateTimeSerializer()), + FieldMetadata("downloadCount", "download_count", "_download_count", int, 0, PredefinedSerializer()), + FieldMetadata("isPrivate", "is_private", "_is_private", bool, False, PredefinedSerializer()), + FieldMetadata("isFeatured", "is_featured", "_is_featured", bool, False, PredefinedSerializer()), + FieldMetadata("licenseName", "license_name", "_license_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("ownerName", "owner_name", "_owner_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("ownerRef", "owner_ref", "_owner_ref", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("kernelCount", "kernel_count", "_kernel_count", int, 0, PredefinedSerializer()), + FieldMetadata("title", "title", "_title", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("topicCount", "topic_count", "_topic_count", int, 0, PredefinedSerializer()), + FieldMetadata("viewCount", "view_count", "_view_count", int, 0, PredefinedSerializer()), + FieldMetadata("voteCount", "vote_count", "_vote_count", int, 0, PredefinedSerializer()), + FieldMetadata("currentVersionNumber", "current_version_number", "_current_version_number", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("usabilityRating", "usability_rating", "_usability_rating", float, None, PredefinedSerializer(), optional=True), + FieldMetadata("tags", "tags", "_tags", ApiCategory, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("files", "files", "_files", ApiDatasetFile, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("versions", "versions", "_versions", ApiDatasetVersion, [], ListSerializer(KaggleObjectSerializer())), +] + +ApiDatasetFile._fields = [ + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("datasetRef", "dataset_ref", "_dataset_ref", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("ownerRef", "owner_ref", "_owner_ref", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("creationDate", "creation_date", "_creation_date", datetime, None, DateTimeSerializer()), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("fileType", "file_type", "_file_type", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("totalBytes", "total_bytes", "_total_bytes", int, 0, PredefinedSerializer()), + FieldMetadata("columns", "columns", "_columns", ApiDatasetColumn, [], ListSerializer(KaggleObjectSerializer())), +] + +ApiDatasetNewFile._fields = [ + FieldMetadata("token", "token", "_token", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("columns", "columns", "_columns", ApiDatasetColumn, [], ListSerializer(KaggleObjectSerializer())), +] + +ApiDatasetVersion._fields = [ + FieldMetadata("versionNumber", "version_number", "_version_number", int, 0, PredefinedSerializer()), + FieldMetadata("creationDate", "creation_date", "_creation_date", datetime, None, DateTimeSerializer()), + FieldMetadata("creatorName", "creator_name", "_creator_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("creatorRef", "creator_ref", "_creator_ref", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("versionNotes", "version_notes", "_version_notes", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("status", "status", "_status", str, None, PredefinedSerializer(), optional=True), +] + +ApiDeleteDatasetRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, "", PredefinedSerializer()), +] + +ApiDeleteDatasetResponse._fields = [ + FieldMetadata("error", "error", "_error", str, None, PredefinedSerializer(), optional=True), +] + +ApiDownloadDatasetRawRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, "", PredefinedSerializer()), + FieldMetadata("fileName", "file_name", "_file_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("datasetVersionNumber", "dataset_version_number", "_dataset_version_number", int, None, PredefinedSerializer(), optional=True), +] + +ApiDownloadDatasetRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, "", PredefinedSerializer()), + FieldMetadata("fileName", "file_name", "_file_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("datasetVersionNumber", "dataset_version_number", "_dataset_version_number", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("raw", "raw", "_raw", bool, False, PredefinedSerializer()), +] + +ApiGetDatasetMetadataRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, "", PredefinedSerializer()), +] + +ApiGetDatasetMetadataResponse._fields = [ + FieldMetadata("info", "info", "_info", DatasetInfo, None, KaggleObjectSerializer()), + FieldMetadata("errorMessage", "error_message", "_error_message", str, None, PredefinedSerializer(), optional=True), +] + +ApiGetDatasetRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, "", PredefinedSerializer()), +] + +ApiGetDatasetStatusRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, "", PredefinedSerializer()), +] + +ApiGetDatasetStatusResponse._fields = [ + FieldMetadata("status", "status", "_status", DatabundleVersionStatus, DatabundleVersionStatus.NOT_YET_PERSISTED, EnumSerializer()), +] + +ApiListDatasetFilesRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetVersionNumber", "dataset_version_number", "_dataset_version_number", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True), +] + +ApiListDatasetFilesResponse._fields = [ + FieldMetadata("datasetFiles", "dataset_files", "_dataset_files", ApiDatasetFile, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("errorMessage", "error_message", "_error_message", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, None, PredefinedSerializer(), optional=True), +] + +ApiListDatasetsRequest._fields = [ + FieldMetadata("group", "group", "_group", DatasetSelectionGroup, DatasetSelectionGroup.DATASET_SELECTION_GROUP_PUBLIC, EnumSerializer()), + FieldMetadata("sortBy", "sort_by", "_sort_by", DatasetSortBy, DatasetSortBy.DATASET_SORT_BY_HOTTEST, EnumSerializer()), + FieldMetadata("size", "size", "_size", DatasetSizeGroup, DatasetSizeGroup.DATASET_SIZE_GROUP_ALL, EnumSerializer()), + FieldMetadata("fileType", "file_type", "_file_type", DatasetFileTypeGroup, DatasetFileTypeGroup.DATASET_FILE_TYPE_GROUP_ALL, EnumSerializer()), + FieldMetadata("license", "license", "_license", DatasetLicenseGroup, DatasetLicenseGroup.DATASET_LICENSE_GROUP_ALL, EnumSerializer()), + FieldMetadata("viewed", "viewed", "_viewed", DatasetViewedGroup, DatasetViewedGroup.DATASET_VIEWED_GROUP_UNSPECIFIED, EnumSerializer()), + FieldMetadata("tagIds", "tag_ids", "_tag_ids", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("search", "search", "_search", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("user", "user", "_user", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("minSize", "min_size", "_min_size", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("maxSize", "max_size", "_max_size", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("page", "page", "_page", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True), +] + +ApiListDatasetsResponse._fields = [ + FieldMetadata("datasets", "datasets", "_datasets", ApiDataset, [], ListSerializer(KaggleObjectSerializer())), +] + +ApiUpdateDatasetMetadataRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, "", PredefinedSerializer()), + FieldMetadata("settings", "settings", "_settings", DatasetSettings, None, KaggleObjectSerializer()), +] + +ApiUpdateDatasetMetadataResponse._fields = [ + FieldMetadata("errors", "errors", "_errors", str, [], ListSerializer(PredefinedSerializer())), +] + +ApiUploadDatasetFileRequest._fields = [ + FieldMetadata("fileName", "file_name", "_file_name", str, "", PredefinedSerializer()), + FieldMetadata("contentLength", "content_length", "_content_length", int, 0, PredefinedSerializer()), + FieldMetadata("lastModifiedEpochSeconds", "last_modified_epoch_seconds", "_last_modified_epoch_seconds", int, 0, PredefinedSerializer()), +] + +ApiUploadDatasetFileResponse._fields = [ + FieldMetadata("token", "token", "_token", str, "", PredefinedSerializer()), + FieldMetadata("createUrl", "create_url", "_create_url", str, "", PredefinedSerializer()), +] + +ApiCategory._fields = [ + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("fullPath", "full_path", "_full_path", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("competitionCount", "competition_count", "_competition_count", int, 0, PredefinedSerializer()), + FieldMetadata("datasetCount", "dataset_count", "_dataset_count", int, 0, PredefinedSerializer()), + FieldMetadata("scriptCount", "script_count", "_script_count", int, 0, PredefinedSerializer()), + FieldMetadata("totalCount", "total_count", "_total_count", int, 0, PredefinedSerializer()), +] + +ApiDatasetColumn._fields = [ + FieldMetadata("order", "order", "_order", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("type", "type", "_type", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("originalType", "original_type", "_original_type", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), +] + +ApiUploadDirectoryInfo._fields = [ + FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()), + FieldMetadata("directories", "directories", "_directories", ApiUploadDirectoryInfo, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("files", "files", "_files", ApiDatasetNewFile, [], ListSerializer(KaggleObjectSerializer())), +] + diff --git a/kagglesdk/datasets/types/dataset_enums.py b/kagglesdk/datasets/types/dataset_enums.py new file mode 100644 index 0000000..1ed7632 --- /dev/null +++ b/kagglesdk/datasets/types/dataset_enums.py @@ -0,0 +1,82 @@ +import enum + +class DatabundleVersionStatus(enum.Enum): + NOT_YET_PERSISTED = 0 + BLOBS_RECEIVED = 1 + BLOBS_DECOMPRESSED = 2 + BLOBS_COPIED_TO_SDS = 3 + INDIVIDUAL_BLOBS_COMPRESSED = 4 + READY = 5 + FAILED = 6 + DELETED = 7 + REPROCESSING = 8 + +class DatasetFileTypeGroup(enum.Enum): + r""" + This enum drives acceptable values from the python API, so avoid changing + enum member names if possible + """ + DATASET_FILE_TYPE_GROUP_ALL = 0 + DATASET_FILE_TYPE_GROUP_CSV = 1 + DATASET_FILE_TYPE_GROUP_SQLITE = 2 + DATASET_FILE_TYPE_GROUP_JSON = 3 + DATASET_FILE_TYPE_GROUP_BIG_QUERY = 4 + +class DatasetLicenseGroup(enum.Enum): + r""" + This enum drives acceptable values from the python API, so avoid changing + enum member names if possible + """ + DATASET_LICENSE_GROUP_ALL = 0 + DATASET_LICENSE_GROUP_CC = 1 + DATASET_LICENSE_GROUP_GPL = 2 + DATASET_LICENSE_GROUP_ODB = 3 + DATASET_LICENSE_GROUP_OTHER = 4 + +class DatasetSelectionGroup(enum.Enum): + DATASET_SELECTION_GROUP_PUBLIC = 0 + DATASET_SELECTION_GROUP_MY = 1 + DATASET_SELECTION_GROUP_USER = 2 + DATASET_SELECTION_GROUP_USER_SHARED_WITH_ME = 3 + DATASET_SELECTION_GROUP_UPVOTED = 4 + DATASET_SELECTION_GROUP_MY_PRIVATE = 5 + DATASET_SELECTION_GROUP_MY_PUBLIC = 10 + DATASET_SELECTION_GROUP_ORGANIZATION = 6 + DATASET_SELECTION_GROUP_BOOKMARKED = 11 + DATASET_SELECTION_GROUP_COLLABORATION = 12 + DATASET_SELECTION_GROUP_SHARED_WITH_USER = 13 + DATASET_SELECTION_GROUP_FEATURED = 7 + """Old""" + DATASET_SELECTION_GROUP_ALL = 8 + DATASET_SELECTION_GROUP_UNFEATURED = 9 + +class DatasetSizeGroup(enum.Enum): + r""" + This enum drives acceptable values from the python API, so avoid changing + enum member names if possible + """ + DATASET_SIZE_GROUP_ALL = 0 + DATASET_SIZE_GROUP_SMALL = 1 + DATASET_SIZE_GROUP_MEDIUM = 2 + DATASET_SIZE_GROUP_LARGE = 3 + +class DatasetSortBy(enum.Enum): + r""" + This enum drives acceptable values from the python API, so avoid changing + enum member names if possible + """ + DATASET_SORT_BY_HOTTEST = 0 + DATASET_SORT_BY_VOTES = 1 + DATASET_SORT_BY_UPDATED = 2 + DATASET_SORT_BY_ACTIVE = 3 + """Deprecated""" + DATASET_SORT_BY_PUBLISHED = 4 + DATASET_SORT_BY_RELEVANCE = 5 + """Old world""" + DATASET_SORT_BY_LAST_VIEWED = 6 + DATASET_SORT_BY_USABILITY = 7 + +class DatasetViewedGroup(enum.Enum): + DATASET_VIEWED_GROUP_UNSPECIFIED = 0 + DATASET_VIEWED_GROUP_VIEWED = 1 + diff --git a/kagglesdk/datasets/types/dataset_types.py b/kagglesdk/datasets/types/dataset_types.py new file mode 100644 index 0000000..5bf9187 --- /dev/null +++ b/kagglesdk/datasets/types/dataset_types.py @@ -0,0 +1,628 @@ +from kagglesdk.kaggle_object import * +from kagglesdk.users.types.users_enums import CollaboratorType +from typing import Optional, List + +class DatasetInfo(KaggleObject): + r""" + Attributes: + dataset_id (int) + dataset_slug (str) + owner_user (str) + usability_rating (float) + total_views (int) + total_votes (int) + total_downloads (int) + title (str) + Copy/paste from DatasetSettings below. Can't use composition because + that'd be a backwards-incompatible change for the Python Api. + subtitle (str) + description (str) + is_private (bool) + keywords (str) + licenses (SettingsLicense) + collaborators (UserRole) + data (DatasetSettingsFile) + """ + + def __init__(self): + self._dataset_id = 0 + self._dataset_slug = None + self._owner_user = None + self._usability_rating = None + self._total_views = 0 + self._total_votes = 0 + self._total_downloads = 0 + self._title = None + self._subtitle = None + self._description = None + self._is_private = False + self._keywords = [] + self._licenses = [] + self._collaborators = [] + self._data = [] + self._freeze() + + @property + def dataset_id(self) -> int: + return self._dataset_id + + @dataset_id.setter + def dataset_id(self, dataset_id: int): + if dataset_id is None: + del self.dataset_id + return + if not isinstance(dataset_id, int): + raise TypeError('dataset_id must be of type int') + self._dataset_id = dataset_id + + @property + def dataset_slug(self) -> str: + return self._dataset_slug or "" + + @dataset_slug.setter + def dataset_slug(self, dataset_slug: str): + if dataset_slug is None: + del self.dataset_slug + return + if not isinstance(dataset_slug, str): + raise TypeError('dataset_slug must be of type str') + self._dataset_slug = dataset_slug + + @property + def owner_user(self) -> str: + return self._owner_user or "" + + @owner_user.setter + def owner_user(self, owner_user: str): + if owner_user is None: + del self.owner_user + return + if not isinstance(owner_user, str): + raise TypeError('owner_user must be of type str') + self._owner_user = owner_user + + @property + def usability_rating(self) -> float: + return self._usability_rating or 0.0 + + @usability_rating.setter + def usability_rating(self, usability_rating: float): + if usability_rating is None: + del self.usability_rating + return + if not isinstance(usability_rating, float): + raise TypeError('usability_rating must be of type float') + self._usability_rating = usability_rating + + @property + def total_views(self) -> int: + return self._total_views + + @total_views.setter + def total_views(self, total_views: int): + if total_views is None: + del self.total_views + return + if not isinstance(total_views, int): + raise TypeError('total_views must be of type int') + self._total_views = total_views + + @property + def total_votes(self) -> int: + return self._total_votes + + @total_votes.setter + def total_votes(self, total_votes: int): + if total_votes is None: + del self.total_votes + return + if not isinstance(total_votes, int): + raise TypeError('total_votes must be of type int') + self._total_votes = total_votes + + @property + def total_downloads(self) -> int: + return self._total_downloads + + @total_downloads.setter + def total_downloads(self, total_downloads: int): + if total_downloads is None: + del self.total_downloads + return + if not isinstance(total_downloads, int): + raise TypeError('total_downloads must be of type int') + self._total_downloads = total_downloads + + @property + def title(self) -> str: + r""" + Copy/paste from DatasetSettings below. Can't use composition because + that'd be a backwards-incompatible change for the Python Api. + """ + return self._title or "" + + @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 subtitle(self) -> str: + return self._subtitle or "" + + @subtitle.setter + def subtitle(self, subtitle: str): + if subtitle is None: + del self.subtitle + return + if not isinstance(subtitle, str): + raise TypeError('subtitle must be of type str') + self._subtitle = subtitle + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def is_private(self) -> bool: + return self._is_private + + @is_private.setter + def is_private(self, is_private: bool): + if is_private is None: + del self.is_private + return + if not isinstance(is_private, bool): + raise TypeError('is_private must be of type bool') + self._is_private = is_private + + @property + def keywords(self) -> Optional[List[str]]: + return self._keywords + + @keywords.setter + def keywords(self, keywords: Optional[List[str]]): + if keywords is None: + del self.keywords + return + if not isinstance(keywords, list): + raise TypeError('keywords must be of type list') + if not all([isinstance(t, str) for t in keywords]): + raise TypeError('keywords must contain only items of type str') + self._keywords = keywords + + @property + def licenses(self) -> Optional[List[Optional['SettingsLicense']]]: + return self._licenses + + @licenses.setter + def licenses(self, licenses: Optional[List[Optional['SettingsLicense']]]): + 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, SettingsLicense) for t in licenses]): + raise TypeError('licenses must contain only items of type SettingsLicense') + self._licenses = licenses + + @property + def collaborators(self) -> Optional[List[Optional['UserRole']]]: + return self._collaborators + + @collaborators.setter + def collaborators(self, collaborators: Optional[List[Optional['UserRole']]]): + if collaborators is None: + del self.collaborators + return + if not isinstance(collaborators, list): + raise TypeError('collaborators must be of type list') + if not all([isinstance(t, UserRole) for t in collaborators]): + raise TypeError('collaborators must contain only items of type UserRole') + self._collaborators = collaborators + + @property + def data(self) -> Optional[List[Optional['DatasetSettingsFile']]]: + return self._data + + @data.setter + def data(self, data: Optional[List[Optional['DatasetSettingsFile']]]): + if data is None: + del self.data + return + if not isinstance(data, list): + raise TypeError('data must be of type list') + if not all([isinstance(t, DatasetSettingsFile) for t in data]): + raise TypeError('data must contain only items of type DatasetSettingsFile') + self._data = data + + +class DatasetSettings(KaggleObject): + r""" + Attributes: + title (str) + subtitle (str) + description (str) + is_private (bool) + keywords (str) + licenses (SettingsLicense) + collaborators (UserRole) + data (DatasetSettingsFile) + """ + + def __init__(self): + self._title = None + self._subtitle = None + self._description = None + self._is_private = False + self._keywords = [] + self._licenses = [] + self._collaborators = [] + self._data = [] + self._freeze() + + @property + def title(self) -> str: + return self._title or "" + + @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 subtitle(self) -> str: + return self._subtitle or "" + + @subtitle.setter + def subtitle(self, subtitle: str): + if subtitle is None: + del self.subtitle + return + if not isinstance(subtitle, str): + raise TypeError('subtitle must be of type str') + self._subtitle = subtitle + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def is_private(self) -> bool: + return self._is_private + + @is_private.setter + def is_private(self, is_private: bool): + if is_private is None: + del self.is_private + return + if not isinstance(is_private, bool): + raise TypeError('is_private must be of type bool') + self._is_private = is_private + + @property + def keywords(self) -> Optional[List[str]]: + return self._keywords + + @keywords.setter + def keywords(self, keywords: Optional[List[str]]): + if keywords is None: + del self.keywords + return + if not isinstance(keywords, list): + raise TypeError('keywords must be of type list') + if not all([isinstance(t, str) for t in keywords]): + raise TypeError('keywords must contain only items of type str') + self._keywords = keywords + + @property + def licenses(self) -> Optional[List[Optional['SettingsLicense']]]: + return self._licenses + + @licenses.setter + def licenses(self, licenses: Optional[List[Optional['SettingsLicense']]]): + 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, SettingsLicense) for t in licenses]): + raise TypeError('licenses must contain only items of type SettingsLicense') + self._licenses = licenses + + @property + def collaborators(self) -> Optional[List[Optional['UserRole']]]: + return self._collaborators + + @collaborators.setter + def collaborators(self, collaborators: Optional[List[Optional['UserRole']]]): + if collaborators is None: + del self.collaborators + return + if not isinstance(collaborators, list): + raise TypeError('collaborators must be of type list') + if not all([isinstance(t, UserRole) for t in collaborators]): + raise TypeError('collaborators must contain only items of type UserRole') + self._collaborators = collaborators + + @property + def data(self) -> Optional[List[Optional['DatasetSettingsFile']]]: + return self._data + + @data.setter + def data(self, data: Optional[List[Optional['DatasetSettingsFile']]]): + if data is None: + del self.data + return + if not isinstance(data, list): + raise TypeError('data must be of type list') + if not all([isinstance(t, DatasetSettingsFile) for t in data]): + raise TypeError('data must contain only items of type DatasetSettingsFile') + self._data = data + + +class DatasetSettingsFile(KaggleObject): + r""" + Attributes: + name (str) + description (str) + total_bytes (int) + columns (DatasetSettingsFileColumn) + """ + + def __init__(self): + self._name = "" + self._description = None + self._total_bytes = 0 + self._columns = [] + 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 description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def total_bytes(self) -> int: + return self._total_bytes + + @total_bytes.setter + def total_bytes(self, total_bytes: int): + if total_bytes is None: + del self.total_bytes + return + if not isinstance(total_bytes, int): + raise TypeError('total_bytes must be of type int') + self._total_bytes = total_bytes + + @property + def columns(self) -> Optional[List[Optional['DatasetSettingsFileColumn']]]: + return self._columns + + @columns.setter + def columns(self, columns: Optional[List[Optional['DatasetSettingsFileColumn']]]): + if columns is None: + del self.columns + return + if not isinstance(columns, list): + raise TypeError('columns must be of type list') + if not all([isinstance(t, DatasetSettingsFileColumn) for t in columns]): + raise TypeError('columns must contain only items of type DatasetSettingsFileColumn') + self._columns = columns + + +class DatasetSettingsFileColumn(KaggleObject): + r""" + Attributes: + name (str) + description (str) + type (str) + """ + + def __init__(self): + self._name = "" + self._description = None + self._type = None + 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 description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def type(self) -> str: + return self._type or "" + + @type.setter + def type(self, type: str): + if type is None: + del self.type + return + if not isinstance(type, str): + raise TypeError('type must be of type str') + self._type = type + + +class SettingsLicense(KaggleObject): + r""" + Attributes: + name (str) + """ + + def __init__(self): + self._name = None + self._freeze() + + @property + def name(self) -> str: + return self._name or "" + + @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 UserRole(KaggleObject): + r""" + Attributes: + username (str) + role (CollaboratorType) + """ + + def __init__(self): + self._username = "" + self._role = CollaboratorType.COLLABORATOR_TYPE_UNSPECIFIED + self._freeze() + + @property + def username(self) -> str: + return self._username + + @username.setter + def username(self, username: str): + if username is None: + del self.username + return + if not isinstance(username, str): + raise TypeError('username must be of type str') + self._username = username + + @property + def role(self) -> 'CollaboratorType': + return self._role + + @role.setter + def role(self, role: 'CollaboratorType'): + if role is None: + del self.role + return + if not isinstance(role, CollaboratorType): + raise TypeError('role must be of type CollaboratorType') + self._role = role + + +DatasetInfo._fields = [ + FieldMetadata("datasetId", "dataset_id", "_dataset_id", int, 0, PredefinedSerializer()), + FieldMetadata("datasetSlug", "dataset_slug", "_dataset_slug", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("ownerUser", "owner_user", "_owner_user", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("usabilityRating", "usability_rating", "_usability_rating", float, None, PredefinedSerializer(), optional=True), + FieldMetadata("totalViews", "total_views", "_total_views", int, 0, PredefinedSerializer()), + FieldMetadata("totalVotes", "total_votes", "_total_votes", int, 0, PredefinedSerializer()), + FieldMetadata("totalDownloads", "total_downloads", "_total_downloads", int, 0, PredefinedSerializer()), + FieldMetadata("title", "title", "_title", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("subtitle", "subtitle", "_subtitle", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("isPrivate", "is_private", "_is_private", bool, False, PredefinedSerializer()), + FieldMetadata("keywords", "keywords", "_keywords", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("licenses", "licenses", "_licenses", SettingsLicense, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("collaborators", "collaborators", "_collaborators", UserRole, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("data", "data", "_data", DatasetSettingsFile, [], ListSerializer(KaggleObjectSerializer())), +] + +DatasetSettings._fields = [ + FieldMetadata("title", "title", "_title", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("subtitle", "subtitle", "_subtitle", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("isPrivate", "is_private", "_is_private", bool, False, PredefinedSerializer()), + FieldMetadata("keywords", "keywords", "_keywords", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("licenses", "licenses", "_licenses", SettingsLicense, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("collaborators", "collaborators", "_collaborators", UserRole, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("data", "data", "_data", DatasetSettingsFile, [], ListSerializer(KaggleObjectSerializer())), +] + +DatasetSettingsFile._fields = [ + FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("totalBytes", "total_bytes", "_total_bytes", int, 0, PredefinedSerializer()), + FieldMetadata("columns", "columns", "_columns", DatasetSettingsFileColumn, [], ListSerializer(KaggleObjectSerializer())), +] + +DatasetSettingsFileColumn._fields = [ + FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("type", "type", "_type", str, None, PredefinedSerializer(), optional=True), +] + +SettingsLicense._fields = [ + FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True), +] + +UserRole._fields = [ + FieldMetadata("username", "username", "_username", str, "", PredefinedSerializer()), + FieldMetadata("role", "role", "_role", CollaboratorType, CollaboratorType.COLLABORATOR_TYPE_UNSPECIFIED, EnumSerializer()), +] + diff --git a/kagglesdk/kaggle_client.py b/kagglesdk/kaggle_client.py new file mode 100644 index 0000000..2c4ee82 --- /dev/null +++ b/kagglesdk/kaggle_client.py @@ -0,0 +1,43 @@ +from kagglesdk.kernels.services.kernels_api_service import KernelsApiClient +from kagglesdk.models.services.model_api_service import ModelApiClient +from kagglesdk.models.services.model_service import ModelClient +from kagglesdk.competitions.services.competition_api_service import CompetitionApiClient +from kagglesdk.datasets.services.dataset_api_service import DatasetApiClient +from kagglesdk.kaggle_env import KaggleEnv +from kagglesdk.kaggle_http_client import KaggleHttpClient + + +class KaggleClient(object): + class Kernels(object): + def __init__(self, http_client: KaggleHttpClient): + self.kernels_api_client = KernelsApiClient(http_client) + + class Models(object): + def __init__(self, http_client: KaggleHttpClient): + self.model_api_client = ModelApiClient(http_client) + self.model_client = ModelClient(http_client) + + class Competitions(object): + def __init__(self, http_client: KaggleHttpClient): + self.competition_api_client = CompetitionApiClient(http_client) + + class Datasets(object): + def __init__(self, http_client: KaggleHttpClient): + self.dataset_api_client = DatasetApiClient(http_client) + + def __init__(self, env: KaggleEnv = None, verbose: bool = False): + self._http_client = http_client = KaggleHttpClient(env, verbose, self._renew_iap_token) + self.kernels = KaggleClient.Kernels(http_client) + self.models = KaggleClient.Models(http_client) + self.competitions = KaggleClient.Competitions(http_client) + self.datasets = KaggleClient.Datasets(http_client) + + def _renew_iap_token(self): + return self.admin.admin_client.renew_iap_token() + + def __enter__(self): + self._http_client.__enter__() + return self + + def __exit__(self, exc_type, exc_value, tb): + self._http_client.__exit__(exc_type, exc_value, tb) diff --git a/kagglesdk/kaggle_env.py b/kagglesdk/kaggle_env.py new file mode 100644 index 0000000..a998216 --- /dev/null +++ b/kagglesdk/kaggle_env.py @@ -0,0 +1,36 @@ +import os +from enum import Enum + + +class KaggleEnv(Enum): + LOCAL = 0 # localhost + STAGING = 1 # staging.kaggle.com + ADMIN = 2 # admin.kaggle.com + QA = 3 # qa.kaggle.com + + +_env_to_endpoint = { + KaggleEnv.LOCAL: 'http://localhost', + KaggleEnv.STAGING: 'https://staging.kaggle.com', + KaggleEnv.ADMIN: 'https://admin.kaggle.com', + KaggleEnv.QA: 'https://qa.kaggle.com', +} + + +def get_endpoint(env: KaggleEnv): + return _env_to_endpoint[env] + + +def get_env(): + env = os.getenv('KAGGLE_API_ENVIRONMENT') + if env is None: + raise Exception('Must specify KaggleEnv or set KAGGLE_API_ENVIRONMENT env var') + if env == 'LOCALHOST': + return KaggleEnv.LOCAL + if env == 'ADMIN': + return KaggleEnv.ADMIN + if env == 'STAGING': + return KaggleEnv.STAGING + if env == 'QA': + return KaggleEnv.QA + raise Exception(f'Unrecognized value in KAGGLE_API_ENVIRONMENT: "{env}"') diff --git a/kagglesdk/kaggle_http_client.py b/kagglesdk/kaggle_http_client.py new file mode 100644 index 0000000..11e2fa8 --- /dev/null +++ b/kagglesdk/kaggle_http_client.py @@ -0,0 +1,196 @@ +import os +import json +import requests +from kagglesdk.kaggle_env import get_endpoint, get_env, KaggleEnv +from kagglesdk.kaggle_object import KaggleObject +from typing import Type + + +# TODO (http://b/354237483) Generate the client from the existing one. +# This was created from kaggle_api_client.py, prior to recent changes to +# auth handling. The new client requires KAGGLE_API_TOKEN, so it is not +# currently usable by the CLI. + +def _headers_to_str(headers): + return '\n'.join(f'{k}: {v}' for k, v in headers.items()) + + +def _get_apikey_creds(): + apikey_filename = os.path.expanduser('~/.kaggle/kaggle.json') + if not os.path.exists(apikey_filename): + return None + + kaggle_json = None + with open(apikey_filename) as apikey_file: + kaggle_json = apikey_file.read() + + if not kaggle_json or not kaggle_json.strip(): + 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): + _xsrf_cookie_name = 'XSRF-TOKEN' + _csrf_cookie_name = "CSRF-TOKEN" + _xsrf_cookies = (_xsrf_cookie_name, _csrf_cookie_name) + _xsrf_header_name = 'X-XSRF-TOKEN' + + def __init__(self, + env: KaggleEnv = None, + verbose: bool = False, + renew_iap_token = None): + self._env = env or get_env() + self._signed_in = None + self._endpoint = get_endpoint(self._env) + self._verbose = verbose + self._session = None + + def call(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) + + http_response = self._session.send(http_request) + + response = self._prepare_response(response_type, http_response) + return response + + def _prepare_request(self, service_name: str, request_name: str, request: KaggleObject): + request_url = self._get_request_url(request) + method = request.method() + if method == 'POST': + data = request.__class__.to_dict(request) + else: + data = [] + http_request = requests.Request( + method=method, + url=request_url, + data=data, + headers=self._session.headers, + # cookies=self._get_xsrf_cookies(), + auth=self._session.auth) + prepared_request = http_request.prepare() + self._print_request(prepared_request) + return prepared_request + + def _get_xsrf_cookies(self): + cookies = requests.cookies.RequestsCookieJar() + for cookie in self._session.cookies: + if cookie.name in KaggleHttpClient._xsrf_cookies: + cookies[cookie.name] = cookie.value + return cookies + + def _prepare_response(self, response_type, http_response): + self._print_response(http_response) + http_response.raise_for_status() + if response_type is None: # Method doesn't have a return type + return None + return response_type.prepare_from(http_response) + + 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('--------------------------------------------------') + + def _print_response(self, response, body=True): + if not self._verbose: + return + self._print('---------------------Response---------------------') + self._print(f'{response.status_code}\n{_headers_to_str(response.headers)}') + if body: + self._print(f'\n{response.text}') + self._print('--------------------------------------------------') + + def _print(self, message: str): + if self._verbose: + print(message) + + def __enter__(self): + self._init_session() + return self + + def __exit__(self, exc_type, exc_value, tb): + if self._session is not None: + self._session.close() + + def _init_session(self): + if self._session is not None: + return self._session + + self._session = requests.Session() + self._session.headers.update({ + 'User-Agent': 'kaggle-api/v1.0.0', # Was: V2 + 'Content-Type': 'application/x-www-form-urlencoded', # Was: /json + }) + + iap_token = self._get_iap_token_if_required() + if iap_token is not None: + self._session.headers.update({ + # https://cloud.google.com/iap/docs/authentication-howto#authenticating_from_proxy-authorization_header + 'Proxy-Authorization': f'Bearer {iap_token}', + }) + + self._try_fill_auth() + self._fill_xsrf_token(iap_token) + + def _get_iap_token_if_required(self): + if self._env not in (KaggleEnv.STAGING, KaggleEnv.ADMIN): + return None + iap_token = os.getenv('KAGGLE_IAP_TOKEN') + if iap_token is None: + raise Exception(f'Must set KAGGLE_IAP_TOKEN to access "{self._endpoint}"') + return iap_token + + def _fill_xsrf_token(self, iap_token): + initial_get_request = requests.Request( + method='GET', + url=self._endpoint, + headers=self._session.headers, + auth=self._session.auth) + prepared_request = initial_get_request.prepare() + self._print_request(prepared_request) + + http_response = self._session.send(prepared_request) + + self._print_response(http_response, body=False) + if iap_token is not None and http_response.status_code in (401, 403): + raise requests.exceptions.HTTPError('IAP token invalid or expired') + http_response.raise_for_status() + + self._session.headers.update({ + KaggleHttpClient._xsrf_header_name: self._session.cookies[KaggleHttpClient._xsrf_cookie_name], + }) + + class BearerAuth(requests.auth.AuthBase): + def __init__(self, token): + self.token = token + + def __call__(self, r): + r.headers["Authorization"] = f"Bearer {self.token}" + return r + + def _try_fill_auth(self): + if self._signed_in is not None: + return + + api_token = os.getenv('KAGGLE_API_TOKEN') + if api_token is not None: + self._session.auth = KaggleHttpClient.BearerAuth(api_token) + self._signed_in = True + return + + apikey_creds = _get_apikey_creds() + if apikey_creds is not None: + self._session.auth = apikey_creds + self._signed_in = True + return + + self._signed_in = False + + def _get_request_url(self, request): + return f'{self._endpoint}{request.endpoint()}' diff --git a/kagglesdk/kaggle_object.py b/kagglesdk/kaggle_object.py new file mode 100644 index 0000000..4e064a2 --- /dev/null +++ b/kagglesdk/kaggle_object.py @@ -0,0 +1,263 @@ +import json +import re +from datetime import datetime, timedelta +from google.protobuf.field_mask_pb2 import FieldMask +from kagglesdk.models.types.model_enums import ModelFramework + + +class ObjectSerializer(object): + def __init__(self, to_dict_value, from_dict_value): + self.to_dict_value = to_dict_value + self.from_dict_value = from_dict_value + + +class PredefinedSerializer(ObjectSerializer): + def __init__(self): + """Predefined objects such as int, float etc are serialized/deserialized directly.""" + ObjectSerializer.__init__(self, lambda cls, v, _: v, lambda cls, v: v) + + +# Adapted from https://stackoverflow.com/questions/1175208/elegant-python-function-to-convert-camelcase-to-snake-case +_pascal_to_upper_snake_case_regex = re.compile('((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))') + + +def _pascal_case_to_upper_snake_case(string): + return _pascal_to_upper_snake_case_regex.sub(r'_\1', string).upper() + + +class EnumSerializer(ObjectSerializer): + def __init__(self): + """ + Enum objects are serialized using their ".name" field and deserialized by indexing the string in the Enum type. + Example: + class Foo(Enum): + TEST = 1 + foo = Foo.TEST + foo.name # => returns "TEST" + Foo["TEST"] # => returns Foo.TEST enum value. + """ + ObjectSerializer.__init__(self, + lambda cls, v, _: EnumSerializer._to_str(cls, v), + lambda cls, v: EnumSerializer._from_str(cls, v)) + + @staticmethod + def _to_str(cls, v): + # "v" corresponds to an enum instance: Example foo or Foo.Test above. + # "cls" corresponds to the enum type Foo above. + #enum_prefix = f'{_pascal_case_to_upper_snake_case(cls.__name__)}_' + #if v.name.startswith(enum_prefix): + # return v.name + #return f'{enum_prefix}{v.name}' + return v.name + + @staticmethod + def _from_str(cls, v): + # "v" corresponds to enum string: Example "TEST" above. + # "cls" corresponds to the enum type Foo above. + # enum_items = {item.name: item for item in cls} + # if v in enum_items: + # return enum_items[v] + # + # # Try with enum prefix. Example: EnvironmentType.JSON -> "ENVIRONMENT_TYPE_JSON" + # enum_prefix = _pascal_case_to_upper_snake_case(cls.__name__) + # if v.startswith(enum_prefix): + # ix_start = len(enum_prefix) + 1 + # return enum_items[v[ix_start:]] + # + # return enum_items[f'{enum_prefix}_{v}'] + return cls[v] + + +class ListSerializer(ObjectSerializer): + def __init__(self, item_serializer: ObjectSerializer): + """ + Lists are serialized based on the type they contain. Since objects are generated from proto files, a list always + contains objects of the same type, which is serialized/deserialized using "item_serializer". + """ + ObjectSerializer.__init__(self, + lambda cls, l, ignore_defaults: [item_serializer.to_dict_value(cls, v, ignore_defaults) for v in l], + lambda cls, l: [item_serializer.from_dict_value(cls, v) for v in l]) + + +class MapSerializer(ObjectSerializer): + def __init__(self, item_serializer: ObjectSerializer): + """ + Maps are serialized based on type of their values. Since maps keys are always predefined types, we don't need a + serializer for them. + """ + ObjectSerializer.__init__(self, + lambda cls, d, ignore_defaults: {k: item_serializer.to_dict_value(cls, v, ignore_defaults) for k, v in d.items()}, + lambda cls, d: {k: item_serializer.from_dict_value(cls, v) for k, v in d.items()}) + + +class DateTimeSerializer(ObjectSerializer): + def __init__(self): + """Date times are serialized/deserialized as a string in iso format""" + ObjectSerializer.__init__(self, + lambda cls, dt, _: DateTimeSerializer._to_str(dt), + lambda _, v: DateTimeSerializer._from_str(v)) + + @staticmethod + def _to_str(dt): + return dt.isoformat(timespec='milliseconds') + 'Z' + + @staticmethod + def _from_str(v): + v = v.rstrip('Z') + fields = v.rsplit('.', maxsplit=1) + if len(fields) == 1: + return datetime.fromisoformat(v) + (dt, nanos) = fields + millis = nanos[:3] + return datetime.fromisoformat(f'{dt}.{millis}') + + +class TimeDeltaSerializer(ObjectSerializer): + def __init__(self): + """Time deltas are serialized/deserialized as a string in "mm:ss" format""" + ObjectSerializer.__init__(self, + lambda cls, t, _: TimeDeltaSerializer._to_dict_value(t), + lambda cls, v: TimeDeltaSerializer._from_dict_value(v)) + + @staticmethod + def _to_dict_value(delta): + seconds = int(delta.total_seconds()) + minutes = seconds // 60 + seconds -= minutes * 60 + return '{}:{:02}'.format(int(minutes), int(seconds)) + + @staticmethod + def _from_dict_value(value): + (minutes, seconds) = value.split(':') + return timedelta(minutes=int(minutes), seconds=int(seconds)) + + +class FieldMaskSerializer(ObjectSerializer): + def __init__(self): + """Field masks are serialized/deserialized as a string that contains a list of paths with a comma delimiter""" + ObjectSerializer.__init__(self, + lambda cls, m, _: m.ToJsonString(), + lambda cls, v: FieldMaskSerializer._from_joined_paths(v)) + + @staticmethod + def _from_joined_paths(joined_paths): + mask = FieldMask() + mask.FromJsonString(joined_paths) + return mask + + +class KaggleObjectSerializer(ObjectSerializer): + def __init__(self): + """ + Kaggle objects (i.e., proto-generated types that inherit from KaggleObject) have custom "to_dict" and "from_dict" + methods that serialize/deserialize them to/from dictionaries. + """ + ObjectSerializer.__init__(self, + # "v" is an instance of a KaggleObject. For example: "req = ListCompetitionsRequest()". + # So "req.to_dict()" returns a dictionary with keys as json field names. Example: + # '{"pageSize": 10, "page": 2}' + lambda cls, v, ignore_defaults: cls.to_dict(v, ignore_defaults), + # "cls" is the type of a KaggleObject. For example: ListCompetitionsRequest. All + # generated Kaggle objects have "from_dict" class method that takes a dict to create a + # new instance of the object. See "KaggleObject" class definition below. + lambda cls, v: cls.from_dict(v)) + + +class FieldMetadata(object): + def __init__(self, json_name, field_name, private_field_name, field_type, default_value, serializer, optional=False): + self.json_name = json_name + self.field_name = field_name + self.private_field_name = private_field_name + self.field_type = field_type + self.default_value = default_value + self.serializer = serializer + self.optional = optional + + def get_as_dict_item(self, instance, ignore_defaults=True): + value = getattr(instance, self.private_field_name) + if ignore_defaults and value == self.default_value: + return None + if value is None: + return None + return self.serializer.to_dict_value(self.field_type, value, ignore_defaults) + + def set_from_dict(self, instance, json_dict): + if self.json_name not in json_dict: + return # Ignore unknown fields + value = json_dict[self.json_name] + if value == self.default_value: + return # Ignore default values + try: + setattr(instance, self.private_field_name, self.serializer.from_dict_value(self.field_type, value)) + except Exception as e: + raise + + +class KaggleObject(object): + def endpoint(self): + raise 'Error: endpoint must be defined by the request object' + + @classmethod + def prepare_from(cls, http_response): + return cls.from_json(http_response.text) + + @staticmethod + def method(): + return "GET" + + def _freeze(self): + self._is_frozen = True + + def __setattr__(self, key, value): + if hasattr(self, '_is_frozen') and not hasattr(self, key): + raise AttributeError(f'Unknown field for {self.__class__.__name__}: {key}') + object.__setattr__(self, key, value) + + @staticmethod + def to_dict(self, ignore_defaults=True): + kv_pairs = [(field.json_name, field.get_as_dict_item(self, ignore_defaults)) for field in self._fields] + return {k: v for (k, v) in kv_pairs if not ignore_defaults or v is not None} + + @staticmethod + def to_field_map(self, ignore_defaults=True): + kv_pairs = [(field.field_name, field.get_as_dict_item(self, ignore_defaults)) for field in self._fields] + return {k: v for (k, v) in kv_pairs if not ignore_defaults or v is not None} + + @classmethod + def from_dict(cls, json_dict): + instance = cls() + for field in cls._fields: + field.set_from_dict(instance, json_dict) + return instance + + @classmethod + def from_json(cls, json_str): + return cls.from_dict(json.loads(json_str)) + + @staticmethod + def to_json(self, ignore_defaults=True): + return json.dumps(KaggleObject.to_dict(self, ignore_defaults)) + + def __str__(self): + return KaggleObject.to_json(self, ignore_defaults=False) + + def __repr__(self): + return KaggleObject.to_json(self, ignore_defaults=False) + + def __contains__(self, field_name): + field = self._get_field(field_name) + value = getattr(self, field.private_field_name) + if field.optional: + return value is not None + else: + return value != field.default_value + + def __delattr__(self, field_name): + field = self._get_field(field_name) + setattr(self, field.private_field_name, field.default_value) + + def _get_field(self, field_name): + field = next((f for f in self._fields if f.field_name == field_name), None) + if field is None: + raise ValueError(f'Protocol message {self.__class__.__name__} has no "{field_name}" field.') + return field diff --git a/kagglesdk/kernels/__init__.py b/kagglesdk/kernels/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/kernels/services/__init__.py b/kagglesdk/kernels/services/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/kernels/services/kernels_api_service.py b/kagglesdk/kernels/services/kernels_api_service.py new file mode 100644 index 0000000..dbccb8e --- /dev/null +++ b/kagglesdk/kernels/services/kernels_api_service.py @@ -0,0 +1,79 @@ +from kagglesdk.kaggle_http_client import KaggleHttpClient +from kagglesdk.kernels.types.kernels_api_service import ApiGetKernelRequest, ApiGetKernelResponse, ApiGetKernelSessionStatusRequest, ApiGetKernelSessionStatusResponse, ApiListKernelFilesRequest, ApiListKernelFilesResponse, ApiListKernelSessionOutputRequest, ApiListKernelSessionOutputResponse, ApiListKernelsRequest, ApiListKernelsResponse, ApiSaveKernelRequest, ApiSaveKernelResponse + +class KernelsApiClient(object): + + def __init__(self, client: KaggleHttpClient): + self._client = client + + def list_kernels(self, request: ApiListKernelsRequest = None) -> ApiListKernelsResponse: + r""" + Args: + request (ApiListKernelsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListKernelsRequest() + + return self._client.call("kernels.KernelsApiService", "ApiListKernels", request, ApiListKernelsResponse) + + def list_kernel_files(self, request: ApiListKernelFilesRequest = None) -> ApiListKernelFilesResponse: + r""" + Args: + request (ApiListKernelFilesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListKernelFilesRequest() + + return self._client.call("kernels.KernelsApiService", "ApiListKernelFiles", request, ApiListKernelFilesResponse) + + def get_kernel(self, request: ApiGetKernelRequest = None) -> ApiGetKernelResponse: + r""" + Args: + request (ApiGetKernelRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetKernelRequest() + + return self._client.call("kernels.KernelsApiService", "ApiGetKernel", request, ApiGetKernelResponse) + + def save_kernel(self, request: ApiSaveKernelRequest = None) -> ApiSaveKernelResponse: + r""" + Args: + request (ApiSaveKernelRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiSaveKernelRequest() + + return self._client.call("kernels.KernelsApiService", "ApiSaveKernel", request, ApiSaveKernelResponse) + + def list_kernel_session_output(self, request: ApiListKernelSessionOutputRequest = None) -> ApiListKernelSessionOutputResponse: + r""" + Args: + request (ApiListKernelSessionOutputRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListKernelSessionOutputRequest() + + return self._client.call("kernels.KernelsApiService", "ApiListKernelSessionOutput", request, ApiListKernelSessionOutputResponse) + + def get_kernel_session_status(self, request: ApiGetKernelSessionStatusRequest = None) -> ApiGetKernelSessionStatusResponse: + r""" + Args: + request (ApiGetKernelSessionStatusRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetKernelSessionStatusRequest() + + return self._client.call("kernels.KernelsApiService", "ApiGetKernelSessionStatus", request, ApiGetKernelSessionStatusResponse) diff --git a/kagglesdk/kernels/types/__init__.py b/kagglesdk/kernels/types/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/kernels/types/kernels_api_service.py b/kagglesdk/kernels/types/kernels_api_service.py new file mode 100644 index 0000000..e0854a9 --- /dev/null +++ b/kagglesdk/kernels/types/kernels_api_service.py @@ -0,0 +1,1748 @@ +from datetime import datetime +from kagglesdk.kaggle_object import * +from kagglesdk.kernels.types.kernels_enums import KernelsListSortType, KernelsListViewType, KernelWorkerStatus +from typing import Optional, List + +class ApiGetKernelRequest(KaggleObject): + r""" + Attributes: + user_name (str) + kernel_slug (str) + """ + + def __init__(self): + self._user_name = "" + self._kernel_slug = "" + self._freeze() + + @property + def user_name(self) -> str: + return self._user_name + + @user_name.setter + def user_name(self, user_name: str): + if user_name is None: + del self.user_name + return + if not isinstance(user_name, str): + raise TypeError('user_name must be of type str') + self._user_name = user_name + + @property + def kernel_slug(self) -> str: + return self._kernel_slug + + @kernel_slug.setter + def kernel_slug(self, kernel_slug: str): + if kernel_slug is None: + del self.kernel_slug + return + if not isinstance(kernel_slug, str): + raise TypeError('kernel_slug must be of type str') + self._kernel_slug = kernel_slug + + + def endpoint(self): + path = '/api/v1/kernels/pull' + return path.format_map(self.to_field_map(self)) + +class ApiGetKernelResponse(KaggleObject): + r""" + Attributes: + metadata (ApiKernelMetadata) + blob (ApiKernelBlob) + """ + + def __init__(self): + self._metadata = None + self._blob = None + self._freeze() + + @property + def metadata(self) -> Optional['ApiKernelMetadata']: + return self._metadata + + @metadata.setter + def metadata(self, metadata: Optional['ApiKernelMetadata']): + if metadata is None: + del self.metadata + return + if not isinstance(metadata, ApiKernelMetadata): + raise TypeError('metadata must be of type ApiKernelMetadata') + self._metadata = metadata + + @property + def blob(self) -> Optional['ApiKernelBlob']: + return self._blob + + @blob.setter + def blob(self, blob: Optional['ApiKernelBlob']): + if blob is None: + del self.blob + return + if not isinstance(blob, ApiKernelBlob): + raise TypeError('blob must be of type ApiKernelBlob') + self._blob = blob + + +class ApiGetKernelSessionStatusRequest(KaggleObject): + r""" + Attributes: + user_name (str) + kernel_slug (str) + """ + + def __init__(self): + self._user_name = "" + self._kernel_slug = "" + self._freeze() + + @property + def user_name(self) -> str: + return self._user_name + + @user_name.setter + def user_name(self, user_name: str): + if user_name is None: + del self.user_name + return + if not isinstance(user_name, str): + raise TypeError('user_name must be of type str') + self._user_name = user_name + + @property + def kernel_slug(self) -> str: + return self._kernel_slug + + @kernel_slug.setter + def kernel_slug(self, kernel_slug: str): + if kernel_slug is None: + del self.kernel_slug + return + if not isinstance(kernel_slug, str): + raise TypeError('kernel_slug must be of type str') + self._kernel_slug = kernel_slug + + + def endpoint(self): + path = '/api/v1/kernels/status' + return path.format_map(self.to_field_map(self)) + +class ApiGetKernelSessionStatusResponse(KaggleObject): + r""" + Attributes: + status (KernelWorkerStatus) + failure_message (str) + """ + + def __init__(self): + self._status = KernelWorkerStatus.QUEUED + self._failure_message = None + self._freeze() + + @property + def status(self) -> 'KernelWorkerStatus': + return self._status + + @status.setter + def status(self, status: 'KernelWorkerStatus'): + if status is None: + del self.status + return + if not isinstance(status, KernelWorkerStatus): + raise TypeError('status must be of type KernelWorkerStatus') + self._status = status + + @property + def failure_message(self) -> str: + return self._failure_message or "" + + @failure_message.setter + def failure_message(self, failure_message: str): + if failure_message is None: + del self.failure_message + return + if not isinstance(failure_message, str): + raise TypeError('failure_message must be of type str') + self._failure_message = failure_message + + +class ApiKernelBlob(KaggleObject): + r""" + Attributes: + source (str) + language (str) + kernel_type (str) + slug (str) + """ + + def __init__(self): + self._source = None + self._language = None + self._kernel_type = None + self._slug = None + self._freeze() + + @property + def source(self) -> str: + return self._source or "" + + @source.setter + def source(self, source: str): + if source is None: + del self.source + return + if not isinstance(source, str): + raise TypeError('source must be of type str') + self._source = source + + @property + def language(self) -> str: + return self._language or "" + + @language.setter + def language(self, language: str): + if language is None: + del self.language + return + if not isinstance(language, str): + raise TypeError('language must be of type str') + self._language = language + + @property + def kernel_type(self) -> str: + return self._kernel_type or "" + + @kernel_type.setter + def kernel_type(self, kernel_type: str): + if kernel_type is None: + del self.kernel_type + return + if not isinstance(kernel_type, str): + raise TypeError('kernel_type must be of type str') + self._kernel_type = kernel_type + + @property + def slug(self) -> str: + return self._slug or "" + + @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 + + +class ApiKernelMetadata(KaggleObject): + r""" + Attributes: + id (int) + ref (str) + title (str) + author (str) + slug (str) + last_run_time (datetime) + language (str) + kernel_type (str) + is_private (bool) + enable_gpu (bool) + enable_tpu (bool) + enable_internet (bool) + category_ids (str) + dataset_data_sources (str) + kernel_data_sources (str) + competition_data_sources (str) + model_data_sources (str) + total_votes (int) + """ + + def __init__(self): + self._id = 0 + self._ref = "" + self._title = "" + self._author = "" + self._slug = "" + self._last_run_time = None + self._language = None + self._kernel_type = None + self._is_private = None + self._enable_gpu = None + self._enable_tpu = None + self._enable_internet = None + self._category_ids = [] + self._dataset_data_sources = [] + self._kernel_data_sources = [] + self._competition_data_sources = [] + self._model_data_sources = [] + self._total_votes = 0 + self._freeze() + + @property + def id(self) -> int: + return self._id + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def ref(self) -> str: + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def 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 author(self) -> str: + return self._author + + @author.setter + def author(self, author: str): + if author is None: + del self.author + return + if not isinstance(author, str): + raise TypeError('author must be of type str') + self._author = author + + @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 last_run_time(self) -> datetime: + return self._last_run_time + + @last_run_time.setter + def last_run_time(self, last_run_time: datetime): + if last_run_time is None: + del self.last_run_time + return + if not isinstance(last_run_time, datetime): + raise TypeError('last_run_time must be of type datetime') + self._last_run_time = last_run_time + + @property + def language(self) -> str: + return self._language or "" + + @language.setter + def language(self, language: str): + if language is None: + del self.language + return + if not isinstance(language, str): + raise TypeError('language must be of type str') + self._language = language + + @property + def kernel_type(self) -> str: + return self._kernel_type or "" + + @kernel_type.setter + def kernel_type(self, kernel_type: str): + if kernel_type is None: + del self.kernel_type + return + if not isinstance(kernel_type, str): + raise TypeError('kernel_type must be of type str') + self._kernel_type = kernel_type + + @property + def is_private(self) -> bool: + return self._is_private or False + + @is_private.setter + def is_private(self, is_private: bool): + if is_private is None: + del self.is_private + return + if not isinstance(is_private, bool): + raise TypeError('is_private must be of type bool') + self._is_private = is_private + + @property + def enable_gpu(self) -> bool: + return self._enable_gpu or False + + @enable_gpu.setter + def enable_gpu(self, enable_gpu: bool): + if enable_gpu is None: + del self.enable_gpu + return + if not isinstance(enable_gpu, bool): + raise TypeError('enable_gpu must be of type bool') + self._enable_gpu = enable_gpu + + @property + def enable_tpu(self) -> bool: + return self._enable_tpu or False + + @enable_tpu.setter + def enable_tpu(self, enable_tpu: bool): + if enable_tpu is None: + del self.enable_tpu + return + if not isinstance(enable_tpu, bool): + raise TypeError('enable_tpu must be of type bool') + self._enable_tpu = enable_tpu + + @property + def enable_internet(self) -> bool: + return self._enable_internet or False + + @enable_internet.setter + def enable_internet(self, enable_internet: bool): + if enable_internet is None: + del self.enable_internet + return + if not isinstance(enable_internet, bool): + raise TypeError('enable_internet must be of type bool') + self._enable_internet = enable_internet + + @property + def category_ids(self) -> Optional[List[str]]: + return self._category_ids + + @category_ids.setter + def category_ids(self, category_ids: Optional[List[str]]): + if category_ids is None: + del self.category_ids + return + if not isinstance(category_ids, list): + raise TypeError('category_ids must be of type list') + if not all([isinstance(t, str) for t in category_ids]): + raise TypeError('category_ids must contain only items of type str') + self._category_ids = category_ids + + @property + def dataset_data_sources(self) -> Optional[List[str]]: + return self._dataset_data_sources + + @dataset_data_sources.setter + def dataset_data_sources(self, dataset_data_sources: Optional[List[str]]): + if dataset_data_sources is None: + del self.dataset_data_sources + return + if not isinstance(dataset_data_sources, list): + raise TypeError('dataset_data_sources must be of type list') + if not all([isinstance(t, str) for t in dataset_data_sources]): + raise TypeError('dataset_data_sources must contain only items of type str') + self._dataset_data_sources = dataset_data_sources + + @property + def kernel_data_sources(self) -> Optional[List[str]]: + return self._kernel_data_sources + + @kernel_data_sources.setter + def kernel_data_sources(self, kernel_data_sources: Optional[List[str]]): + if kernel_data_sources is None: + del self.kernel_data_sources + return + if not isinstance(kernel_data_sources, list): + raise TypeError('kernel_data_sources must be of type list') + if not all([isinstance(t, str) for t in kernel_data_sources]): + raise TypeError('kernel_data_sources must contain only items of type str') + self._kernel_data_sources = kernel_data_sources + + @property + def competition_data_sources(self) -> Optional[List[str]]: + return self._competition_data_sources + + @competition_data_sources.setter + def competition_data_sources(self, competition_data_sources: Optional[List[str]]): + if competition_data_sources is None: + del self.competition_data_sources + return + if not isinstance(competition_data_sources, list): + raise TypeError('competition_data_sources must be of type list') + if not all([isinstance(t, str) for t in competition_data_sources]): + raise TypeError('competition_data_sources must contain only items of type str') + self._competition_data_sources = competition_data_sources + + @property + def model_data_sources(self) -> Optional[List[str]]: + return self._model_data_sources + + @model_data_sources.setter + def model_data_sources(self, model_data_sources: Optional[List[str]]): + if model_data_sources is None: + del self.model_data_sources + return + if not isinstance(model_data_sources, list): + raise TypeError('model_data_sources must be of type list') + if not all([isinstance(t, str) for t in model_data_sources]): + raise TypeError('model_data_sources must contain only items of type str') + self._model_data_sources = model_data_sources + + @property + def total_votes(self) -> int: + return self._total_votes + + @total_votes.setter + def total_votes(self, total_votes: int): + if total_votes is None: + del self.total_votes + return + if not isinstance(total_votes, int): + raise TypeError('total_votes must be of type int') + self._total_votes = total_votes + + +class ApiListKernelFilesRequest(KaggleObject): + r""" + Attributes: + user_name (str) + kernel_slug (str) + page_size (int) + page_token (str) + """ + + def __init__(self): + self._user_name = "" + self._kernel_slug = "" + self._page_size = None + self._page_token = None + self._freeze() + + @property + def user_name(self) -> str: + return self._user_name + + @user_name.setter + def user_name(self, user_name: str): + if user_name is None: + del self.user_name + return + if not isinstance(user_name, str): + raise TypeError('user_name must be of type str') + self._user_name = user_name + + @property + def kernel_slug(self) -> str: + return self._kernel_slug + + @kernel_slug.setter + def kernel_slug(self, kernel_slug: str): + if kernel_slug is None: + del self.kernel_slug + return + if not isinstance(kernel_slug, str): + raise TypeError('kernel_slug must be of type str') + self._kernel_slug = kernel_slug + + @property + def page_size(self) -> int: + return self._page_size or 0 + + @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 or "" + + @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 + + + def endpoint(self): + path = '/api/v1/kernels/files' + return path.format_map(self.to_field_map(self)) + +class ApiListKernelFilesResponse(KaggleObject): + r""" + Attributes: + files (ApiListKernelFilesItem) + next_page_token (str) + """ + + def __init__(self): + self._files = [] + self._next_page_token = None + self._freeze() + + @property + def files(self) -> Optional[List[Optional['ApiListKernelFilesItem']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiListKernelFilesItem']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiListKernelFilesItem) for t in files]): + raise TypeError('files must contain only items of type ApiListKernelFilesItem') + self._files = files + + @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: 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 + + +class ApiListKernelSessionOutputRequest(KaggleObject): + r""" + Attributes: + user_name (str) + kernel_slug (str) + page_size (int) + page_token (str) + """ + + def __init__(self): + self._user_name = "" + self._kernel_slug = "" + self._page_size = None + self._page_token = None + self._freeze() + + @property + def user_name(self) -> str: + return self._user_name + + @user_name.setter + def user_name(self, user_name: str): + if user_name is None: + del self.user_name + return + if not isinstance(user_name, str): + raise TypeError('user_name must be of type str') + self._user_name = user_name + + @property + def kernel_slug(self) -> str: + return self._kernel_slug + + @kernel_slug.setter + def kernel_slug(self, kernel_slug: str): + if kernel_slug is None: + del self.kernel_slug + return + if not isinstance(kernel_slug, str): + raise TypeError('kernel_slug must be of type str') + self._kernel_slug = kernel_slug + + @property + def page_size(self) -> int: + return self._page_size or 0 + + @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 or "" + + @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 + + + def endpoint(self): + path = '/api/v1/kernels/output' + return path.format_map(self.to_field_map(self)) + +class ApiListKernelSessionOutputResponse(KaggleObject): + r""" + Attributes: + files (ApiKernelSessionOutputFile) + log (str) + next_page_token (str) + """ + + def __init__(self): + self._files = [] + self._log = None + self._next_page_token = None + self._freeze() + + @property + def files(self) -> Optional[List[Optional['ApiKernelSessionOutputFile']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiKernelSessionOutputFile']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiKernelSessionOutputFile) for t in files]): + raise TypeError('files must contain only items of type ApiKernelSessionOutputFile') + self._files = files + + @property + def log(self) -> str: + return self._log or "" + + @log.setter + def log(self, log: str): + if log is None: + del self.log + return + if not isinstance(log, str): + raise TypeError('log must be of type str') + self._log = log + + @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: 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 + + +class ApiListKernelsRequest(KaggleObject): + r""" + Attributes: + competition (str) + Display kernels using the specified competition. + dataset (str) + Display kernels using the specified dataset. + parent_kernel (str) + Display kernels that have forked the specified kernel. + group (KernelsListViewType) + Display your kernels, collaborated, bookmarked or upvoted kernels. + kernel_type (str) + Display kernels of a specific type. + language (str) + Display kernels in a specific language. One of 'all', 'python', 'r', + 'sqlite' and 'julia'. + output_type (str) + Display kernels with a specific output type. One of 'all', 'visualization' + and 'notebook'. + search (str) + Display kernels matching the specified search terms. + sort_by (KernelsListSortType) + Sort the results (default is 'hotness'). 'relevance' only works if there is + a search query. + user (str) + Display kernels by a particular user or group. + page (int) + Page number (default is 1). + page_size (int) + Page size, i.e., maximum number of results to return. + """ + + def __init__(self): + self._competition = None + self._dataset = None + self._parent_kernel = None + self._group = KernelsListViewType.KERNELS_LIST_VIEW_TYPE_UNSPECIFIED + self._kernel_type = None + self._language = None + self._output_type = None + self._search = None + self._sort_by = KernelsListSortType.HOTNESS + self._user = None + self._page = None + self._page_size = None + self._freeze() + + @property + def competition(self) -> str: + """Display kernels using the specified competition.""" + return self._competition or "" + + @competition.setter + def competition(self, competition: str): + if competition is None: + del self.competition + return + if not isinstance(competition, str): + raise TypeError('competition must be of type str') + self._competition = competition + + @property + def dataset(self) -> str: + """Display kernels using the specified dataset.""" + return self._dataset or "" + + @dataset.setter + def dataset(self, dataset: str): + if dataset is None: + del self.dataset + return + if not isinstance(dataset, str): + raise TypeError('dataset must be of type str') + self._dataset = dataset + + @property + def parent_kernel(self) -> str: + """Display kernels that have forked the specified kernel.""" + return self._parent_kernel or "" + + @parent_kernel.setter + def parent_kernel(self, parent_kernel: str): + if parent_kernel is None: + del self.parent_kernel + return + if not isinstance(parent_kernel, str): + raise TypeError('parent_kernel must be of type str') + self._parent_kernel = parent_kernel + + @property + def group(self) -> 'KernelsListViewType': + """Display your kernels, collaborated, bookmarked or upvoted kernels.""" + return self._group + + @group.setter + def group(self, group: 'KernelsListViewType'): + if group is None: + del self.group + return + if not isinstance(group, KernelsListViewType): + raise TypeError('group must be of type KernelsListViewType') + self._group = group + + @property + def kernel_type(self) -> str: + """Display kernels of a specific type.""" + return self._kernel_type or "" + + @kernel_type.setter + def kernel_type(self, kernel_type: str): + if kernel_type is None: + del self.kernel_type + return + if not isinstance(kernel_type, str): + raise TypeError('kernel_type must be of type str') + self._kernel_type = kernel_type + + @property + def language(self) -> str: + r""" + Display kernels in a specific language. One of 'all', 'python', 'r', + 'sqlite' and 'julia'. + """ + return self._language or "" + + @language.setter + def language(self, language: str): + if language is None: + del self.language + return + if not isinstance(language, str): + raise TypeError('language must be of type str') + self._language = language + + @property + def output_type(self) -> str: + r""" + Display kernels with a specific output type. One of 'all', 'visualization' + and 'notebook'. + """ + return self._output_type or "" + + @output_type.setter + def output_type(self, output_type: str): + if output_type is None: + del self.output_type + return + if not isinstance(output_type, str): + raise TypeError('output_type must be of type str') + self._output_type = output_type + + @property + def search(self) -> str: + """Display kernels matching the specified search terms.""" + return self._search or "" + + @search.setter + def search(self, search: str): + if search is None: + del self.search + return + if not isinstance(search, str): + raise TypeError('search must be of type str') + self._search = search + + @property + def sort_by(self) -> 'KernelsListSortType': + r""" + Sort the results (default is 'hotness'). 'relevance' only works if there is + a search query. + """ + return self._sort_by + + @sort_by.setter + def sort_by(self, sort_by: 'KernelsListSortType'): + if sort_by is None: + del self.sort_by + return + if not isinstance(sort_by, KernelsListSortType): + raise TypeError('sort_by must be of type KernelsListSortType') + self._sort_by = sort_by + + @property + def user(self) -> str: + """Display kernels by a particular user or group.""" + return self._user or "" + + @user.setter + def user(self, user: str): + if user is None: + del self.user + return + if not isinstance(user, str): + raise TypeError('user must be of type str') + self._user = user + + @property + def page(self) -> int: + """Page number (default is 1).""" + return self._page or 0 + + @page.setter + def page(self, page: int): + if page is None: + del self.page + return + if not isinstance(page, int): + raise TypeError('page must be of type int') + self._page = page + + @property + def page_size(self) -> int: + """Page size, i.e., maximum number of results to return.""" + return self._page_size or 0 + + @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 + + + def endpoint(self): + path = '/api/v1/kernels/list' + return path.format_map(self.to_field_map(self)) + +class ApiListKernelsResponse(KaggleObject): + r""" + Attributes: + kernels (ApiKernelMetadata) + """ + + def __init__(self): + self._kernels = [] + self._freeze() + + @property + def kernels(self) -> Optional[List[Optional['ApiKernelMetadata']]]: + return self._kernels + + @kernels.setter + def kernels(self, kernels: Optional[List[Optional['ApiKernelMetadata']]]): + if kernels is None: + del self.kernels + return + if not isinstance(kernels, list): + raise TypeError('kernels must be of type list') + if not all([isinstance(t, ApiKernelMetadata) for t in kernels]): + raise TypeError('kernels must contain only items of type ApiKernelMetadata') + self._kernels = kernels + + + @classmethod + def prepare_from(cls, http_response): + return cls.from_dict({'kernels': json.loads(http_response.text)}) + +class ApiSaveKernelRequest(KaggleObject): + r""" + Attributes: + id (int) + The kernel's unique ID number. One of `id` and `slug` are required. If both + are specified, `id` will be preferred. + slug (str) + The full slug of the kernel to push to, in the format + `{username}/{kernel-slug}`. The kernel slug must be the title lowercased + with dashes (`-`) replacing spaces. One of `id` and `slug` are required. If + both are specified, `id` will be preferred. + new_title (str) + The title to be set on the kernel. + text (str) + The kernel's source code. + language (str) + The language that the kernel is written in. One of 'python', 'r' and + 'rmarkdown'. + kernel_type (str) + The type of kernel. Cannot be changed once the kernel has been created. + dataset_data_sources (str) + A list of dataset data sources that the kernel should use. Each dataset is + specified as + `{username}/{dataset-slug}`. + kernel_data_sources (str) + A list of kernel data sources that the kernel should use. Each dataset is + specified as + `{username}/{kernel-slug}`. + competition_data_sources (str) + A list of competition data sources that the kernel should use + category_ids (str) + A list of tag IDs to associated with the kernel. + is_private (bool) + Whether or not the kernel should be private. + enable_gpu (bool) + Whether or not the kernel should run on a GPU. + enable_tpu (bool) + Whether or not the kernel should run on a TPU. + enable_internet (bool) + Whether or not the kernel should be able to access the internet. + docker_image_pinning_type (str) + Which docker image to use for executing new versions going forward. + model_data_sources (str) + A list of model data sources that the kernel should use. + Each model is specified as (for the latest version): + `{username}/{model-slug}/{framework}/{variation-slug}` + Or versioned: + `{username}/{model-slug}/{framework}/{variation-slug}/{version-number}` + """ + + def __init__(self): + self._id = None + self._slug = None + self._new_title = None + self._text = None + self._language = None + self._kernel_type = None + self._dataset_data_sources = [] + self._kernel_data_sources = [] + self._competition_data_sources = [] + self._category_ids = [] + self._is_private = None + self._enable_gpu = None + self._enable_tpu = None + self._enable_internet = None + self._docker_image_pinning_type = None + self._model_data_sources = [] + self._freeze() + + @property + def id(self) -> int: + r""" + The kernel's unique ID number. One of `id` and `slug` are required. If both + are specified, `id` will be preferred. + """ + return self._id or 0 + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def slug(self) -> str: + r""" + The full slug of the kernel to push to, in the format + `{username}/{kernel-slug}`. The kernel slug must be the title lowercased + with dashes (`-`) replacing spaces. One of `id` and `slug` are required. If + both are specified, `id` will be preferred. + """ + return self._slug or "" + + @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 new_title(self) -> str: + """The title to be set on the kernel.""" + return self._new_title or "" + + @new_title.setter + def new_title(self, new_title: str): + if new_title is None: + del self.new_title + return + if not isinstance(new_title, str): + raise TypeError('new_title must be of type str') + self._new_title = new_title + + @property + def text(self) -> str: + """The kernel's source code.""" + return self._text or "" + + @text.setter + def text(self, text: str): + if text is None: + del self.text + return + if not isinstance(text, str): + raise TypeError('text must be of type str') + self._text = text + + @property + def language(self) -> str: + r""" + The language that the kernel is written in. One of 'python', 'r' and + 'rmarkdown'. + """ + return self._language or "" + + @language.setter + def language(self, language: str): + if language is None: + del self.language + return + if not isinstance(language, str): + raise TypeError('language must be of type str') + self._language = language + + @property + def kernel_type(self) -> str: + """The type of kernel. Cannot be changed once the kernel has been created.""" + return self._kernel_type or "" + + @kernel_type.setter + def kernel_type(self, kernel_type: str): + if kernel_type is None: + del self.kernel_type + return + if not isinstance(kernel_type, str): + raise TypeError('kernel_type must be of type str') + self._kernel_type = kernel_type + + @property + def dataset_data_sources(self) -> Optional[List[str]]: + r""" + A list of dataset data sources that the kernel should use. Each dataset is + specified as + `{username}/{dataset-slug}`. + """ + return self._dataset_data_sources + + @dataset_data_sources.setter + def dataset_data_sources(self, dataset_data_sources: Optional[List[str]]): + if dataset_data_sources is None: + del self.dataset_data_sources + return + if not isinstance(dataset_data_sources, list): + raise TypeError('dataset_data_sources must be of type list') + if not all([isinstance(t, str) for t in dataset_data_sources]): + raise TypeError('dataset_data_sources must contain only items of type str') + self._dataset_data_sources = dataset_data_sources + + @property + def kernel_data_sources(self) -> Optional[List[str]]: + r""" + A list of kernel data sources that the kernel should use. Each dataset is + specified as + `{username}/{kernel-slug}`. + """ + return self._kernel_data_sources + + @kernel_data_sources.setter + def kernel_data_sources(self, kernel_data_sources: Optional[List[str]]): + if kernel_data_sources is None: + del self.kernel_data_sources + return + if not isinstance(kernel_data_sources, list): + raise TypeError('kernel_data_sources must be of type list') + if not all([isinstance(t, str) for t in kernel_data_sources]): + raise TypeError('kernel_data_sources must contain only items of type str') + self._kernel_data_sources = kernel_data_sources + + @property + def competition_data_sources(self) -> Optional[List[str]]: + """A list of competition data sources that the kernel should use""" + return self._competition_data_sources + + @competition_data_sources.setter + def competition_data_sources(self, competition_data_sources: Optional[List[str]]): + if competition_data_sources is None: + del self.competition_data_sources + return + if not isinstance(competition_data_sources, list): + raise TypeError('competition_data_sources must be of type list') + if not all([isinstance(t, str) for t in competition_data_sources]): + raise TypeError('competition_data_sources must contain only items of type str') + self._competition_data_sources = competition_data_sources + + @property + def category_ids(self) -> Optional[List[str]]: + """A list of tag IDs to associated with the kernel.""" + return self._category_ids + + @category_ids.setter + def category_ids(self, category_ids: Optional[List[str]]): + if category_ids is None: + del self.category_ids + return + if not isinstance(category_ids, list): + raise TypeError('category_ids must be of type list') + if not all([isinstance(t, str) for t in category_ids]): + raise TypeError('category_ids must contain only items of type str') + self._category_ids = category_ids + + @property + def is_private(self) -> bool: + """Whether or not the kernel should be private.""" + return self._is_private or False + + @is_private.setter + def is_private(self, is_private: bool): + if is_private is None: + del self.is_private + return + if not isinstance(is_private, bool): + raise TypeError('is_private must be of type bool') + self._is_private = is_private + + @property + def enable_gpu(self) -> bool: + """Whether or not the kernel should run on a GPU.""" + return self._enable_gpu or False + + @enable_gpu.setter + def enable_gpu(self, enable_gpu: bool): + if enable_gpu is None: + del self.enable_gpu + return + if not isinstance(enable_gpu, bool): + raise TypeError('enable_gpu must be of type bool') + self._enable_gpu = enable_gpu + + @property + def enable_tpu(self) -> bool: + """Whether or not the kernel should run on a TPU.""" + return self._enable_tpu or False + + @enable_tpu.setter + def enable_tpu(self, enable_tpu: bool): + if enable_tpu is None: + del self.enable_tpu + return + if not isinstance(enable_tpu, bool): + raise TypeError('enable_tpu must be of type bool') + self._enable_tpu = enable_tpu + + @property + def enable_internet(self) -> bool: + """Whether or not the kernel should be able to access the internet.""" + return self._enable_internet or False + + @enable_internet.setter + def enable_internet(self, enable_internet: bool): + if enable_internet is None: + del self.enable_internet + return + if not isinstance(enable_internet, bool): + raise TypeError('enable_internet must be of type bool') + self._enable_internet = enable_internet + + @property + def docker_image_pinning_type(self) -> str: + """Which docker image to use for executing new versions going forward.""" + return self._docker_image_pinning_type or "" + + @docker_image_pinning_type.setter + def docker_image_pinning_type(self, docker_image_pinning_type: str): + if docker_image_pinning_type is None: + del self.docker_image_pinning_type + return + if not isinstance(docker_image_pinning_type, str): + raise TypeError('docker_image_pinning_type must be of type str') + self._docker_image_pinning_type = docker_image_pinning_type + + @property + def model_data_sources(self) -> Optional[List[str]]: + r""" + A list of model data sources that the kernel should use. + Each model is specified as (for the latest version): + `{username}/{model-slug}/{framework}/{variation-slug}` + Or versioned: + `{username}/{model-slug}/{framework}/{variation-slug}/{version-number}` + """ + return self._model_data_sources + + @model_data_sources.setter + def model_data_sources(self, model_data_sources: Optional[List[str]]): + if model_data_sources is None: + del self.model_data_sources + return + if not isinstance(model_data_sources, list): + raise TypeError('model_data_sources must be of type list') + if not all([isinstance(t, str) for t in model_data_sources]): + raise TypeError('model_data_sources must contain only items of type str') + self._model_data_sources = model_data_sources + + + def endpoint(self): + path = '/api/v1/kernels/push' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiSaveKernelResponse(KaggleObject): + r""" + Attributes: + ref (str) + url (str) + version_number (int) + error (str) + invalid_tags (str) + invalid_dataset_sources (str) + invalid_competition_sources (str) + invalid_kernel_sources (str) + invalid_model_sources (str) + """ + + def __init__(self): + self._ref = "" + self._url = "" + self._version_number = None + self._error = None + self._invalid_tags = [] + self._invalid_dataset_sources = [] + self._invalid_competition_sources = [] + self._invalid_kernel_sources = [] + self._invalid_model_sources = [] + self._freeze() + + @property + def ref(self) -> str: + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def url(self) -> str: + 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 version_number(self) -> int: + return self._version_number or 0 + + @version_number.setter + def version_number(self, version_number: int): + if version_number is None: + del self.version_number + return + if not isinstance(version_number, int): + raise TypeError('version_number must be of type int') + self._version_number = version_number + + @property + def error(self) -> str: + return self._error or "" + + @error.setter + def error(self, error: str): + if error is None: + del self.error + return + if not isinstance(error, str): + raise TypeError('error must be of type str') + self._error = error + + @property + def invalid_tags(self) -> Optional[List[str]]: + return self._invalid_tags + + @invalid_tags.setter + def invalid_tags(self, invalid_tags: Optional[List[str]]): + if invalid_tags is None: + del self.invalid_tags + return + if not isinstance(invalid_tags, list): + raise TypeError('invalid_tags must be of type list') + if not all([isinstance(t, str) for t in invalid_tags]): + raise TypeError('invalid_tags must contain only items of type str') + self._invalid_tags = invalid_tags + + @property + def invalid_dataset_sources(self) -> Optional[List[str]]: + return self._invalid_dataset_sources + + @invalid_dataset_sources.setter + def invalid_dataset_sources(self, invalid_dataset_sources: Optional[List[str]]): + if invalid_dataset_sources is None: + del self.invalid_dataset_sources + return + if not isinstance(invalid_dataset_sources, list): + raise TypeError('invalid_dataset_sources must be of type list') + if not all([isinstance(t, str) for t in invalid_dataset_sources]): + raise TypeError('invalid_dataset_sources must contain only items of type str') + self._invalid_dataset_sources = invalid_dataset_sources + + @property + def invalid_competition_sources(self) -> Optional[List[str]]: + return self._invalid_competition_sources + + @invalid_competition_sources.setter + def invalid_competition_sources(self, invalid_competition_sources: Optional[List[str]]): + if invalid_competition_sources is None: + del self.invalid_competition_sources + return + if not isinstance(invalid_competition_sources, list): + raise TypeError('invalid_competition_sources must be of type list') + if not all([isinstance(t, str) for t in invalid_competition_sources]): + raise TypeError('invalid_competition_sources must contain only items of type str') + self._invalid_competition_sources = invalid_competition_sources + + @property + def invalid_kernel_sources(self) -> Optional[List[str]]: + return self._invalid_kernel_sources + + @invalid_kernel_sources.setter + def invalid_kernel_sources(self, invalid_kernel_sources: Optional[List[str]]): + if invalid_kernel_sources is None: + del self.invalid_kernel_sources + return + if not isinstance(invalid_kernel_sources, list): + raise TypeError('invalid_kernel_sources must be of type list') + if not all([isinstance(t, str) for t in invalid_kernel_sources]): + raise TypeError('invalid_kernel_sources must contain only items of type str') + self._invalid_kernel_sources = invalid_kernel_sources + + @property + def invalid_model_sources(self) -> Optional[List[str]]: + return self._invalid_model_sources + + @invalid_model_sources.setter + def invalid_model_sources(self, invalid_model_sources: Optional[List[str]]): + if invalid_model_sources is None: + del self.invalid_model_sources + return + if not isinstance(invalid_model_sources, list): + raise TypeError('invalid_model_sources must be of type list') + if not all([isinstance(t, str) for t in invalid_model_sources]): + raise TypeError('invalid_model_sources must contain only items of type str') + self._invalid_model_sources = invalid_model_sources + + +class ApiKernelSessionOutputFile(KaggleObject): + r""" + Attributes: + url (str) + file_name (str) + """ + + def __init__(self): + self._url = None + self._file_name = None + self._freeze() + + @property + def url(self) -> str: + return self._url or "" + + @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 file_name(self) -> str: + return self._file_name or "" + + @file_name.setter + def file_name(self, file_name: str): + if file_name is None: + del self.file_name + return + if not isinstance(file_name, str): + raise TypeError('file_name must be of type str') + self._file_name = file_name + + +class ApiListKernelFilesItem(KaggleObject): + r""" + Attributes: + name (str) + size (int) + creation_date (str) + """ + + def __init__(self): + self._name = "" + self._size = 0 + self._creation_date = "" + 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 size(self) -> int: + return self._size + + @size.setter + def size(self, size: int): + if size is None: + del self.size + return + if not isinstance(size, int): + raise TypeError('size must be of type int') + self._size = size + + @property + def creation_date(self) -> str: + return self._creation_date + + @creation_date.setter + def creation_date(self, creation_date: str): + if creation_date is None: + del self.creation_date + return + if not isinstance(creation_date, str): + raise TypeError('creation_date must be of type str') + self._creation_date = creation_date + + +ApiGetKernelRequest._fields = [ + FieldMetadata("userName", "user_name", "_user_name", str, "", PredefinedSerializer()), + FieldMetadata("kernelSlug", "kernel_slug", "_kernel_slug", str, "", PredefinedSerializer()), +] + +ApiGetKernelResponse._fields = [ + FieldMetadata("metadata", "metadata", "_metadata", ApiKernelMetadata, None, KaggleObjectSerializer()), + FieldMetadata("blob", "blob", "_blob", ApiKernelBlob, None, KaggleObjectSerializer()), +] + +ApiGetKernelSessionStatusRequest._fields = [ + FieldMetadata("userName", "user_name", "_user_name", str, "", PredefinedSerializer()), + FieldMetadata("kernelSlug", "kernel_slug", "_kernel_slug", str, "", PredefinedSerializer()), +] + +ApiGetKernelSessionStatusResponse._fields = [ + FieldMetadata("status", "status", "_status", KernelWorkerStatus, KernelWorkerStatus.QUEUED, EnumSerializer()), + FieldMetadata("failureMessage", "failure_message", "_failure_message", str, None, PredefinedSerializer(), optional=True), +] + +ApiKernelBlob._fields = [ + FieldMetadata("source", "source", "_source", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("language", "language", "_language", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("kernelType", "kernel_type", "_kernel_type", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("slug", "slug", "_slug", str, None, PredefinedSerializer(), optional=True), +] + +ApiKernelMetadata._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("title", "title", "_title", str, "", PredefinedSerializer()), + FieldMetadata("author", "author", "_author", str, "", PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("lastRunTime", "last_run_time", "_last_run_time", datetime, None, DateTimeSerializer()), + FieldMetadata("language", "language", "_language", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("kernelType", "kernel_type", "_kernel_type", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("isPrivate", "is_private", "_is_private", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("enableGpu", "enable_gpu", "_enable_gpu", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("enableTpu", "enable_tpu", "_enable_tpu", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("enableInternet", "enable_internet", "_enable_internet", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("categoryIds", "category_ids", "_category_ids", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("datasetDataSources", "dataset_data_sources", "_dataset_data_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("kernelDataSources", "kernel_data_sources", "_kernel_data_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("competitionDataSources", "competition_data_sources", "_competition_data_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("modelDataSources", "model_data_sources", "_model_data_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("totalVotes", "total_votes", "_total_votes", int, 0, PredefinedSerializer()), +] + +ApiListKernelFilesRequest._fields = [ + FieldMetadata("userName", "user_name", "_user_name", str, "", PredefinedSerializer()), + FieldMetadata("kernelSlug", "kernel_slug", "_kernel_slug", str, "", PredefinedSerializer()), + FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True), +] + +ApiListKernelFilesResponse._fields = [ + FieldMetadata("files", "files", "_files", ApiListKernelFilesItem, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, None, PredefinedSerializer(), optional=True), +] + +ApiListKernelSessionOutputRequest._fields = [ + FieldMetadata("userName", "user_name", "_user_name", str, "", PredefinedSerializer()), + FieldMetadata("kernelSlug", "kernel_slug", "_kernel_slug", str, "", PredefinedSerializer()), + FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True), +] + +ApiListKernelSessionOutputResponse._fields = [ + FieldMetadata("files", "files", "_files", ApiKernelSessionOutputFile, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("log", "log", "_log", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, None, PredefinedSerializer(), optional=True), +] + +ApiListKernelsRequest._fields = [ + FieldMetadata("competition", "competition", "_competition", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("dataset", "dataset", "_dataset", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("parentKernel", "parent_kernel", "_parent_kernel", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("group", "group", "_group", KernelsListViewType, KernelsListViewType.KERNELS_LIST_VIEW_TYPE_UNSPECIFIED, EnumSerializer()), + FieldMetadata("kernelType", "kernel_type", "_kernel_type", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("language", "language", "_language", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("outputType", "output_type", "_output_type", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("search", "search", "_search", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("sortBy", "sort_by", "_sort_by", KernelsListSortType, KernelsListSortType.HOTNESS, EnumSerializer()), + FieldMetadata("user", "user", "_user", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("page", "page", "_page", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True), +] + +ApiListKernelsResponse._fields = [ + FieldMetadata("kernels", "kernels", "_kernels", ApiKernelMetadata, [], ListSerializer(KaggleObjectSerializer())), +] + +ApiSaveKernelRequest._fields = [ + FieldMetadata("id", "id", "_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("slug", "slug", "_slug", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("newTitle", "new_title", "_new_title", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("text", "text", "_text", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("language", "language", "_language", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("kernelType", "kernel_type", "_kernel_type", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("datasetDataSources", "dataset_data_sources", "_dataset_data_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("kernelDataSources", "kernel_data_sources", "_kernel_data_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("competitionDataSources", "competition_data_sources", "_competition_data_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("categoryIds", "category_ids", "_category_ids", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("isPrivate", "is_private", "_is_private", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("enableGpu", "enable_gpu", "_enable_gpu", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("enableTpu", "enable_tpu", "_enable_tpu", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("enableInternet", "enable_internet", "_enable_internet", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("dockerImagePinningType", "docker_image_pinning_type", "_docker_image_pinning_type", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("modelDataSources", "model_data_sources", "_model_data_sources", str, [], ListSerializer(PredefinedSerializer())), +] + +ApiSaveKernelResponse._fields = [ + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("url", "url", "_url", str, "", PredefinedSerializer()), + FieldMetadata("versionNumber", "version_number", "_version_number", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("error", "error", "_error", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("invalidTags", "invalid_tags", "_invalid_tags", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("invalidDatasetSources", "invalid_dataset_sources", "_invalid_dataset_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("invalidCompetitionSources", "invalid_competition_sources", "_invalid_competition_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("invalidKernelSources", "invalid_kernel_sources", "_invalid_kernel_sources", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("invalidModelSources", "invalid_model_sources", "_invalid_model_sources", str, [], ListSerializer(PredefinedSerializer())), +] + +ApiKernelSessionOutputFile._fields = [ + FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("fileName", "file_name", "_file_name", str, None, PredefinedSerializer(), optional=True), +] + +ApiListKernelFilesItem._fields = [ + FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()), + FieldMetadata("size", "size", "_size", int, 0, PredefinedSerializer()), + FieldMetadata("creationDate", "creation_date", "_creation_date", str, "", PredefinedSerializer()), +] + diff --git a/kagglesdk/kernels/types/kernels_enums.py b/kagglesdk/kernels/types/kernels_enums.py new file mode 100644 index 0000000..6b36aba --- /dev/null +++ b/kagglesdk/kernels/types/kernels_enums.py @@ -0,0 +1,33 @@ +import enum + +class KernelsListSortType(enum.Enum): + HOTNESS = 0 + COMMENT_COUNT = 1 + DATE_CREATED = 2 + DATE_RUN = 3 + RELEVANCE = 4 + SCORE_ASCENDING = 5 + SCORE_DESCENDING = 6 + VIEW_COUNT = 7 + VOTE_COUNT = 8 + +class KernelsListViewType(enum.Enum): + KERNELS_LIST_VIEW_TYPE_UNSPECIFIED = 0 + PROFILE = 1 + UPVOTED = 2 + EVERYONE = 3 + COLLABORATION = 4 + FORK = 5 + BOOKMARKED = 6 + RECENTLY_VIEWED = 7 + PUBLIC_AND_USERS_PRIVATE = 8 + +class KernelWorkerStatus(enum.Enum): + QUEUED = 0 + RUNNING = 1 + COMPLETE = 2 + ERROR = 3 + CANCEL_REQUESTED = 4 + CANCEL_ACKNOWLEDGED = 5 + NEW_SCRIPT = 6 + diff --git a/kagglesdk/models/__init__.py b/kagglesdk/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/models/services/__init__.py b/kagglesdk/models/services/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/models/services/model_api_service.py b/kagglesdk/models/services/model_api_service.py new file mode 100644 index 0000000..7e46c6b --- /dev/null +++ b/kagglesdk/models/services/model_api_service.py @@ -0,0 +1,178 @@ +from kagglesdk.common.types.http_redirect import HttpRedirect +from kagglesdk.kaggle_http_client import KaggleHttpClient +from kagglesdk.models.types.model_api_service import ApiCreateModelInstanceRequest, ApiCreateModelInstanceVersionRequest, ApiCreateModelRequest, ApiCreateModelResponse, ApiDeleteModelInstanceRequest, ApiDeleteModelInstanceVersionRequest, ApiDeleteModelRequest, ApiDeleteModelResponse, ApiDownloadModelInstanceVersionRequest, ApiGetModelInstanceRequest, ApiGetModelRequest, ApiListModelInstanceVersionFilesRequest, ApiListModelInstanceVersionFilesResponse, ApiListModelsRequest, ApiListModelsResponse, ApiModel, ApiModelInstance, ApiUpdateModelInstanceRequest, ApiUpdateModelRequest, ApiUpdateModelResponse, ApiUploadModelFileRequest, ApiUploadModelFileResponse + +class ModelApiClient(object): + + def __init__(self, client: KaggleHttpClient): + self._client = client + + def create_model(self, request: ApiCreateModelRequest = None) -> ApiCreateModelResponse: + r""" + Args: + request (ApiCreateModelRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateModelRequest() + + return self._client.call("models.ModelApiService", "ApiCreateModel", request, ApiCreateModelResponse) + + def create_model_instance(self, request: ApiCreateModelInstanceRequest = None) -> ApiCreateModelResponse: + r""" + Args: + request (ApiCreateModelInstanceRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateModelInstanceRequest() + + return self._client.call("models.ModelApiService", "ApiCreateModelInstance", request, ApiCreateModelResponse) + + def create_model_instance_version(self, request: ApiCreateModelInstanceVersionRequest = None) -> ApiCreateModelResponse: + r""" + Args: + request (ApiCreateModelInstanceVersionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateModelInstanceVersionRequest() + + return self._client.call("models.ModelApiService", "ApiCreateModelInstanceVersion", request, ApiCreateModelResponse) + + def delete_model(self, request: ApiDeleteModelRequest = None) -> ApiDeleteModelResponse: + r""" + Args: + request (ApiDeleteModelRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDeleteModelRequest() + + return self._client.call("models.ModelApiService", "ApiDeleteModel", request, ApiDeleteModelResponse) + + def delete_model_instance(self, request: ApiDeleteModelInstanceRequest = None) -> ApiDeleteModelResponse: + r""" + Args: + request (ApiDeleteModelInstanceRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDeleteModelInstanceRequest() + + return self._client.call("models.ModelApiService", "ApiDeleteModelInstance", request, ApiDeleteModelResponse) + + def delete_model_instance_version(self, request: ApiDeleteModelInstanceVersionRequest = None) -> ApiDeleteModelResponse: + r""" + Args: + request (ApiDeleteModelInstanceVersionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDeleteModelInstanceVersionRequest() + + return self._client.call("models.ModelApiService", "ApiDeleteModelInstanceVersion", request, ApiDeleteModelResponse) + + def get_model(self, request: ApiGetModelRequest = None) -> ApiModel: + r""" + Args: + request (ApiGetModelRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetModelRequest() + + return self._client.call("models.ModelApiService", "ApiGetModel", request, ApiModel) + + def get_model_instance(self, request: ApiGetModelInstanceRequest = None) -> ApiModelInstance: + r""" + Args: + request (ApiGetModelInstanceRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetModelInstanceRequest() + + return self._client.call("models.ModelApiService", "ApiGetModelInstance", request, ApiModelInstance) + + def download_model_instance_version(self, request: ApiDownloadModelInstanceVersionRequest = None) -> HttpRedirect: + r""" + Args: + request (ApiDownloadModelInstanceVersionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDownloadModelInstanceVersionRequest() + + return self._client.call("models.ModelApiService", "ApiDownloadModelInstanceVersion", request, HttpRedirect) + + def list_models(self, request: ApiListModelsRequest = None) -> ApiListModelsResponse: + r""" + Args: + request (ApiListModelsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListModelsRequest() + + return self._client.call("models.ModelApiService", "ApiListModels", request, ApiListModelsResponse) + + def list_model_instance_version_files(self, request: ApiListModelInstanceVersionFilesRequest = None) -> ApiListModelInstanceVersionFilesResponse: + r""" + Args: + request (ApiListModelInstanceVersionFilesRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListModelInstanceVersionFilesRequest() + + return self._client.call("models.ModelApiService", "ApiListModelInstanceVersionFiles", request, ApiListModelInstanceVersionFilesResponse) + + def update_model(self, request: ApiUpdateModelRequest = None) -> ApiUpdateModelResponse: + r""" + Args: + request (ApiUpdateModelRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiUpdateModelRequest() + + return self._client.call("models.ModelApiService", "ApiUpdateModel", request, ApiUpdateModelResponse) + + def update_model_instance(self, request: ApiUpdateModelInstanceRequest = None) -> ApiUpdateModelResponse: + r""" + Args: + request (ApiUpdateModelInstanceRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiUpdateModelInstanceRequest() + + return self._client.call("models.ModelApiService", "ApiUpdateModelInstance", request, ApiUpdateModelResponse) + + def upload_model_file(self, request: ApiUploadModelFileRequest = None) -> ApiUploadModelFileResponse: + r""" + Deprecated. Use the new unified BlobApiService#StartBlobUpload rpc. + + Args: + request (ApiUploadModelFileRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiUploadModelFileRequest() + + return self._client.call("models.ModelApiService", "ApiUploadModelFile", request, ApiUploadModelFileResponse) diff --git a/kagglesdk/models/services/model_service.py b/kagglesdk/models/services/model_service.py new file mode 100644 index 0000000..1196a32 --- /dev/null +++ b/kagglesdk/models/services/model_service.py @@ -0,0 +1,19 @@ +from kagglesdk.kaggle_http_client import KaggleHttpClient +from kagglesdk.models.types.model_service import GetModelMetricsRequest, GetModelMetricsResponse + +class ModelClient(object): + + def __init__(self, client: KaggleHttpClient): + self._client = client + + def get_model_metrics(self, request: GetModelMetricsRequest = None) -> GetModelMetricsResponse: + r""" + Args: + request (GetModelMetricsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = GetModelMetricsRequest() + + return self._client.call("models.ModelService", "GetModelMetrics", request, GetModelMetricsResponse) diff --git a/kagglesdk/models/types/__init__.py b/kagglesdk/models/types/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/models/types/model_api_service.py b/kagglesdk/models/types/model_api_service.py new file mode 100644 index 0000000..ce9aa1d --- /dev/null +++ b/kagglesdk/models/types/model_api_service.py @@ -0,0 +1,2683 @@ +from datetime import datetime +from google.protobuf.field_mask_pb2 import FieldMask +from kagglesdk.datasets.types.dataset_api_service import ApiCategory, ApiDatasetNewFile, ApiUploadDirectoryInfo +from kagglesdk.kaggle_object import * +from kagglesdk.models.types.model_enums import ListModelsOrderBy, ModelFramework, ModelInstanceType +from kagglesdk.models.types.model_types import BaseModelInstanceInformation +from typing import Optional, List + +class ApiCreateModelInstanceRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + body (ApiCreateModelInstanceRequestBody) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._body = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def body(self) -> Optional['ApiCreateModelInstanceRequestBody']: + return self._body + + @body.setter + def body(self, body: Optional['ApiCreateModelInstanceRequestBody']): + if body is None: + del self.body + return + if not isinstance(body, ApiCreateModelInstanceRequestBody): + raise TypeError('body must be of type ApiCreateModelInstanceRequestBody') + self._body = body + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/create/instance' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiCreateModelInstanceRequestBody(KaggleObject): + r""" + Attributes: + instance_slug (str) + framework (ModelFramework) + overview (str) + usage (str) + fine_tunable (bool) + training_data (str) + files (ApiDatasetNewFile) + directories (ApiUploadDirectoryInfo) + license_name (str) + model_instance_type (ModelInstanceType) + base_model_instance (str) + external_base_model_url (str) + """ + + def __init__(self): + self._instance_slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._overview = "" + self._usage = "" + self._fine_tunable = None + self._training_data = [] + self._files = [] + self._directories = [] + self._license_name = None + self._model_instance_type = None + self._base_model_instance = None + self._external_base_model_url = None + self._freeze() + + @property + def instance_slug(self) -> str: + return self._instance_slug + + @instance_slug.setter + def instance_slug(self, instance_slug: str): + if instance_slug is None: + del self.instance_slug + return + if not isinstance(instance_slug, str): + raise TypeError('instance_slug must be of type str') + self._instance_slug = instance_slug + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def overview(self) -> str: + return self._overview + + @overview.setter + def overview(self, overview: str): + if overview is None: + del self.overview + return + if not isinstance(overview, str): + raise TypeError('overview must be of type str') + self._overview = overview + + @property + def usage(self) -> str: + return self._usage + + @usage.setter + def usage(self, usage: str): + if usage is None: + del self.usage + return + if not isinstance(usage, str): + raise TypeError('usage must be of type str') + self._usage = usage + + @property + def fine_tunable(self) -> bool: + return self._fine_tunable or False + + @fine_tunable.setter + def fine_tunable(self, fine_tunable: bool): + if fine_tunable is None: + del self.fine_tunable + return + if not isinstance(fine_tunable, bool): + raise TypeError('fine_tunable must be of type bool') + self._fine_tunable = fine_tunable + + @property + def training_data(self) -> Optional[List[str]]: + return self._training_data + + @training_data.setter + def training_data(self, training_data: Optional[List[str]]): + if training_data is None: + del self.training_data + return + if not isinstance(training_data, list): + raise TypeError('training_data must be of type list') + if not all([isinstance(t, str) for t in training_data]): + raise TypeError('training_data must contain only items of type str') + self._training_data = training_data + + @property + def files(self) -> Optional[List[Optional['ApiDatasetNewFile']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiDatasetNewFile']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiDatasetNewFile) for t in files]): + raise TypeError('files must contain only items of type ApiDatasetNewFile') + self._files = files + + @property + def directories(self) -> Optional[List[Optional['ApiUploadDirectoryInfo']]]: + return self._directories + + @directories.setter + def directories(self, directories: Optional[List[Optional['ApiUploadDirectoryInfo']]]): + if directories is None: + del self.directories + return + if not isinstance(directories, list): + raise TypeError('directories must be of type list') + if not all([isinstance(t, ApiUploadDirectoryInfo) for t in directories]): + raise TypeError('directories must contain only items of type ApiUploadDirectoryInfo') + self._directories = directories + + @property + def license_name(self) -> str: + return self._license_name or "" + + @license_name.setter + def license_name(self, license_name: str): + if license_name is None: + del self.license_name + return + if not isinstance(license_name, str): + raise TypeError('license_name must be of type str') + self._license_name = license_name + + @property + def model_instance_type(self) -> 'ModelInstanceType': + return self._model_instance_type or ModelInstanceType.MODEL_INSTANCE_TYPE_UNSPECIFIED + + @model_instance_type.setter + def model_instance_type(self, model_instance_type: 'ModelInstanceType'): + if model_instance_type is None: + del self.model_instance_type + return + if not isinstance(model_instance_type, ModelInstanceType): + raise TypeError('model_instance_type must be of type ModelInstanceType') + self._model_instance_type = model_instance_type + + @property + def base_model_instance(self) -> str: + return self._base_model_instance or "" + + @base_model_instance.setter + def base_model_instance(self, base_model_instance: str): + if base_model_instance is None: + del self.base_model_instance + return + if not isinstance(base_model_instance, str): + raise TypeError('base_model_instance must be of type str') + self._base_model_instance = base_model_instance + + @property + def external_base_model_url(self) -> str: + return self._external_base_model_url or "" + + @external_base_model_url.setter + def external_base_model_url(self, external_base_model_url: str): + if external_base_model_url is None: + del self.external_base_model_url + return + if not isinstance(external_base_model_url, str): + raise TypeError('external_base_model_url must be of type str') + self._external_base_model_url = external_base_model_url + + +class ApiCreateModelInstanceVersionRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + framework (ModelFramework) + instance_slug (str) + body (ApiCreateModelInstanceVersionRequestBody) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._instance_slug = "" + self._body = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def instance_slug(self) -> str: + return self._instance_slug + + @instance_slug.setter + def instance_slug(self, instance_slug: str): + if instance_slug is None: + del self.instance_slug + return + if not isinstance(instance_slug, str): + raise TypeError('instance_slug must be of type str') + self._instance_slug = instance_slug + + @property + def body(self) -> Optional['ApiCreateModelInstanceVersionRequestBody']: + return self._body + + @body.setter + def body(self, body: Optional['ApiCreateModelInstanceVersionRequestBody']): + if body is None: + del self.body + return + if not isinstance(body, ApiCreateModelInstanceVersionRequestBody): + raise TypeError('body must be of type ApiCreateModelInstanceVersionRequestBody') + self._body = body + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/{framework}/{instance_slug}/create/version' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiCreateModelInstanceVersionRequestBody(KaggleObject): + r""" + Attributes: + version_notes (str) + files (ApiDatasetNewFile) + directories (ApiUploadDirectoryInfo) + """ + + def __init__(self): + self._version_notes = None + self._files = [] + self._directories = [] + self._freeze() + + @property + def version_notes(self) -> str: + return self._version_notes or "" + + @version_notes.setter + def version_notes(self, version_notes: str): + if version_notes is None: + del self.version_notes + return + if not isinstance(version_notes, str): + raise TypeError('version_notes must be of type str') + self._version_notes = version_notes + + @property + def files(self) -> Optional[List[Optional['ApiDatasetNewFile']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiDatasetNewFile']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiDatasetNewFile) for t in files]): + raise TypeError('files must contain only items of type ApiDatasetNewFile') + self._files = files + + @property + def directories(self) -> Optional[List[Optional['ApiUploadDirectoryInfo']]]: + return self._directories + + @directories.setter + def directories(self, directories: Optional[List[Optional['ApiUploadDirectoryInfo']]]): + if directories is None: + del self.directories + return + if not isinstance(directories, list): + raise TypeError('directories must be of type list') + if not all([isinstance(t, ApiUploadDirectoryInfo) for t in directories]): + raise TypeError('directories must contain only items of type ApiUploadDirectoryInfo') + self._directories = directories + + +class ApiCreateModelRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + slug (str) + title (str) + subtitle (str) + is_private (bool) + description (str) + publish_time (datetime) + provenance_sources (str) + """ + + def __init__(self): + self._owner_slug = "" + self._slug = "" + self._title = "" + self._subtitle = None + self._is_private = None + self._description = None + self._publish_time = None + self._provenance_sources = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @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 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 subtitle(self) -> str: + return self._subtitle or "" + + @subtitle.setter + def subtitle(self, subtitle: str): + if subtitle is None: + del self.subtitle + return + if not isinstance(subtitle, str): + raise TypeError('subtitle must be of type str') + self._subtitle = subtitle + + @property + def is_private(self) -> bool: + return self._is_private or False + + @is_private.setter + def is_private(self, is_private: bool): + if is_private is None: + del self.is_private + return + if not isinstance(is_private, bool): + raise TypeError('is_private must be of type bool') + self._is_private = is_private + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def publish_time(self) -> datetime: + return self._publish_time + + @publish_time.setter + def publish_time(self, publish_time: datetime): + if publish_time is None: + del self.publish_time + return + if not isinstance(publish_time, datetime): + raise TypeError('publish_time must be of type datetime') + self._publish_time = publish_time + + @property + def provenance_sources(self) -> str: + return self._provenance_sources or "" + + @provenance_sources.setter + def provenance_sources(self, provenance_sources: str): + if provenance_sources is None: + del self.provenance_sources + return + if not isinstance(provenance_sources, str): + raise TypeError('provenance_sources must be of type str') + self._provenance_sources = provenance_sources + + + def endpoint(self): + path = '/api/v1/models/create/new' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiCreateModelResponse(KaggleObject): + r""" + Attributes: + id (int) + ref (str) + error (str) + error_code (int) + url (str) + """ + + def __init__(self): + self._id = None + self._ref = None + self._error = None + self._error_code = None + self._url = None + self._freeze() + + @property + def id(self) -> int: + return self._id or 0 + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def ref(self) -> str: + return self._ref or "" + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def error(self) -> str: + return self._error or "" + + @error.setter + def error(self, error: str): + if error is None: + del self.error + return + if not isinstance(error, str): + raise TypeError('error must be of type str') + self._error = error + + @property + def error_code(self) -> int: + return self._error_code or 0 + + @error_code.setter + def error_code(self, error_code: int): + if error_code is None: + del self.error_code + return + if not isinstance(error_code, int): + raise TypeError('error_code must be of type int') + self._error_code = error_code + + @property + def url(self) -> str: + return self._url or "" + + @url.setter + def url(self, url: str): + if url is None: + del self.url + return + if not isinstance(url, str): + raise TypeError('url must be of type str') + self._url = url + + +class ApiDeleteModelInstanceRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + framework (ModelFramework) + instance_slug (str) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._instance_slug = "" + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def instance_slug(self) -> str: + return self._instance_slug + + @instance_slug.setter + def instance_slug(self, instance_slug: str): + if instance_slug is None: + del self.instance_slug + return + if not isinstance(instance_slug, str): + raise TypeError('instance_slug must be of type str') + self._instance_slug = instance_slug + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/{framework}/{instance_slug}/delete' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiDeleteModelInstanceVersionRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + framework (ModelFramework) + instance_slug (str) + version_number (int) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._instance_slug = "" + self._version_number = 0 + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def instance_slug(self) -> str: + return self._instance_slug + + @instance_slug.setter + def instance_slug(self, instance_slug: str): + if instance_slug is None: + del self.instance_slug + return + if not isinstance(instance_slug, str): + raise TypeError('instance_slug must be of type str') + self._instance_slug = instance_slug + + @property + def version_number(self) -> int: + return self._version_number + + @version_number.setter + def version_number(self, version_number: int): + if version_number is None: + del self.version_number + return + if not isinstance(version_number, int): + raise TypeError('version_number must be of type int') + self._version_number = version_number + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/{framework}/{instance_slug}/{version_number}/delete' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiDeleteModelRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/delete' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiDeleteModelResponse(KaggleObject): + r""" + Attributes: + error (str) + """ + + def __init__(self): + self._error = None + self._freeze() + + @property + def error(self) -> str: + return self._error or "" + + @error.setter + def error(self, error: str): + if error is None: + del self.error + return + if not isinstance(error, str): + raise TypeError('error must be of type str') + self._error = error + + +class ApiDownloadModelInstanceVersionRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + framework (ModelFramework) + instance_slug (str) + version_number (int) + path (str) + Relative path to a specific file inside the databundle. + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._instance_slug = "" + self._version_number = 0 + self._path = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def instance_slug(self) -> str: + return self._instance_slug + + @instance_slug.setter + def instance_slug(self, instance_slug: str): + if instance_slug is None: + del self.instance_slug + return + if not isinstance(instance_slug, str): + raise TypeError('instance_slug must be of type str') + self._instance_slug = instance_slug + + @property + def version_number(self) -> int: + return self._version_number + + @version_number.setter + def version_number(self, version_number: int): + if version_number is None: + del self.version_number + return + if not isinstance(version_number, int): + raise TypeError('version_number must be of type int') + self._version_number = version_number + + @property + def path(self) -> str: + """Relative path to a specific file inside the databundle.""" + return self._path or "" + + @path.setter + def path(self, path: str): + if path is None: + del self.path + return + if not isinstance(path, str): + raise TypeError('path must be of type str') + self._path = path + + + def endpoint(self): + if self.path: + path = '/api/v1/models/{owner_slug}/{model_slug}/{framework}/{instance_slug}/{version_number}/download/{path}' + else: + path = '/api/v1/models/{owner_slug}/{model_slug}/{framework}/{instance_slug}/{version_number}/download' + return path.format_map(self.to_field_map(self)) + +class ApiGetModelInstanceRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + framework (ModelFramework) + instance_slug (str) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._instance_slug = "" + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def instance_slug(self) -> str: + return self._instance_slug + + @instance_slug.setter + def instance_slug(self, instance_slug: str): + if instance_slug is None: + del self.instance_slug + return + if not isinstance(instance_slug, str): + raise TypeError('instance_slug must be of type str') + self._instance_slug = instance_slug + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/{framework}/{instance_slug}/get' + return path.format_map(self.to_field_map(self)) + +class ApiGetModelRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/get' + return path.format_map(self.to_field_map(self)) + +class ApiListModelInstanceVersionFilesRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + instance_slug (str) + framework (ModelFramework) + version_number (int) + page_size (int) + page_token (str) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._instance_slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._version_number = None + self._page_size = None + self._page_token = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def instance_slug(self) -> str: + return self._instance_slug + + @instance_slug.setter + def instance_slug(self, instance_slug: str): + if instance_slug is None: + del self.instance_slug + return + if not isinstance(instance_slug, str): + raise TypeError('instance_slug must be of type str') + self._instance_slug = instance_slug + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def version_number(self) -> int: + return self._version_number or 0 + + @version_number.setter + def version_number(self, version_number: int): + if version_number is None: + del self.version_number + return + if not isinstance(version_number, int): + raise TypeError('version_number must be of type int') + self._version_number = version_number + + @property + def page_size(self) -> int: + return self._page_size or 0 + + @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 or "" + + @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 + + + def endpoint(self): + if self.version_number: + path = '/api/v1/models/{owner_slug}/{model_slug}/{framework}/{instance_slug}/{version_number}/files' + else: + path = '/api/v1/models/{owner_slug}/{model_slug}/{framework}/{instance_slug}/files' + return path.format_map(self.to_field_map(self)) + +class ApiListModelInstanceVersionFilesResponse(KaggleObject): + r""" + Attributes: + files (ApiModelFile) + next_page_token (str) + """ + + def __init__(self): + self._files = [] + self._next_page_token = "" + self._freeze() + + @property + def files(self) -> Optional[List[Optional['ApiModelFile']]]: + return self._files + + @files.setter + def files(self, files: Optional[List[Optional['ApiModelFile']]]): + if files is None: + del self.files + return + if not isinstance(files, list): + raise TypeError('files must be of type list') + if not all([isinstance(t, ApiModelFile) for t in files]): + raise TypeError('files must contain only items of type ApiModelFile') + self._files = files + + @property + def next_page_token(self) -> str: + return self._next_page_token + + @next_page_token.setter + def next_page_token(self, next_page_token: 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 + + +class ApiListModelsRequest(KaggleObject): + r""" + Attributes: + search (str) + Display models matching the specified search terms. + sort_by (ListModelsOrderBy) + Sort the results (default is 'hotness'). 'relevance' only works if there is + a search query. + owner (str) + Display models by a particular user or organization. + page_size (int) + Page size. + page_token (str) + Page token used for pagination. + """ + + def __init__(self): + self._search = None + self._sort_by = None + self._owner = None + self._page_size = None + self._page_token = None + self._freeze() + + @property + def search(self) -> str: + """Display models matching the specified search terms.""" + return self._search or "" + + @search.setter + def search(self, search: str): + if search is None: + del self.search + return + if not isinstance(search, str): + raise TypeError('search must be of type str') + self._search = search + + @property + def sort_by(self) -> 'ListModelsOrderBy': + r""" + Sort the results (default is 'hotness'). 'relevance' only works if there is + a search query. + """ + return self._sort_by or ListModelsOrderBy.LIST_MODELS_ORDER_BY_UNSPECIFIED + + @sort_by.setter + def sort_by(self, sort_by: 'ListModelsOrderBy'): + if sort_by is None: + del self.sort_by + return + if not isinstance(sort_by, ListModelsOrderBy): + raise TypeError('sort_by must be of type ListModelsOrderBy') + self._sort_by = sort_by + + @property + def owner(self) -> str: + """Display models by a particular user or organization.""" + return self._owner or "" + + @owner.setter + def owner(self, owner: str): + if owner is None: + del self.owner + return + if not isinstance(owner, str): + raise TypeError('owner must be of type str') + self._owner = owner + + @property + def page_size(self) -> int: + """Page size.""" + return self._page_size or 0 + + @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: + """Page token used for pagination.""" + return self._page_token or "" + + @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 + + + def endpoint(self): + path = '/api/v1/models/list' + return path.format_map(self.to_field_map(self)) + +class ApiListModelsResponse(KaggleObject): + r""" + Attributes: + models (ApiModel) + next_page_token (str) + total_results (int) + """ + + def __init__(self): + self._models = [] + self._next_page_token = "" + self._total_results = 0 + self._freeze() + + @property + def models(self) -> Optional[List[Optional['ApiModel']]]: + return self._models + + @models.setter + def models(self, models: Optional[List[Optional['ApiModel']]]): + if models is None: + del self.models + return + if not isinstance(models, list): + raise TypeError('models must be of type list') + if not all([isinstance(t, ApiModel) for t in models]): + raise TypeError('models must contain only items of type ApiModel') + self._models = models + + @property + def next_page_token(self) -> str: + return self._next_page_token + + @next_page_token.setter + def next_page_token(self, next_page_token: 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 total_results(self) -> int: + return self._total_results + + @total_results.setter + def total_results(self, total_results: int): + if total_results is None: + del self.total_results + return + if not isinstance(total_results, int): + raise TypeError('total_results must be of type int') + self._total_results = total_results + + +class ApiModel(KaggleObject): + r""" + Attributes: + id (int) + ref (str) + ref is `owner_slug/model_slug` + title (str) + subtitle (str) + author (str) + slug (str) + is_private (bool) + description (str) + instances (ApiModelInstance) + tags (ApiCategory) + publish_time (datetime) + provenance_sources (str) + url (str) + """ + + def __init__(self): + self._id = 0 + self._ref = "" + self._title = "" + self._subtitle = "" + self._author = "" + self._slug = "" + self._is_private = False + self._description = "" + self._instances = [] + self._tags = [] + self._publish_time = None + self._provenance_sources = "" + self._url = "" + self._freeze() + + @property + def id(self) -> int: + return self._id + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def ref(self) -> str: + """ref is `owner_slug/model_slug`""" + return self._ref + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def 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 subtitle(self) -> str: + return self._subtitle + + @subtitle.setter + def subtitle(self, subtitle: str): + if subtitle is None: + del self.subtitle + return + if not isinstance(subtitle, str): + raise TypeError('subtitle must be of type str') + self._subtitle = subtitle + + @property + def author(self) -> str: + return self._author + + @author.setter + def author(self, author: str): + if author is None: + del self.author + return + if not isinstance(author, str): + raise TypeError('author must be of type str') + self._author = author + + @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 is_private(self) -> bool: + return self._is_private + + @is_private.setter + def is_private(self, is_private: bool): + if is_private is None: + del self.is_private + return + if not isinstance(is_private, bool): + raise TypeError('is_private must be of type bool') + self._is_private = is_private + + @property + def description(self) -> str: + return self._description + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def instances(self) -> Optional[List[Optional['ApiModelInstance']]]: + return self._instances + + @instances.setter + def instances(self, instances: Optional[List[Optional['ApiModelInstance']]]): + if instances is None: + del self.instances + return + if not isinstance(instances, list): + raise TypeError('instances must be of type list') + if not all([isinstance(t, ApiModelInstance) for t in instances]): + raise TypeError('instances must contain only items of type ApiModelInstance') + self._instances = instances + + @property + def tags(self) -> Optional[List[Optional['ApiCategory']]]: + return self._tags + + @tags.setter + def tags(self, tags: Optional[List[Optional['ApiCategory']]]): + if tags is None: + del self.tags + return + if not isinstance(tags, list): + raise TypeError('tags must be of type list') + if not all([isinstance(t, ApiCategory) for t in tags]): + raise TypeError('tags must contain only items of type ApiCategory') + self._tags = tags + + @property + def publish_time(self) -> datetime: + return self._publish_time + + @publish_time.setter + def publish_time(self, publish_time: datetime): + if publish_time is None: + del self.publish_time + return + if not isinstance(publish_time, datetime): + raise TypeError('publish_time must be of type datetime') + self._publish_time = publish_time + + @property + def provenance_sources(self) -> str: + return self._provenance_sources + + @provenance_sources.setter + def provenance_sources(self, provenance_sources: str): + if provenance_sources is None: + del self.provenance_sources + return + if not isinstance(provenance_sources, str): + raise TypeError('provenance_sources must be of type str') + self._provenance_sources = provenance_sources + + @property + def url(self) -> str: + return self._url + + @url.setter + def url(self, url: str): + if url is None: + del self.url + return + if not isinstance(url, str): + raise TypeError('url must be of type str') + self._url = url + + +class ApiModelFile(KaggleObject): + r""" + Attributes: + name (str) + size (int) + creation_date (datetime) + """ + + def __init__(self): + self._name = "" + self._size = 0 + self._creation_date = None + 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 size(self) -> int: + return self._size + + @size.setter + def size(self, size: int): + if size is None: + del self.size + return + if not isinstance(size, int): + raise TypeError('size must be of type int') + self._size = size + + @property + def creation_date(self) -> datetime: + return self._creation_date or None + + @creation_date.setter + def creation_date(self, creation_date: datetime): + if creation_date is None: + del self.creation_date + return + if not isinstance(creation_date, datetime): + raise TypeError('creation_date must be of type datetime') + self._creation_date = creation_date + + +class ApiModelInstance(KaggleObject): + r""" + Attributes: + id (int) + slug (str) + framework (ModelFramework) + fine_tunable (bool) + overview (str) + usage (str) + download_url (str) + version_id (int) + version_number (int) + training_data (str) + url (str) + license_name (str) + model_instance_type (ModelInstanceType) + base_model_instance_information (BaseModelInstanceInformation) + external_base_model_url (str) + """ + + def __init__(self): + self._id = 0 + self._slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._fine_tunable = False + self._overview = "" + self._usage = "" + self._download_url = "" + self._version_id = 0 + self._version_number = 0 + self._training_data = [] + self._url = "" + self._license_name = "" + self._model_instance_type = ModelInstanceType.MODEL_INSTANCE_TYPE_UNSPECIFIED + self._base_model_instance_information = None + self._external_base_model_url = "" + self._freeze() + + @property + def id(self) -> int: + return self._id + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def 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 framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def fine_tunable(self) -> bool: + return self._fine_tunable + + @fine_tunable.setter + def fine_tunable(self, fine_tunable: bool): + if fine_tunable is None: + del self.fine_tunable + return + if not isinstance(fine_tunable, bool): + raise TypeError('fine_tunable must be of type bool') + self._fine_tunable = fine_tunable + + @property + def overview(self) -> str: + return self._overview + + @overview.setter + def overview(self, overview: str): + if overview is None: + del self.overview + return + if not isinstance(overview, str): + raise TypeError('overview must be of type str') + self._overview = overview + + @property + def usage(self) -> str: + return self._usage + + @usage.setter + def usage(self, usage: str): + if usage is None: + del self.usage + return + if not isinstance(usage, str): + raise TypeError('usage must be of type str') + self._usage = usage + + @property + def download_url(self) -> str: + return self._download_url + + @download_url.setter + def download_url(self, download_url: str): + if download_url is None: + del self.download_url + return + if not isinstance(download_url, str): + raise TypeError('download_url must be of type str') + self._download_url = download_url + + @property + def version_id(self) -> int: + return self._version_id + + @version_id.setter + def version_id(self, version_id: int): + if version_id is None: + del self.version_id + return + if not isinstance(version_id, int): + raise TypeError('version_id must be of type int') + self._version_id = version_id + + @property + def version_number(self) -> int: + return self._version_number + + @version_number.setter + def version_number(self, version_number: int): + if version_number is None: + del self.version_number + return + if not isinstance(version_number, int): + raise TypeError('version_number must be of type int') + self._version_number = version_number + + @property + def training_data(self) -> Optional[List[str]]: + return self._training_data + + @training_data.setter + def training_data(self, training_data: Optional[List[str]]): + if training_data is None: + del self.training_data + return + if not isinstance(training_data, list): + raise TypeError('training_data must be of type list') + if not all([isinstance(t, str) for t in training_data]): + raise TypeError('training_data must contain only items of type str') + self._training_data = training_data + + @property + def url(self) -> str: + 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 license_name(self) -> str: + return self._license_name + + @license_name.setter + def license_name(self, license_name: str): + if license_name is None: + del self.license_name + return + if not isinstance(license_name, str): + raise TypeError('license_name must be of type str') + self._license_name = license_name + + @property + def model_instance_type(self) -> 'ModelInstanceType': + return self._model_instance_type + + @model_instance_type.setter + def model_instance_type(self, model_instance_type: 'ModelInstanceType'): + if model_instance_type is None: + del self.model_instance_type + return + if not isinstance(model_instance_type, ModelInstanceType): + raise TypeError('model_instance_type must be of type ModelInstanceType') + self._model_instance_type = model_instance_type + + @property + def base_model_instance_information(self) -> Optional['BaseModelInstanceInformation']: + return self._base_model_instance_information or None + + @base_model_instance_information.setter + def base_model_instance_information(self, base_model_instance_information: Optional['BaseModelInstanceInformation']): + if base_model_instance_information is None: + del self.base_model_instance_information + return + if not isinstance(base_model_instance_information, BaseModelInstanceInformation): + raise TypeError('base_model_instance_information must be of type BaseModelInstanceInformation') + self._base_model_instance_information = base_model_instance_information + + @property + def external_base_model_url(self) -> str: + return self._external_base_model_url + + @external_base_model_url.setter + def external_base_model_url(self, external_base_model_url: str): + if external_base_model_url is None: + del self.external_base_model_url + return + if not isinstance(external_base_model_url, str): + raise TypeError('external_base_model_url must be of type str') + self._external_base_model_url = external_base_model_url + + +class ApiUpdateModelInstanceRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + framework (ModelFramework) + instance_slug (str) + overview (str) + usage (str) + fine_tunable (bool) + training_data (str) + update_mask (FieldMask) + license_name (str) + model_instance_type (ModelInstanceType) + base_model_instance (str) + external_base_model_url (str) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._instance_slug = "" + self._overview = "" + self._usage = "" + self._fine_tunable = None + self._training_data = [] + self._update_mask = None + self._license_name = None + self._model_instance_type = None + self._base_model_instance = None + self._external_base_model_url = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def instance_slug(self) -> str: + return self._instance_slug + + @instance_slug.setter + def instance_slug(self, instance_slug: str): + if instance_slug is None: + del self.instance_slug + return + if not isinstance(instance_slug, str): + raise TypeError('instance_slug must be of type str') + self._instance_slug = instance_slug + + @property + def overview(self) -> str: + return self._overview + + @overview.setter + def overview(self, overview: str): + if overview is None: + del self.overview + return + if not isinstance(overview, str): + raise TypeError('overview must be of type str') + self._overview = overview + + @property + def usage(self) -> str: + return self._usage + + @usage.setter + def usage(self, usage: str): + if usage is None: + del self.usage + return + if not isinstance(usage, str): + raise TypeError('usage must be of type str') + self._usage = usage + + @property + def fine_tunable(self) -> bool: + return self._fine_tunable or False + + @fine_tunable.setter + def fine_tunable(self, fine_tunable: bool): + if fine_tunable is None: + del self.fine_tunable + return + if not isinstance(fine_tunable, bool): + raise TypeError('fine_tunable must be of type bool') + self._fine_tunable = fine_tunable + + @property + def training_data(self) -> Optional[List[str]]: + return self._training_data + + @training_data.setter + def training_data(self, training_data: Optional[List[str]]): + if training_data is None: + del self.training_data + return + if not isinstance(training_data, list): + raise TypeError('training_data must be of type list') + if not all([isinstance(t, str) for t in training_data]): + raise TypeError('training_data must contain only items of type str') + self._training_data = training_data + + @property + def update_mask(self) -> FieldMask: + 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 + + @property + def license_name(self) -> str: + return self._license_name or "" + + @license_name.setter + def license_name(self, license_name: str): + if license_name is None: + del self.license_name + return + if not isinstance(license_name, str): + raise TypeError('license_name must be of type str') + self._license_name = license_name + + @property + def model_instance_type(self) -> 'ModelInstanceType': + return self._model_instance_type or ModelInstanceType.MODEL_INSTANCE_TYPE_UNSPECIFIED + + @model_instance_type.setter + def model_instance_type(self, model_instance_type: 'ModelInstanceType'): + if model_instance_type is None: + del self.model_instance_type + return + if not isinstance(model_instance_type, ModelInstanceType): + raise TypeError('model_instance_type must be of type ModelInstanceType') + self._model_instance_type = model_instance_type + + @property + def base_model_instance(self) -> str: + return self._base_model_instance or "" + + @base_model_instance.setter + def base_model_instance(self, base_model_instance: str): + if base_model_instance is None: + del self.base_model_instance + return + if not isinstance(base_model_instance, str): + raise TypeError('base_model_instance must be of type str') + self._base_model_instance = base_model_instance + + @property + def external_base_model_url(self) -> str: + return self._external_base_model_url or "" + + @external_base_model_url.setter + def external_base_model_url(self, external_base_model_url: str): + if external_base_model_url is None: + del self.external_base_model_url + return + if not isinstance(external_base_model_url, str): + raise TypeError('external_base_model_url must be of type str') + self._external_base_model_url = external_base_model_url + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/{framework}/{instance_slug}/update' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiUpdateModelRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + title (str) + subtitle (str) + is_private (bool) + description (str) + publish_time (datetime) + provenance_sources (str) + update_mask (FieldMask) + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._title = "" + self._subtitle = None + self._is_private = False + self._description = None + self._publish_time = None + self._provenance_sources = None + self._update_mask = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @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 subtitle(self) -> str: + return self._subtitle or "" + + @subtitle.setter + def subtitle(self, subtitle: str): + if subtitle is None: + del self.subtitle + return + if not isinstance(subtitle, str): + raise TypeError('subtitle must be of type str') + self._subtitle = subtitle + + @property + def is_private(self) -> bool: + return self._is_private + + @is_private.setter + def is_private(self, is_private: bool): + if is_private is None: + del self.is_private + return + if not isinstance(is_private, bool): + raise TypeError('is_private must be of type bool') + self._is_private = is_private + + @property + def description(self) -> str: + return self._description or "" + + @description.setter + def description(self, description: str): + if description is None: + del self.description + return + if not isinstance(description, str): + raise TypeError('description must be of type str') + self._description = description + + @property + def publish_time(self) -> datetime: + return self._publish_time + + @publish_time.setter + def publish_time(self, publish_time: datetime): + if publish_time is None: + del self.publish_time + return + if not isinstance(publish_time, datetime): + raise TypeError('publish_time must be of type datetime') + self._publish_time = publish_time + + @property + def provenance_sources(self) -> str: + return self._provenance_sources or "" + + @provenance_sources.setter + def provenance_sources(self, provenance_sources: str): + if provenance_sources is None: + del self.provenance_sources + return + if not isinstance(provenance_sources, str): + raise TypeError('provenance_sources must be of type str') + self._provenance_sources = provenance_sources + + @property + def update_mask(self) -> FieldMask: + 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 + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/update' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiUpdateModelResponse(KaggleObject): + r""" + Attributes: + id (int) + ref (str) + error (str) + url (str) + """ + + def __init__(self): + self._id = None + self._ref = None + self._error = None + self._url = None + self._freeze() + + @property + def id(self) -> int: + return self._id or 0 + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def ref(self) -> str: + return self._ref or "" + + @ref.setter + def ref(self, ref: str): + if ref is None: + del self.ref + return + if not isinstance(ref, str): + raise TypeError('ref must be of type str') + self._ref = ref + + @property + def error(self) -> str: + return self._error or "" + + @error.setter + def error(self, error: str): + if error is None: + del self.error + return + if not isinstance(error, str): + raise TypeError('error must be of type str') + self._error = error + + @property + def url(self) -> str: + return self._url or "" + + @url.setter + def url(self, url: str): + if url is None: + del self.url + return + if not isinstance(url, str): + raise TypeError('url must be of type str') + self._url = url + + +class ApiUploadModelFileRequest(KaggleObject): + r""" + Attributes: + file_name (str) + content_length (int) + last_modified_epoch_seconds (int) + """ + + def __init__(self): + self._file_name = "" + self._content_length = 0 + self._last_modified_epoch_seconds = 0 + self._freeze() + + @property + def file_name(self) -> str: + return self._file_name + + @file_name.setter + def file_name(self, file_name: str): + if file_name is None: + del self.file_name + return + if not isinstance(file_name, str): + raise TypeError('file_name must be of type str') + self._file_name = file_name + + @property + def content_length(self) -> int: + return self._content_length + + @content_length.setter + def content_length(self, content_length: int): + if content_length is None: + del self.content_length + return + if not isinstance(content_length, int): + raise TypeError('content_length must be of type int') + self._content_length = content_length + + @property + def last_modified_epoch_seconds(self) -> int: + return self._last_modified_epoch_seconds + + @last_modified_epoch_seconds.setter + def last_modified_epoch_seconds(self, last_modified_epoch_seconds: int): + if last_modified_epoch_seconds is None: + del self.last_modified_epoch_seconds + return + if not isinstance(last_modified_epoch_seconds, int): + raise TypeError('last_modified_epoch_seconds must be of type int') + self._last_modified_epoch_seconds = last_modified_epoch_seconds + + + def endpoint(self): + path = '/api/v1/models/upload/file/{content_length}/{last_modified_epoch_seconds}' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + +class ApiUploadModelFileResponse(KaggleObject): + r""" + Attributes: + token (str) + Opaque string token used to reference the new BlobFile. + create_url (str) + URL to use to start the upload + """ + + def __init__(self): + self._token = "" + self._create_url = "" + self._freeze() + + @property + def token(self) -> str: + """Opaque string token used to reference the new BlobFile.""" + return self._token + + @token.setter + def token(self, token: str): + if token is None: + del self.token + return + if not isinstance(token, str): + raise TypeError('token must be of type str') + self._token = token + + @property + def create_url(self) -> str: + """URL to use to start the upload""" + return self._create_url + + @create_url.setter + def create_url(self, create_url: str): + if create_url is None: + del self.create_url + return + if not isinstance(create_url, str): + raise TypeError('create_url must be of type str') + self._create_url = create_url + + +ApiCreateModelInstanceRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("body", "body", "_body", ApiCreateModelInstanceRequestBody, None, KaggleObjectSerializer()), +] + +ApiCreateModelInstanceRequestBody._fields = [ + FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("overview", "overview", "_overview", str, "", PredefinedSerializer()), + FieldMetadata("usage", "usage", "_usage", str, "", PredefinedSerializer()), + FieldMetadata("fineTunable", "fine_tunable", "_fine_tunable", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("trainingData", "training_data", "_training_data", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("files", "files", "_files", ApiDatasetNewFile, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("directories", "directories", "_directories", ApiUploadDirectoryInfo, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("licenseName", "license_name", "_license_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("modelInstanceType", "model_instance_type", "_model_instance_type", ModelInstanceType, None, EnumSerializer(), optional=True), + FieldMetadata("baseModelInstance", "base_model_instance", "_base_model_instance", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("externalBaseModelUrl", "external_base_model_url", "_external_base_model_url", str, None, PredefinedSerializer(), optional=True), +] + +ApiCreateModelInstanceVersionRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()), + FieldMetadata("body", "body", "_body", ApiCreateModelInstanceVersionRequestBody, None, KaggleObjectSerializer()), +] + +ApiCreateModelInstanceVersionRequestBody._fields = [ + FieldMetadata("versionNotes", "version_notes", "_version_notes", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("files", "files", "_files", ApiDatasetNewFile, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("directories", "directories", "_directories", ApiUploadDirectoryInfo, [], ListSerializer(KaggleObjectSerializer())), +] + +ApiCreateModelRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("title", "title", "_title", str, "", PredefinedSerializer()), + FieldMetadata("subtitle", "subtitle", "_subtitle", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("isPrivate", "is_private", "_is_private", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("publishTime", "publish_time", "_publish_time", datetime, None, DateTimeSerializer()), + FieldMetadata("provenanceSources", "provenance_sources", "_provenance_sources", str, None, PredefinedSerializer(), optional=True), +] + +ApiCreateModelResponse._fields = [ + FieldMetadata("id", "id", "_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("ref", "ref", "_ref", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("error", "error", "_error", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("errorCode", "error_code", "_error_code", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True), +] + +ApiDeleteModelInstanceRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()), +] + +ApiDeleteModelInstanceVersionRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()), + FieldMetadata("versionNumber", "version_number", "_version_number", int, 0, PredefinedSerializer()), +] + +ApiDeleteModelRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), +] + +ApiDeleteModelResponse._fields = [ + FieldMetadata("error", "error", "_error", str, None, PredefinedSerializer(), optional=True), +] + +ApiDownloadModelInstanceVersionRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()), + FieldMetadata("versionNumber", "version_number", "_version_number", int, 0, PredefinedSerializer()), + FieldMetadata("path", "path", "_path", str, None, PredefinedSerializer(), optional=True), +] + +ApiGetModelInstanceRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()), +] + +ApiGetModelRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), +] + +ApiListModelInstanceVersionFilesRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("versionNumber", "version_number", "_version_number", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True), +] + +ApiListModelInstanceVersionFilesResponse._fields = [ + FieldMetadata("files", "files", "_files", ApiModelFile, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()), +] + +ApiListModelsRequest._fields = [ + FieldMetadata("search", "search", "_search", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("sortBy", "sort_by", "_sort_by", ListModelsOrderBy, None, EnumSerializer(), optional=True), + FieldMetadata("owner", "owner", "_owner", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True), +] + +ApiListModelsResponse._fields = [ + FieldMetadata("models", "models", "_models", ApiModel, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()), + FieldMetadata("totalResults", "total_results", "_total_results", int, 0, PredefinedSerializer()), +] + +ApiModel._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()), + FieldMetadata("title", "title", "_title", str, "", PredefinedSerializer()), + FieldMetadata("subtitle", "subtitle", "_subtitle", str, "", PredefinedSerializer()), + FieldMetadata("author", "author", "_author", str, "", PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("isPrivate", "is_private", "_is_private", bool, False, PredefinedSerializer()), + FieldMetadata("description", "description", "_description", str, "", PredefinedSerializer()), + FieldMetadata("instances", "instances", "_instances", ApiModelInstance, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("tags", "tags", "_tags", ApiCategory, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("publishTime", "publish_time", "_publish_time", datetime, None, DateTimeSerializer()), + FieldMetadata("provenanceSources", "provenance_sources", "_provenance_sources", str, "", PredefinedSerializer()), + FieldMetadata("url", "url", "_url", str, "", PredefinedSerializer()), +] + +ApiModelFile._fields = [ + FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()), + FieldMetadata("size", "size", "_size", int, 0, PredefinedSerializer()), + FieldMetadata("creationDate", "creation_date", "_creation_date", datetime, None, DateTimeSerializer(), optional=True), +] + +ApiModelInstance._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("fineTunable", "fine_tunable", "_fine_tunable", bool, False, PredefinedSerializer()), + FieldMetadata("overview", "overview", "_overview", str, "", PredefinedSerializer()), + FieldMetadata("usage", "usage", "_usage", str, "", PredefinedSerializer()), + FieldMetadata("downloadUrl", "download_url", "_download_url", str, "", PredefinedSerializer()), + FieldMetadata("versionId", "version_id", "_version_id", int, 0, PredefinedSerializer()), + FieldMetadata("versionNumber", "version_number", "_version_number", int, 0, PredefinedSerializer()), + FieldMetadata("trainingData", "training_data", "_training_data", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("url", "url", "_url", str, "", PredefinedSerializer()), + FieldMetadata("licenseName", "license_name", "_license_name", str, "", PredefinedSerializer()), + FieldMetadata("modelInstanceType", "model_instance_type", "_model_instance_type", ModelInstanceType, ModelInstanceType.MODEL_INSTANCE_TYPE_UNSPECIFIED, EnumSerializer()), + FieldMetadata("baseModelInstanceInformation", "base_model_instance_information", "_base_model_instance_information", BaseModelInstanceInformation, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("externalBaseModelUrl", "external_base_model_url", "_external_base_model_url", str, "", PredefinedSerializer()), +] + +ApiUpdateModelInstanceRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()), + FieldMetadata("overview", "overview", "_overview", str, "", PredefinedSerializer()), + FieldMetadata("usage", "usage", "_usage", str, "", PredefinedSerializer()), + FieldMetadata("fineTunable", "fine_tunable", "_fine_tunable", bool, None, PredefinedSerializer(), optional=True), + FieldMetadata("trainingData", "training_data", "_training_data", str, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("updateMask", "update_mask", "_update_mask", FieldMask, None, FieldMaskSerializer()), + FieldMetadata("licenseName", "license_name", "_license_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("modelInstanceType", "model_instance_type", "_model_instance_type", ModelInstanceType, None, EnumSerializer(), optional=True), + FieldMetadata("baseModelInstance", "base_model_instance", "_base_model_instance", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("externalBaseModelUrl", "external_base_model_url", "_external_base_model_url", str, None, PredefinedSerializer(), optional=True), +] + +ApiUpdateModelRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("title", "title", "_title", str, "", PredefinedSerializer()), + FieldMetadata("subtitle", "subtitle", "_subtitle", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("isPrivate", "is_private", "_is_private", bool, False, PredefinedSerializer()), + FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("publishTime", "publish_time", "_publish_time", datetime, None, DateTimeSerializer()), + FieldMetadata("provenanceSources", "provenance_sources", "_provenance_sources", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("updateMask", "update_mask", "_update_mask", FieldMask, None, FieldMaskSerializer()), +] + +ApiUpdateModelResponse._fields = [ + FieldMetadata("id", "id", "_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("ref", "ref", "_ref", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("error", "error", "_error", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True), +] + +ApiUploadModelFileRequest._fields = [ + FieldMetadata("fileName", "file_name", "_file_name", str, "", PredefinedSerializer()), + FieldMetadata("contentLength", "content_length", "_content_length", int, 0, PredefinedSerializer()), + FieldMetadata("lastModifiedEpochSeconds", "last_modified_epoch_seconds", "_last_modified_epoch_seconds", int, 0, PredefinedSerializer()), +] + +ApiUploadModelFileResponse._fields = [ + FieldMetadata("token", "token", "_token", str, "", PredefinedSerializer()), + FieldMetadata("createUrl", "create_url", "_create_url", str, "", PredefinedSerializer()), +] + diff --git a/kagglesdk/models/types/model_enums.py b/kagglesdk/models/types/model_enums.py new file mode 100644 index 0000000..a7f488e --- /dev/null +++ b/kagglesdk/models/types/model_enums.py @@ -0,0 +1,44 @@ +import enum + +class ListModelsOrderBy(enum.Enum): + LIST_MODELS_ORDER_BY_UNSPECIFIED = 0 + LIST_MODELS_ORDER_BY_HOTNESS = 1 + LIST_MODELS_ORDER_BY_DOWNLOAD_COUNT = 2 + LIST_MODELS_ORDER_BY_VOTE_COUNT = 3 + LIST_MODELS_ORDER_BY_NOTEBOOK_COUNT = 4 + LIST_MODELS_ORDER_BY_PUBLISH_TIME = 5 + LIST_MODELS_ORDER_BY_CREATE_TIME = 6 + LIST_MODELS_ORDER_BY_UPDATE_TIME = 7 + LIST_MODELS_ORDER_BY_VIEW_TIME_DESC = 8 + +class ModelFramework(enum.Enum): + MODEL_FRAMEWORK_UNSPECIFIED = 0 + MODEL_FRAMEWORK_TENSOR_FLOW_1 = 1 + MODEL_FRAMEWORK_TENSOR_FLOW_2 = 2 + MODEL_FRAMEWORK_TF_LITE = 3 + MODEL_FRAMEWORK_TF_JS = 4 + MODEL_FRAMEWORK_PY_TORCH = 5 + MODEL_FRAMEWORK_JAX = 6 + MODEL_FRAMEWORK_FLAX = 14 + MODEL_FRAMEWORK_PAX = 15 + MODEL_FRAMEWORK_MAX_TEXT = 17 + MODEL_FRAMEWORK_GEMMA_CPP = 18 + MODEL_FRAMEWORK_GGML = 19 + MODEL_FRAMEWORK_GGUF = 21 + MODEL_FRAMEWORK_CORAL = 7 + MODEL_FRAMEWORK_SCIKIT_LEARN = 8 + MODEL_FRAMEWORK_MXNET = 9 + MODEL_FRAMEWORK_ONNX = 10 + MODEL_FRAMEWORK_KERAS = 11 + MODEL_FRAMEWORK_TRANSFORMERS = 16 + MODEL_FRAMEWORK_API = 12 + MODEL_FRAMEWORK_OTHER = 13 + MODEL_FRAMEWORK_TENSOR_RT_LLM = 20 + MODEL_FRAMEWORK_TRITON = 22 + +class ModelInstanceType(enum.Enum): + MODEL_INSTANCE_TYPE_UNSPECIFIED = 0 + MODEL_INSTANCE_TYPE_BASE_MODEL = 1 + MODEL_INSTANCE_TYPE_KAGGLE_VARIANT = 2 + MODEL_INSTANCE_TYPE_EXTERNAL_VARIANT = 3 + diff --git a/kagglesdk/models/types/model_service.py b/kagglesdk/models/types/model_service.py new file mode 100644 index 0000000..e8afa4b --- /dev/null +++ b/kagglesdk/models/types/model_service.py @@ -0,0 +1,271 @@ +from datetime import datetime +from kagglesdk.kaggle_object import * +from kagglesdk.models.types.model_enums import ModelFramework +from typing import Optional, List + +class GetModelMetricsRequest(KaggleObject): + r""" + Attributes: + owner_slug (str) + model_slug (str) + start_time (datetime) + Optional start time for the time series. A year ago by default. + """ + + def __init__(self): + self._owner_slug = "" + self._model_slug = "" + self._start_time = None + self._freeze() + + @property + def owner_slug(self) -> str: + return self._owner_slug + + @owner_slug.setter + def owner_slug(self, owner_slug: str): + if owner_slug is None: + del self.owner_slug + return + if not isinstance(owner_slug, str): + raise TypeError('owner_slug must be of type str') + self._owner_slug = owner_slug + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def start_time(self) -> datetime: + """Optional start time for the time series. A year ago by default.""" + return self._start_time or None + + @start_time.setter + def start_time(self, start_time: datetime): + if start_time is None: + del self.start_time + return + if not isinstance(start_time, datetime): + raise TypeError('start_time must be of type datetime') + self._start_time = start_time + + + def endpoint(self): + path = '/api/v1/models/{owner_slug}/{model_slug}/metrics' + return path.format_map(self.to_field_map(self)) + +class GetModelMetricsResponse(KaggleObject): + r""" + Attributes: + metrics (ModelMetric) + """ + + def __init__(self): + self._metrics = [] + self._freeze() + + @property + def metrics(self) -> Optional[List[Optional['ModelMetric']]]: + return self._metrics + + @metrics.setter + def metrics(self, metrics: Optional[List[Optional['ModelMetric']]]): + if metrics is None: + del self.metrics + return + if not isinstance(metrics, list): + raise TypeError('metrics must be of type list') + if not all([isinstance(t, ModelMetric) for t in metrics]): + raise TypeError('metrics must contain only items of type ModelMetric') + self._metrics = metrics + + +class ModelMetric(KaggleObject): + r""" + Attributes: + date (str) + views (int) + downloads (int) + notebooks (int) + instances (ModelInstanceMetric) + """ + + def __init__(self): + self._date = "" + self._views = 0 + self._downloads = 0 + self._notebooks = 0 + self._instances = [] + self._freeze() + + @property + def date(self) -> str: + return self._date + + @date.setter + def date(self, date: str): + if date is None: + del self.date + return + if not isinstance(date, str): + raise TypeError('date must be of type str') + self._date = date + + @property + def views(self) -> int: + return self._views + + @views.setter + def views(self, views: int): + if views is None: + del self.views + return + if not isinstance(views, int): + raise TypeError('views must be of type int') + self._views = views + + @property + def downloads(self) -> int: + return self._downloads + + @downloads.setter + def downloads(self, downloads: int): + if downloads is None: + del self.downloads + return + if not isinstance(downloads, int): + raise TypeError('downloads must be of type int') + self._downloads = downloads + + @property + def notebooks(self) -> int: + return self._notebooks + + @notebooks.setter + def notebooks(self, notebooks: int): + if notebooks is None: + del self.notebooks + return + if not isinstance(notebooks, int): + raise TypeError('notebooks must be of type int') + self._notebooks = notebooks + + @property + def instances(self) -> Optional[List[Optional['ModelInstanceMetric']]]: + return self._instances + + @instances.setter + def instances(self, instances: Optional[List[Optional['ModelInstanceMetric']]]): + if instances is None: + del self.instances + return + if not isinstance(instances, list): + raise TypeError('instances must be of type list') + if not all([isinstance(t, ModelInstanceMetric) for t in instances]): + raise TypeError('instances must contain only items of type ModelInstanceMetric') + self._instances = instances + + +class ModelInstanceMetric(KaggleObject): + r""" + Attributes: + variation (str) + framework (ModelFramework) + downloads (int) + notebooks (int) + """ + + def __init__(self): + self._variation = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._downloads = 0 + self._notebooks = 0 + self._freeze() + + @property + def variation(self) -> str: + return self._variation + + @variation.setter + def variation(self, variation: str): + if variation is None: + del self.variation + return + if not isinstance(variation, str): + raise TypeError('variation must be of type str') + self._variation = variation + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + @property + def downloads(self) -> int: + return self._downloads + + @downloads.setter + def downloads(self, downloads: int): + if downloads is None: + del self.downloads + return + if not isinstance(downloads, int): + raise TypeError('downloads must be of type int') + self._downloads = downloads + + @property + def notebooks(self) -> int: + return self._notebooks + + @notebooks.setter + def notebooks(self, notebooks: int): + if notebooks is None: + del self.notebooks + return + if not isinstance(notebooks, int): + raise TypeError('notebooks must be of type int') + self._notebooks = notebooks + + +GetModelMetricsRequest._fields = [ + FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("startTime", "start_time", "_start_time", datetime, None, DateTimeSerializer(), optional=True), +] + +GetModelMetricsResponse._fields = [ + FieldMetadata("metrics", "metrics", "_metrics", ModelMetric, [], ListSerializer(KaggleObjectSerializer())), +] + +ModelMetric._fields = [ + FieldMetadata("date", "date", "_date", str, "", PredefinedSerializer()), + FieldMetadata("views", "views", "_views", int, 0, PredefinedSerializer()), + FieldMetadata("downloads", "downloads", "_downloads", int, 0, PredefinedSerializer()), + FieldMetadata("notebooks", "notebooks", "_notebooks", int, 0, PredefinedSerializer()), + FieldMetadata("instances", "instances", "_instances", ModelInstanceMetric, [], ListSerializer(KaggleObjectSerializer())), +] + +ModelInstanceMetric._fields = [ + FieldMetadata("variation", "variation", "_variation", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), + FieldMetadata("downloads", "downloads", "_downloads", int, 0, PredefinedSerializer()), + FieldMetadata("notebooks", "notebooks", "_notebooks", int, 0, PredefinedSerializer()), +] + diff --git a/kagglesdk/models/types/model_types.py b/kagglesdk/models/types/model_types.py new file mode 100644 index 0000000..96a4931 --- /dev/null +++ b/kagglesdk/models/types/model_types.py @@ -0,0 +1,226 @@ +from kagglesdk.kaggle_object import * +from kagglesdk.models.types.model_enums import ModelFramework +from kagglesdk.users.types.users_enums import UserAchievementTier +from typing import Optional + +class BaseModelInstanceInformation(KaggleObject): + r""" + Attributes: + id (int) + owner (Owner) + model_slug (str) + instance_slug (str) + framework (ModelFramework) + """ + + def __init__(self): + self._id = 0 + self._owner = None + self._model_slug = "" + self._instance_slug = "" + self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED + self._freeze() + + @property + def id(self) -> int: + return self._id + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def owner(self) -> Optional['Owner']: + return self._owner + + @owner.setter + def owner(self, owner: Optional['Owner']): + if owner is None: + del self.owner + return + if not isinstance(owner, Owner): + raise TypeError('owner must be of type Owner') + self._owner = owner + + @property + def model_slug(self) -> str: + return self._model_slug + + @model_slug.setter + def model_slug(self, model_slug: str): + if model_slug is None: + del self.model_slug + return + if not isinstance(model_slug, str): + raise TypeError('model_slug must be of type str') + self._model_slug = model_slug + + @property + def instance_slug(self) -> str: + return self._instance_slug + + @instance_slug.setter + def instance_slug(self, instance_slug: str): + if instance_slug is None: + del self.instance_slug + return + if not isinstance(instance_slug, str): + raise TypeError('instance_slug must be of type str') + self._instance_slug = instance_slug + + @property + def framework(self) -> 'ModelFramework': + return self._framework + + @framework.setter + def framework(self, framework: 'ModelFramework'): + if framework is None: + del self.framework + return + if not isinstance(framework, ModelFramework): + raise TypeError('framework must be of type ModelFramework') + self._framework = framework + + +class Owner(KaggleObject): + r""" + Based off Datasets OwnerDto as the permission model is the same + Separate message since Models don't have max_file_size_bytes. + Consider renaming more generically to apply to Users/Orgs + interchangeably without a strict concept of ownership + + Attributes: + id (int) + image_url (str) + is_organization (bool) + name (str) + profile_url (str) + slug (str) + user_tier (UserAchievementTier) + """ + + def __init__(self): + self._id = 0 + self._image_url = None + self._is_organization = False + self._name = "" + self._profile_url = None + self._slug = "" + self._user_tier = UserAchievementTier.NOVICE + self._freeze() + + @property + def id(self) -> int: + return self._id + + @id.setter + def id(self, id: int): + if id is None: + del self.id + return + if not isinstance(id, int): + raise TypeError('id must be of type int') + self._id = id + + @property + def image_url(self) -> str: + return self._image_url or "" + + @image_url.setter + def image_url(self, image_url: str): + if image_url is None: + del self.image_url + return + if not isinstance(image_url, str): + raise TypeError('image_url must be of type str') + self._image_url = image_url + + @property + def is_organization(self) -> bool: + return self._is_organization + + @is_organization.setter + def is_organization(self, is_organization: bool): + if is_organization is None: + del self.is_organization + return + if not isinstance(is_organization, bool): + raise TypeError('is_organization must be of type bool') + self._is_organization = is_organization + + @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 profile_url(self) -> str: + return self._profile_url or "" + + @profile_url.setter + def profile_url(self, profile_url: str): + if profile_url is None: + del self.profile_url + return + if not isinstance(profile_url, str): + raise TypeError('profile_url must be of type str') + self._profile_url = profile_url + + @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 user_tier(self) -> 'UserAchievementTier': + return self._user_tier + + @user_tier.setter + def user_tier(self, user_tier: 'UserAchievementTier'): + if user_tier is None: + del self.user_tier + return + if not isinstance(user_tier, UserAchievementTier): + raise TypeError('user_tier must be of type UserAchievementTier') + self._user_tier = user_tier + + +BaseModelInstanceInformation._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("owner", "owner", "_owner", Owner, None, KaggleObjectSerializer()), + FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()), + FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()), + FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()), +] + +Owner._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("imageUrl", "image_url", "_image_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("isOrganization", "is_organization", "_is_organization", bool, False, PredefinedSerializer()), + FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()), + FieldMetadata("profileUrl", "profile_url", "_profile_url", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("userTier", "user_tier", "_user_tier", UserAchievementTier, UserAchievementTier.NOVICE, EnumSerializer()), +] + diff --git a/kagglesdk/users/__init__.py b/kagglesdk/users/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/users/types/__init__.py b/kagglesdk/users/types/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/kagglesdk/users/types/users_enums.py b/kagglesdk/users/types/users_enums.py new file mode 100644 index 0000000..9b91246 --- /dev/null +++ b/kagglesdk/users/types/users_enums.py @@ -0,0 +1,22 @@ +import enum + +class CollaboratorType(enum.Enum): + COLLABORATOR_TYPE_UNSPECIFIED = 0 + READER = 1 + WRITER = 2 + OWNER = 3 + ADMIN = 4 + +class UserAchievementTier(enum.Enum): + NOVICE = 0 + CONTRIBUTOR = 1 + EXPERT = 2 + MASTER = 3 + GRANDMASTER = 4 + STAFF = 5 + """Kaggle admins""" + ORGANIZATION = 11 + """Organizations""" + RECALC = 21 + """Flag user for tier recalculation""" +