From 8d6326a55069f455ebbebe6b575124f6124012fa Mon Sep 17 00:00:00 2001 From: Steve Messick Date: Thu, 11 Jun 2026 17:35:23 +0000 Subject: [PATCH] Regenerated from kapigen after resync --- kagglesdk/__init__.py | 2 +- kagglesdk/benchmarks/types/benchmark_types.py | 22 ++ .../services/hackathon_service.py | 35 +- .../competitions/types/hackathon_service.py | 321 ++++++++++-------- kagglesdk/competitions/types/page_service.py | 58 ++-- kagglesdk/competitions/types/team.py | 24 ++ kagglesdk/kaggle_http_client.py | 80 +++-- .../kernels/types/kernels_api_service.py | 130 ++++++- kagglesdk/models/types/model_enums.py | 1 + kagglesdk/security/types/iam_service.py | 4 +- pyproject.toml | 2 +- 11 files changed, 447 insertions(+), 232 deletions(-) diff --git a/kagglesdk/__init__.py b/kagglesdk/__init__.py index ad11a7c..a01a678 100644 --- a/kagglesdk/__init__.py +++ b/kagglesdk/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.1.28" +__version__ = "0.1.29" from kagglesdk.kaggle_client import KaggleClient from kagglesdk.kaggle_creds import KaggleCredentials diff --git a/kagglesdk/benchmarks/types/benchmark_types.py b/kagglesdk/benchmarks/types/benchmark_types.py index 39292cc..045ed7c 100644 --- a/kagglesdk/benchmarks/types/benchmark_types.py +++ b/kagglesdk/benchmarks/types/benchmark_types.py @@ -255,6 +255,9 @@ class BenchmarkModelVersion(KaggleObject): Input modalities supported by this model version. output_modalities (Modality) Output modalities supported by this model version. + deprecation_time (datetime) + Timestamp when this model version was deprecated. A future value indicates + a scheduled deprecation. Null/unset means not deprecated. """ def __init__(self): @@ -275,6 +278,7 @@ def __init__(self): self._importance_level = None self._input_modalities = [] self._output_modalities = [] + self._deprecation_time = None self._freeze() @property @@ -530,6 +534,23 @@ def output_modalities(self, output_modalities: Optional[List['Modality']]): raise TypeError('output_modalities must contain only items of type Modality') self._output_modalities = output_modalities + @property + def deprecation_time(self) -> datetime: + r""" + Timestamp when this model version was deprecated. A future value indicates + a scheduled deprecation. Null/unset means not deprecated. + """ + return self._deprecation_time or None + + @deprecation_time.setter + def deprecation_time(self, deprecation_time: Optional[datetime]): + if deprecation_time is None: + del self.deprecation_time + return + if not isinstance(deprecation_time, datetime): + raise TypeError('deprecation_time must be of type datetime') + self._deprecation_time = deprecation_time + class BenchmarkResult(KaggleObject): r""" @@ -882,6 +903,7 @@ def minus(self, minus: float): FieldMetadata("importanceLevel", "importance_level", "_importance_level", BenchmarkModelImportanceLevel, None, EnumSerializer(), optional=True), FieldMetadata("inputModalities", "input_modalities", "_input_modalities", Modality, [], ListSerializer(EnumSerializer())), FieldMetadata("outputModalities", "output_modalities", "_output_modalities", Modality, [], ListSerializer(EnumSerializer())), + FieldMetadata("deprecationTime", "deprecation_time", "_deprecation_time", datetime, None, DateTimeSerializer(), optional=True), ] BenchmarkResult._fields = [ diff --git a/kagglesdk/competitions/services/hackathon_service.py b/kagglesdk/competitions/services/hackathon_service.py index 837e800..9783c5f 100644 --- a/kagglesdk/competitions/services/hackathon_service.py +++ b/kagglesdk/competitions/services/hackathon_service.py @@ -1,19 +1,30 @@ -from kagglesdk.competitions.types.hackathon_service import ListHackathonTracksRequest, ListHackathonTracksResponse +from kagglesdk.competitions.types.hackathon_service import ( + ListHackathonTracksRequest, + ListHackathonTracksResponse, +) from kagglesdk.kaggle_http_client import KaggleHttpClient + class HackathonClient(object): - def __init__(self, client: KaggleHttpClient): - self._client = client + def __init__(self, client: KaggleHttpClient): + self._client = client - def list_hackathon_tracks(self, request: ListHackathonTracksRequest = None) -> ListHackathonTracksResponse: - r""" - Args: - request (ListHackathonTracksRequest): - The request object; initialized to empty instance if not specified. - """ + def list_hackathon_tracks( + self, request: ListHackathonTracksRequest = None + ) -> ListHackathonTracksResponse: + r""" + Args: + request (ListHackathonTracksRequest): + The request object; initialized to empty instance if not specified. + """ - if request is None: - request = ListHackathonTracksRequest() + if request is None: + request = ListHackathonTracksRequest() - return self._client.call("competitions.HackathonService", "ListHackathonTracks", request, ListHackathonTracksResponse) + return self._client.call( + "competitions.HackathonService", + "ListHackathonTracks", + request, + ListHackathonTracksResponse, + ) diff --git a/kagglesdk/competitions/types/hackathon_service.py b/kagglesdk/competitions/types/hackathon_service.py index 0d3e684..7a4215e 100644 --- a/kagglesdk/competitions/types/hackathon_service.py +++ b/kagglesdk/competitions/types/hackathon_service.py @@ -2,159 +2,202 @@ from kagglesdk.kaggle_object import * from typing import Optional, List + class ListHackathonTracksRequest(KaggleObject): - r""" - Attributes: - competition_id (int) - competition_name (str) - """ - - def __init__(self): - self._competition_id = None - self._competition_name = None - self._freeze() - - @property - def competition_id(self) -> int: - return self._competition_id or 0 - - @competition_id.setter - def competition_id(self, competition_id: Optional[int]): - if competition_id is None: - del self.competition_id - return - if not isinstance(competition_id, int): - raise TypeError('competition_id must be of type int') - self._competition_id = competition_id - - @property - def competition_name(self) -> str: - return self._competition_name or "" - - @competition_name.setter - def competition_name(self, competition_name: Optional[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_id}/hackathon-tracks' - return path.format_map(self.to_field_map(self)) - - @staticmethod - def endpoint_path(): - return '/api/v1/competitions/{competition_id}/hackathon-tracks' + r""" + Attributes: + competition_id (int) + competition_name (str) + """ + + def __init__(self): + self._competition_id = None + self._competition_name = None + self._freeze() + + @property + def competition_id(self) -> int: + return self._competition_id or 0 + + @competition_id.setter + def competition_id(self, competition_id: Optional[int]): + if competition_id is None: + del self.competition_id + return + if not isinstance(competition_id, int): + raise TypeError("competition_id must be of type int") + self._competition_id = competition_id + + @property + def competition_name(self) -> str: + return self._competition_name or "" + + @competition_name.setter + def competition_name(self, competition_name: Optional[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_id}/hackathon-tracks" + return path.format_map(self.to_field_map(self)) + + @staticmethod + def endpoint_path(): + return "/api/v1/competitions/{competition_id}/hackathon-tracks" class ListHackathonTracksResponse(KaggleObject): - r""" - Attributes: - tracks (HackathonTrack) - """ - - def __init__(self): - self._tracks = [] - self._freeze() - - @property - def tracks(self) -> Optional[List[Optional['HackathonTrack']]]: - return self._tracks - - @tracks.setter - def tracks(self, tracks: Optional[List[Optional['HackathonTrack']]]): - if tracks is None: - del self.tracks - return - if not isinstance(tracks, list): - raise TypeError('tracks must be of type list') - if not all([isinstance(t, HackathonTrack) for t in tracks]): - raise TypeError('tracks must contain only items of type HackathonTrack') - self._tracks = tracks + r""" + Attributes: + tracks (HackathonTrack) + """ + + def __init__(self): + self._tracks = [] + self._freeze() + + @property + def tracks(self) -> Optional[List[Optional["HackathonTrack"]]]: + return self._tracks + + @tracks.setter + def tracks(self, tracks: Optional[List[Optional["HackathonTrack"]]]): + if tracks is None: + del self.tracks + return + if not isinstance(tracks, list): + raise TypeError("tracks must be of type list") + if not all([isinstance(t, HackathonTrack) for t in tracks]): + raise TypeError("tracks must contain only items of type HackathonTrack") + self._tracks = tracks class ListHackathonWriteUpsResponse(KaggleObject): - r""" - Attributes: - hackathon_write_ups (HackathonWriteUp) - next_page_token (str) - total_count (int) - """ - - def __init__(self): - self._hackathon_write_ups = [] - self._next_page_token = "" - self._total_count = 0 - self._freeze() - - @property - def hackathon_write_ups(self) -> Optional[List[Optional['HackathonWriteUp']]]: - return self._hackathon_write_ups - - @hackathon_write_ups.setter - def hackathon_write_ups(self, hackathon_write_ups: Optional[List[Optional['HackathonWriteUp']]]): - if hackathon_write_ups is None: - del self.hackathon_write_ups - return - if not isinstance(hackathon_write_ups, list): - raise TypeError('hackathon_write_ups must be of type list') - if not all([isinstance(t, HackathonWriteUp) for t in hackathon_write_ups]): - raise TypeError('hackathon_write_ups must contain only items of type HackathonWriteUp') - self._hackathon_write_ups = hackathon_write_ups - - @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_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 - - @property - def hackathonWriteUps(self): - return self.hackathon_write_ups - - @property - def nextPageToken(self): - return self.next_page_token - - @property - def totalCount(self): - return self.total_count + r""" + Attributes: + hackathon_write_ups (HackathonWriteUp) + next_page_token (str) + total_count (int) + """ + + def __init__(self): + self._hackathon_write_ups = [] + self._next_page_token = "" + self._total_count = 0 + self._freeze() + + @property + def hackathon_write_ups(self) -> Optional[List[Optional["HackathonWriteUp"]]]: + return self._hackathon_write_ups + + @hackathon_write_ups.setter + def hackathon_write_ups( + self, hackathon_write_ups: Optional[List[Optional["HackathonWriteUp"]]] + ): + if hackathon_write_ups is None: + del self.hackathon_write_ups + return + if not isinstance(hackathon_write_ups, list): + raise TypeError("hackathon_write_ups must be of type list") + if not all([isinstance(t, HackathonWriteUp) for t in hackathon_write_ups]): + raise TypeError( + "hackathon_write_ups must contain only items of type HackathonWriteUp" + ) + self._hackathon_write_ups = hackathon_write_ups + + @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_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 + + @property + def hackathonWriteUps(self): + return self.hackathon_write_ups + + @property + def nextPageToken(self): + return self.next_page_token + + @property + def totalCount(self): + return self.total_count ListHackathonTracksRequest._fields = [ - FieldMetadata("competitionId", "competition_id", "_competition_id", int, None, PredefinedSerializer(), optional=True), - FieldMetadata("competitionName", "competition_name", "_competition_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata( + "competitionId", + "competition_id", + "_competition_id", + int, + None, + PredefinedSerializer(), + optional=True, + ), + FieldMetadata( + "competitionName", + "competition_name", + "_competition_name", + str, + None, + PredefinedSerializer(), + optional=True, + ), ] ListHackathonTracksResponse._fields = [ - FieldMetadata("tracks", "tracks", "_tracks", HackathonTrack, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata( + "tracks", + "tracks", + "_tracks", + HackathonTrack, + [], + ListSerializer(KaggleObjectSerializer()), + ), ] ListHackathonWriteUpsResponse._fields = [ - FieldMetadata("hackathonWriteUps", "hackathon_write_ups", "_hackathon_write_ups", HackathonWriteUp, [], ListSerializer(KaggleObjectSerializer())), - FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()), - FieldMetadata("totalCount", "total_count", "_total_count", int, 0, PredefinedSerializer()), + FieldMetadata( + "hackathonWriteUps", + "hackathon_write_ups", + "_hackathon_write_ups", + HackathonWriteUp, + [], + ListSerializer(KaggleObjectSerializer()), + ), + FieldMetadata( + "nextPageToken", + "next_page_token", + "_next_page_token", + str, + "", + PredefinedSerializer(), + ), + FieldMetadata( + "totalCount", "total_count", "_total_count", int, 0, PredefinedSerializer() + ), ] - diff --git a/kagglesdk/competitions/types/page_service.py b/kagglesdk/competitions/types/page_service.py index 6788f26..d55e608 100644 --- a/kagglesdk/competitions/types/page_service.py +++ b/kagglesdk/competitions/types/page_service.py @@ -2,36 +2,38 @@ from kagglesdk.kaggle_object import * from typing import List, Optional + class ListPagesResponse(KaggleObject): - r""" - TODO(aip.dev/158): (-- api-linter: - core::0158::response-next-page-token-field=disabled --) - - Attributes: - pages (Page) - """ - - def __init__(self): - self._pages = [] - self._freeze() - - @property - def pages(self) -> Optional[List[Optional['Page']]]: - return self._pages - - @pages.setter - def pages(self, pages: Optional[List[Optional['Page']]]): - if pages is None: - del self.pages - return - if not isinstance(pages, list): - raise TypeError('pages must be of type list') - if not all([isinstance(t, Page) for t in pages]): - raise TypeError('pages must contain only items of type Page') - self._pages = pages + r""" + TODO(aip.dev/158): (-- api-linter: + core::0158::response-next-page-token-field=disabled --) + + Attributes: + pages (Page) + """ + + def __init__(self): + self._pages = [] + self._freeze() + + @property + def pages(self) -> Optional[List[Optional["Page"]]]: + return self._pages + + @pages.setter + def pages(self, pages: Optional[List[Optional["Page"]]]): + if pages is None: + del self.pages + return + if not isinstance(pages, list): + raise TypeError("pages must be of type list") + if not all([isinstance(t, Page) for t in pages]): + raise TypeError("pages must contain only items of type Page") + self._pages = pages ListPagesResponse._fields = [ - FieldMetadata("pages", "pages", "_pages", Page, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata( + "pages", "pages", "_pages", Page, [], ListSerializer(KaggleObjectSerializer()) + ), ] - diff --git a/kagglesdk/competitions/types/team.py b/kagglesdk/competitions/types/team.py index f246bc3..7ddde33 100644 --- a/kagglesdk/competitions/types/team.py +++ b/kagglesdk/competitions/types/team.py @@ -53,6 +53,10 @@ class Team(KaggleObject): ForumTopic of the team's solution writeup, if set. benchmark_model_version_id (int) Linked benchmark model version, if set. + benchmark_model_version_display_name (str) + DisplayName of the linked BenchmarkModelVersion, if set. Preferred over + team_name in surfaces where a single label per team is shown (e.g. the + Episode panel and replayer). team_members (UserAvatar) The list of users on the team. """ @@ -75,6 +79,7 @@ def __init__(self): self._team_up_intro = None self._write_up_forum_topic_id = None self._benchmark_model_version_id = None + self._benchmark_model_version_display_name = None self._team_members = [] self._freeze() @@ -345,6 +350,24 @@ def benchmark_model_version_id(self, benchmark_model_version_id: Optional[int]): raise TypeError('benchmark_model_version_id must be of type int') self._benchmark_model_version_id = benchmark_model_version_id + @property + def benchmark_model_version_display_name(self) -> str: + r""" + DisplayName of the linked BenchmarkModelVersion, if set. Preferred over + team_name in surfaces where a single label per team is shown (e.g. the + Episode panel and replayer). + """ + return self._benchmark_model_version_display_name or "" + + @benchmark_model_version_display_name.setter + def benchmark_model_version_display_name(self, benchmark_model_version_display_name: Optional[str]): + if benchmark_model_version_display_name is None: + del self.benchmark_model_version_display_name + return + if not isinstance(benchmark_model_version_display_name, str): + raise TypeError('benchmark_model_version_display_name must be of type str') + self._benchmark_model_version_display_name = benchmark_model_version_display_name + @property def team_members(self) -> Optional[List[Optional['UserAvatar']]]: """The list of users on the team.""" @@ -434,6 +457,7 @@ def intro(self, intro: Optional[str]): FieldMetadata("teamUpIntro", "team_up_intro", "_team_up_intro", str, None, PredefinedSerializer(), optional=True), FieldMetadata("writeUpForumTopicId", "write_up_forum_topic_id", "_write_up_forum_topic_id", int, None, PredefinedSerializer(), optional=True), FieldMetadata("benchmarkModelVersionId", "benchmark_model_version_id", "_benchmark_model_version_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("benchmarkModelVersionDisplayName", "benchmark_model_version_display_name", "_benchmark_model_version_display_name", str, None, PredefinedSerializer(), optional=True), FieldMetadata("teamMembers", "team_members", "_team_members", UserAvatar, [], ListSerializer(KaggleObjectSerializer())), ] diff --git a/kagglesdk/kaggle_http_client.py b/kagglesdk/kaggle_http_client.py index 6d4ae7d..8ede93b 100644 --- a/kagglesdk/kaggle_http_client.py +++ b/kagglesdk/kaggle_http_client.py @@ -43,12 +43,12 @@ def _get_apikey_creds(): return None try: - "Be careful, since the file may be used for more than credential storage." + # Be careful, since the file may be used for more than credential storage. api_key_data = json.loads(kaggle_json) username = api_key_data["username"] api_key = api_key_data["key"] return username, api_key - except KeyError as e: + except KeyError: return None @@ -59,14 +59,14 @@ class KaggleHttpClient(object): _xsrf_header_name = "X-XSRF-TOKEN" def __init__( - self, - env: KaggleEnv = None, - verbose: bool = False, - username: str = None, - password: str = None, - api_token: str = None, - user_agent: str = "kaggle-api/v1.7.0", # Was: V2 - response_processor=None, + self, + env: KaggleEnv = None, + verbose: bool = False, + username: str = None, + password: str = None, + api_token: str = None, + user_agent: str = "kaggle-api/v1.7.0", # Was: V2 + response_processor=None, ): self._env = env or get_env() self._signed_in = None @@ -80,21 +80,25 @@ def __init__( self._response_processor = response_processor def call( - self, - service_name: str, - request_name: str, - request: KaggleObject, - response_type: Type[KaggleObject], + self, + service_name: str, + request_name: str, + request: KaggleObject, + response_type: Type[KaggleObject], ): self._init_session() http_request = self._prepare_request(service_name, request_name, request) # Merge environment settings into session - settings = self._session.merge_environment_settings(http_request.url, {}, None, None, None) + settings = self._session.merge_environment_settings( + http_request.url, {}, None, None, None + ) # Use stream=True for file downloads to avoid loading entire file into memory # See: https://github.com/Kaggle/kaggle-api/issues/754 - if response_type is not None and (response_type == FileDownload or response_type == HttpRedirect): + if response_type is not None and ( + response_type == FileDownload or response_type == HttpRedirect + ): settings["stream"] = True http_response = self._session.send(http_request, **settings) @@ -102,7 +106,9 @@ def call( response = self._prepare_response(response_type, http_response) return response - def _prepare_request(self, service_name: str, request_name: str, request: KaggleObject): + def _prepare_request( + self, service_name: str, request_name: str, request: KaggleObject + ): request_url = self._get_request_url(service_name, request_name) http_request = requests.Request( method="POST", @@ -122,7 +128,9 @@ def _prepare_response(self, response_type, http_response): if "application/json" in http_response.headers["Content-Type"]: resp = http_response.json() if "code" in resp and resp["code"] >= 400: - raise requests.exceptions.HTTPError(resp["message"], response=http_response) + raise requests.exceptions.HTTPError( + resp["message"], response=http_response + ) except KeyError: pass http_response.raise_for_status() @@ -137,7 +145,9 @@ def _print_request(self, request): if not self._verbose: return self._print("---------------------Request----------------------") - self._print(f"{request.method} {request.url}\n{_headers_to_str(request.headers)}\n\n{request.body}") + self._print( + f"{request.method} {request.url}\n{_headers_to_str(request.headers)}\n\n{request.body}" + ) self._print("--------------------------------------------------") def _print_response(self, response, body=True): @@ -166,7 +176,9 @@ def _init_session(self): return self._session self._session = requests.Session() - self._session.headers.update({"User-Agent": self._user_agent, "Content-Type": "application/json"}) + self._session.headers.update( + {"User-Agent": self._user_agent, "Content-Type": "application/json"} + ) iap_token = self._get_iap_token_if_required() if iap_token is not None: @@ -207,17 +219,19 @@ def _fill_xsrf_token(self, iap_token): self._session.headers.update( { - KaggleHttpClient._xsrf_header_name: self._session.cookies[KaggleHttpClient._xsrf_cookie_name], + KaggleHttpClient._xsrf_header_name: self._session.cookies[ + KaggleHttpClient._xsrf_cookie_name + ], } ) def build_start_oauth_url( - self, - client_id: str, - redirect_uri: str, - scope: list[str], - state: str, - code_challenge: str, + self, + client_id: str, + redirect_uri: str, + scope: list[str], + state: str, + code_challenge: str, ) -> str: params = { "response_type": "code", @@ -238,7 +252,9 @@ def get_oauth_default_redirect_url(self) -> str: return f"{self.get_non_api_endpoint()}/account/api/oauth/token" def get_non_api_endpoint(self) -> str: - return "https://www.kaggle.com" if self._env == KaggleEnv.PROD else self._endpoint + return ( + "https://www.kaggle.com" if self._env == KaggleEnv.PROD else self._endpoint + ) class BearerAuth(requests.auth.AuthBase): @@ -254,7 +270,7 @@ def _try_fill_auth(self): return if self._api_token is None: - (api_token, _) = get_access_token_from_env() + api_token, _ = get_access_token_from_env() self._api_token = api_token if self._api_token is not None: @@ -276,5 +292,7 @@ def _try_fill_auth(self): def _get_request_url(self, service_name: str, request_name: str): # On prod, API endpoints are served under https://api.kaggle.com/v1, # but on staging/admin/local, they are served under http://localhost/api/v1. - base_url = self._endpoint if self._env == KaggleEnv.PROD else f"{self._endpoint}/api" + base_url = ( + self._endpoint if self._env == KaggleEnv.PROD else f"{self._endpoint}/api" + ) return f"{base_url}/v1/{service_name}/{request_name}" diff --git a/kagglesdk/kernels/types/kernels_api_service.py b/kagglesdk/kernels/types/kernels_api_service.py index f7bf268..b01a8ec 100644 --- a/kagglesdk/kernels/types/kernels_api_service.py +++ b/kagglesdk/kernels/types/kernels_api_service.py @@ -591,13 +591,13 @@ class ApiGetKernelRequest(KaggleObject): Attributes: user_name (str) kernel_slug (str) - version_number (int) + version_label (str) """ def __init__(self): self._user_name = "" self._kernel_slug = "" - self._version_number = None + self._version_label = None self._freeze() @property @@ -627,17 +627,17 @@ def kernel_slug(self, kernel_slug: str): self._kernel_slug = kernel_slug @property - def version_number(self) -> int: - return self._version_number or 0 + def version_label(self) -> str: + return self._version_label or "" - @version_number.setter - def version_number(self, version_number: Optional[int]): - if version_number is None: - del self.version_number + @version_label.setter + def version_label(self, version_label: Optional[str]): + if version_label is None: + del self.version_label return - if not isinstance(version_number, int): - raise TypeError('version_number must be of type int') - self._version_number = version_number + if not isinstance(version_label, str): + raise TypeError('version_label must be of type str') + self._version_label = version_label def endpoint(self): path = '/api/v1/kernels/pull' @@ -687,27 +687,31 @@ class ApiGetKernelSessionLogsStreamRequest(KaggleObject): r""" Attributes: kernel_session_id (int) - ID of the notebook session whose live logs should be streamed. wait_for_logs_url_seconds (int) Maximum number of seconds to wait for the upstream log stream URL to be published by the session manager before giving up. The session manager only publishes the URL once the session has been allocated to a worker, so callers may need to wait while the session is queued. Defaults to 60 seconds; capped to 300 seconds. + user_name (str) + kernel_slug (str) + version_label (str) """ def __init__(self): - self._kernel_session_id = 0 + self._kernel_session_id = None self._wait_for_logs_url_seconds = None + self._user_name = None + self._kernel_slug = None + self._version_label = None self._freeze() @property def kernel_session_id(self) -> int: - """ID of the notebook session whose live logs should be streamed.""" - return self._kernel_session_id + return self._kernel_session_id or 0 @kernel_session_id.setter - def kernel_session_id(self, kernel_session_id: int): + def kernel_session_id(self, kernel_session_id: Optional[int]): if kernel_session_id is None: del self.kernel_session_id return @@ -715,6 +719,45 @@ def kernel_session_id(self, kernel_session_id: int): raise TypeError('kernel_session_id must be of type int') self._kernel_session_id = kernel_session_id + @property + def user_name(self) -> str: + return self._user_name or "" + + @user_name.setter + def user_name(self, user_name: Optional[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 or "" + + @kernel_slug.setter + def kernel_slug(self, kernel_slug: Optional[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 version_label(self) -> str: + return self._version_label or "" + + @version_label.setter + def version_label(self, version_label: Optional[str]): + if version_label is None: + del self.version_label + return + if not isinstance(version_label, str): + raise TypeError('version_label must be of type str') + self._version_label = version_label + @property def wait_for_logs_url_seconds(self) -> int: r""" @@ -749,11 +792,13 @@ class ApiGetKernelSessionStatusRequest(KaggleObject): Attributes: user_name (str) kernel_slug (str) + version_label (str) """ def __init__(self): self._user_name = "" self._kernel_slug = "" + self._version_label = None self._freeze() @property @@ -782,6 +827,19 @@ def kernel_slug(self, kernel_slug: str): raise TypeError('kernel_slug must be of type str') self._kernel_slug = kernel_slug + @property + def version_label(self) -> str: + return self._version_label or "" + + @version_label.setter + def version_label(self, version_label: Optional[str]): + if version_label is None: + del self.version_label + return + if not isinstance(version_label, str): + raise TypeError('version_label must be of type str') + self._version_label = version_label + def endpoint(self): path = '/api/v1/kernels/status' return path.format_map(self.to_field_map(self)) @@ -1341,6 +1399,7 @@ class ApiListKernelFilesRequest(KaggleObject): kernel_slug (str) page_size (int) page_token (str) + version_label (str) """ def __init__(self): @@ -1348,6 +1407,7 @@ def __init__(self): self._kernel_slug = "" self._page_size = None self._page_token = None + self._version_label = None self._freeze() @property @@ -1402,6 +1462,19 @@ def page_token(self, page_token: Optional[str]): raise TypeError('page_token must be of type str') self._page_token = page_token + @property + def version_label(self) -> str: + return self._version_label or "" + + @version_label.setter + def version_label(self, version_label: Optional[str]): + if version_label is None: + del self.version_label + return + if not isinstance(version_label, str): + raise TypeError('version_label must be of type str') + self._version_label = version_label + def endpoint(self): path = '/api/v1/kernels/files' return path.format_map(self.to_field_map(self)) @@ -1459,6 +1532,7 @@ class ApiListKernelSessionOutputRequest(KaggleObject): kernel_slug (str) page_size (int) page_token (str) + version_label (str) """ def __init__(self): @@ -1466,6 +1540,7 @@ def __init__(self): self._kernel_slug = "" self._page_size = None self._page_token = None + self._version_label = None self._freeze() @property @@ -1520,6 +1595,19 @@ def page_token(self, page_token: Optional[str]): raise TypeError('page_token must be of type str') self._page_token = page_token + @property + def version_label(self) -> str: + return self._version_label or "" + + @version_label.setter + def version_label(self, version_label: Optional[str]): + if version_label is None: + del self.version_label + return + if not isinstance(version_label, str): + raise TypeError('version_label must be of type str') + self._version_label = version_label + def endpoint(self): path = '/api/v1/kernels/output' return path.format_map(self.to_field_map(self)) @@ -2587,7 +2675,7 @@ def kernelId(self): ApiGetKernelRequest._fields = [ FieldMetadata("userName", "user_name", "_user_name", str, "", PredefinedSerializer()), FieldMetadata("kernelSlug", "kernel_slug", "_kernel_slug", str, "", PredefinedSerializer()), - FieldMetadata("versionNumber", "version_number", "_version_number", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("versionLabel", "version_label", "_version_label", str, None, PredefinedSerializer(), optional=True), ] ApiGetKernelResponse._fields = [ @@ -2596,13 +2684,17 @@ def kernelId(self): ] ApiGetKernelSessionLogsStreamRequest._fields = [ - FieldMetadata("kernelSessionId", "kernel_session_id", "_kernel_session_id", int, 0, PredefinedSerializer()), + FieldMetadata("kernelSessionId", "kernel_session_id", "_kernel_session_id", int, None, PredefinedSerializer(), optional=True), FieldMetadata("waitForLogsUrlSeconds", "wait_for_logs_url_seconds", "_wait_for_logs_url_seconds", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("userName", "user_name", "_user_name", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("kernelSlug", "kernel_slug", "_kernel_slug", str, None, PredefinedSerializer(), optional=True), + FieldMetadata("versionLabel", "version_label", "_version_label", str, None, PredefinedSerializer(), optional=True), ] ApiGetKernelSessionStatusRequest._fields = [ FieldMetadata("userName", "user_name", "_user_name", str, "", PredefinedSerializer()), FieldMetadata("kernelSlug", "kernel_slug", "_kernel_slug", str, "", PredefinedSerializer()), + FieldMetadata("versionLabel", "version_label", "_version_label", str, None, PredefinedSerializer(), optional=True), ] ApiGetKernelSessionStatusResponse._fields = [ @@ -2657,6 +2749,7 @@ def kernelId(self): 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), + FieldMetadata("versionLabel", "version_label", "_version_label", str, None, PredefinedSerializer(), optional=True), ] ApiListKernelFilesResponse._fields = [ @@ -2669,6 +2762,7 @@ def kernelId(self): 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), + FieldMetadata("versionLabel", "version_label", "_version_label", str, None, PredefinedSerializer(), optional=True), ] ApiListKernelSessionOutputResponse._fields = [ diff --git a/kagglesdk/models/types/model_enums.py b/kagglesdk/models/types/model_enums.py index d0b9834..ea1b154 100644 --- a/kagglesdk/models/types/model_enums.py +++ b/kagglesdk/models/types/model_enums.py @@ -41,6 +41,7 @@ class ModelFramework(enum.Enum): MODEL_FRAMEWORK_OTHER = 13 MODEL_FRAMEWORK_TENSOR_RT_LLM = 20 MODEL_FRAMEWORK_TRITON = 22 + MODEL_FRAMEWORK_VLLM = 23 class ModelInstanceType(enum.Enum): MODEL_INSTANCE_TYPE_UNSPECIFIED = 0 diff --git a/kagglesdk/security/types/iam_service.py b/kagglesdk/security/types/iam_service.py index 2b2eb14..88d1523 100644 --- a/kagglesdk/security/types/iam_service.py +++ b/kagglesdk/security/types/iam_service.py @@ -172,7 +172,7 @@ class IamPolicyBinding(KaggleObject): Specifies the principals requesting access for a Kaggle resource. If not specified or empty, revokes access to 'role'. Otherwise, sets the members to the specified value. In other words, overrides existing members - are overriden so if you want to add a new member, you need to specify + are overridden so if you want to add a new member, you need to specify existing members as well. """ @@ -204,7 +204,7 @@ def members(self) -> Optional[List[Optional['Principal']]]: Specifies the principals requesting access for a Kaggle resource. If not specified or empty, revokes access to 'role'. Otherwise, sets the members to the specified value. In other words, overrides existing members - are overriden so if you want to add a new member, you need to specify + are overridden so if you want to add a new member, you need to specify existing members as well. """ return self._members diff --git a/pyproject.toml b/pyproject.toml index b70ea6f..511228c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,7 +19,7 @@ classifiers = [ "Operating System :: OS Independent", ] keywords = ["Kaggle", "API"] -requires-python = ">=3.9" +requires-python = ">=3.11" dependencies = [ "requests", "protobuf",