diff --git a/kagglesdk/__init__.py b/kagglesdk/__init__.py index 977be6a..0001571 100644 --- a/kagglesdk/__init__.py +++ b/kagglesdk/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.1.35" +__version__ = "0.1.36" from kagglesdk.kaggle_client import KaggleClient from kagglesdk.kaggle_creds import KaggleCredentials diff --git a/kagglesdk/agents/services/agents_api_service.py b/kagglesdk/agents/services/agents_api_service.py new file mode 100644 index 0000000..0643d53 --- /dev/null +++ b/kagglesdk/agents/services/agents_api_service.py @@ -0,0 +1,112 @@ +from kagglesdk.agents.types.agents_api_service import ApiCreateHarnessRequest, ApiCreateHarnessVersionRequest, ApiGetHarnessRequest, ApiGetHarnessVersionRequest, ApiHarness, ApiHarnessVersion +from kagglesdk.kaggle_http_client import KaggleHttpClient + +class AgentsApiClient(object): + + def __init__(self, client: KaggleHttpClient): + self._client = client + + def create_harness(self, request: ApiCreateHarnessRequest = None) -> ApiHarness: + r""" + Create a Harness together with its (required) first HarnessVersion. + Admin-only. + + Example: + curl -sSL -u andrewmingwang:local_api_token \ + -X POST http://localhost/api/v1/agents/harnesses/create \ + -H 'Content-Type: application/json' \ + -d '{ + 'harness': { + 'displayName': 'Claude Code', + 'slug': 'claude-code', + 'isPublic': false, + 'type': 'HARNESS_TYPE_HARBOR_CANONICAL', + 'version': { + 'displayName': 'Claude Code v2.1.216', + 'slug': 'claude-code-2.1.216', + 'isPublic': false, + 'harborCanonical': { + 'harborSlug': 'claude-code', + 'harborVersionSlug': '2.1.216' + } + } + } + }' + + Args: + request (ApiCreateHarnessRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateHarnessRequest() + + return self._client.call("agents.AgentsApiService", "CreateHarness", request, ApiHarness) + + def get_harness(self, request: ApiGetHarnessRequest = None) -> ApiHarness: + r""" + Get a Harness by id. Admin-only. + + Example: + curl -sSL -u andrewmingwang:local_api_token \ + http://localhost/api/v1/agents/harnesses/1 + + Args: + request (ApiGetHarnessRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetHarnessRequest() + + return self._client.call("agents.AgentsApiService", "GetHarness", request, ApiHarness) + + def create_harness_version(self, request: ApiCreateHarnessVersionRequest = None) -> ApiHarnessVersion: + r""" + Create an additional HarnessVersion under an existing Harness. + Admin-only. + + Example: + curl -sSL -u andrewmingwang:local_api_token \ + -X POST http://localhost/api/v1/agents/harnesses/versions/create \ + -H 'Content-Type: application/json' \ + -d '{ + 'harnessVersion': { + 'harnessId': 1, + 'displayName': 'Claude Code v2.1.217', + 'slug': 'claude-code-2.1.217', + 'isPublic': false, + 'harborCanonical': { + 'harborSlug': 'claude-code', + 'harborVersionSlug': '2.1.217' + } + } + }' + + Args: + request (ApiCreateHarnessVersionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateHarnessVersionRequest() + + return self._client.call("agents.AgentsApiService", "CreateHarnessVersion", request, ApiHarnessVersion) + + def get_harness_version(self, request: ApiGetHarnessVersionRequest = None) -> ApiHarnessVersion: + r""" + Get a HarnessVersion by id. Admin-only. + + Example: + curl -sSL -u andrewmingwang:local_api_token \ + http://localhost/api/v1/agents/harnesses/versions/1 + + Args: + request (ApiGetHarnessVersionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetHarnessVersionRequest() + + return self._client.call("agents.AgentsApiService", "GetHarnessVersion", request, ApiHarnessVersion) diff --git a/kagglesdk/agents/types/agent_enums.py b/kagglesdk/agents/types/agent_enums.py new file mode 100644 index 0000000..e2271d4 --- /dev/null +++ b/kagglesdk/agents/types/agent_enums.py @@ -0,0 +1,16 @@ +import enum + +class HarnessType(enum.Enum): + r""" + The implementation of a Harness. This value + the harness slug represent the + concrete implementation used to execute an agent against Kaggle. + Saved to the DB. Do not modify existing values. + """ + HARNESS_TYPE_UNSPECIFIED = 0 + HARNESS_TYPE_HARBOR_CANONICAL = 1 + """A canonical harbor agent, executed via the harbor --agent flag.""" + HARNESS_TYPE_KERNEL_GAME_ARENA = 2 + """A kernel-backed Game Arena harness.""" + HARNESS_TYPE_KERNEL_COMPS_BENCH = 3 + """A kernel-backed competitions benchmark harness.""" + diff --git a/kagglesdk/agents/types/agents_api_service.py b/kagglesdk/agents/types/agents_api_service.py new file mode 100644 index 0000000..f71120b --- /dev/null +++ b/kagglesdk/agents/types/agents_api_service.py @@ -0,0 +1,617 @@ +from kagglesdk.agents.types.agent_enums import HarnessType +from kagglesdk.kaggle_object import * +from kagglesdk.users.types.legacy_organizations_service import OrganizationCard +from typing import Optional + +class ApiCreateHarnessRequest(KaggleObject): + r""" + Attributes: + harness (ApiHarness) + The Harness to create. Must include version. + """ + + def __init__(self): + self._harness = None + self._freeze() + + @property + def harness(self) -> Optional['ApiHarness']: + """The Harness to create. Must include version.""" + return self._harness + + @harness.setter + def harness(self, harness: Optional['ApiHarness']): + if harness is None: + del self.harness + return + if not isinstance(harness, ApiHarness): + raise TypeError('harness must be of type ApiHarness') + self._harness = harness + + def endpoint(self): + path = '/api/v1/agents/harnesses/create' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + + @staticmethod + def body_fields(): + return '*' + + +class ApiCreateHarnessVersionRequest(KaggleObject): + r""" + Attributes: + harness_version (ApiHarnessVersion) + """ + + def __init__(self): + self._harness_version = None + self._freeze() + + @property + def harness_version(self) -> Optional['ApiHarnessVersion']: + return self._harness_version + + @harness_version.setter + def harness_version(self, harness_version: Optional['ApiHarnessVersion']): + if harness_version is None: + del self.harness_version + return + if not isinstance(harness_version, ApiHarnessVersion): + raise TypeError('harness_version must be of type ApiHarnessVersion') + self._harness_version = harness_version + + def endpoint(self): + path = '/api/v1/agents/harnesses/versions/create' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + + @staticmethod + def body_fields(): + return '*' + + +class ApiGetHarnessRequest(KaggleObject): + r""" + Attributes: + id (int) + Id of the Harness to fetch. + """ + + def __init__(self): + self._id = 0 + self._freeze() + + @property + def id(self) -> int: + """Id of the Harness to fetch.""" + 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 + + def endpoint(self): + path = '/api/v1/agents/harnesses/{id}' + return path.format_map(self.to_field_map(self)) + + @staticmethod + def endpoint_path(): + return '/api/v1/agents/harnesses/{id}' + + +class ApiGetHarnessVersionRequest(KaggleObject): + r""" + Attributes: + id (int) + Id of the HarnessVersion to fetch. + """ + + def __init__(self): + self._id = 0 + self._freeze() + + @property + def id(self) -> int: + """Id of the HarnessVersion to fetch.""" + 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 + + def endpoint(self): + path = '/api/v1/agents/harnesses/versions/{id}' + return path.format_map(self.to_field_map(self)) + + @staticmethod + def endpoint_path(): + return '/api/v1/agents/harnesses/versions/{id}' + + +class ApiHarborCanonicalHarnessVersion(KaggleObject): + r""" + API equivalent of HarborCanonicalHarnessVersion. + + Attributes: + harbor_slug (str) + harbor_version_slug (str) + """ + + def __init__(self): + self._harbor_slug = "" + self._harbor_version_slug = "" + self._freeze() + + @property + def harbor_slug(self) -> str: + return self._harbor_slug + + @harbor_slug.setter + def harbor_slug(self, harbor_slug: str): + if harbor_slug is None: + del self.harbor_slug + return + if not isinstance(harbor_slug, str): + raise TypeError('harbor_slug must be of type str') + self._harbor_slug = harbor_slug + + @property + def harbor_version_slug(self) -> str: + return self._harbor_version_slug + + @harbor_version_slug.setter + def harbor_version_slug(self, harbor_version_slug: str): + if harbor_version_slug is None: + del self.harbor_version_slug + return + if not isinstance(harbor_version_slug, str): + raise TypeError('harbor_version_slug must be of type str') + self._harbor_version_slug = harbor_version_slug + + +class ApiHarness(KaggleObject): + r""" + API equivalent of Harness from agent_types.proto. + + Attributes: + id (int) + Output-only on create. + display_name (str) + slug (str) + is_public (bool) + organization_id (int) + type (HarnessType) + version (ApiHarnessVersion) + Required on CreateHarness — a Harness is unusable without a version. + On read responses this holds the latest / relevant HarnessVersion. + organization (OrganizationCard) + The associated Organization, if any. Ignored on create and update. + """ + + def __init__(self): + self._id = 0 + self._display_name = "" + self._slug = "" + self._is_public = False + self._organization_id = None + self._type = HarnessType.HARNESS_TYPE_UNSPECIFIED + self._version = None + self._organization = None + self._freeze() + + @property + def id(self) -> int: + """Output-only on create.""" + 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 display_name(self) -> str: + return self._display_name + + @display_name.setter + def display_name(self, display_name: str): + if display_name is None: + del self.display_name + return + if not isinstance(display_name, str): + raise TypeError('display_name must be of type str') + self._display_name = display_name + + @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_public(self) -> bool: + return self._is_public + + @is_public.setter + def is_public(self, is_public: bool): + if is_public is None: + del self.is_public + return + if not isinstance(is_public, bool): + raise TypeError('is_public must be of type bool') + self._is_public = is_public + + @property + def organization_id(self) -> int: + return self._organization_id or 0 + + @organization_id.setter + def organization_id(self, organization_id: Optional[int]): + if organization_id is None: + del self.organization_id + return + if not isinstance(organization_id, int): + raise TypeError('organization_id must be of type int') + self._organization_id = organization_id + + @property + def type(self) -> 'HarnessType': + return self._type + + @type.setter + def type(self, type: 'HarnessType'): + if type is None: + del self.type + return + if not isinstance(type, HarnessType): + raise TypeError('type must be of type HarnessType') + self._type = type + + @property + def version(self) -> Optional['ApiHarnessVersion']: + r""" + Required on CreateHarness — a Harness is unusable without a version. + On read responses this holds the latest / relevant HarnessVersion. + """ + return self._version + + @version.setter + def version(self, version: Optional['ApiHarnessVersion']): + if version is None: + del self.version + return + if not isinstance(version, ApiHarnessVersion): + raise TypeError('version must be of type ApiHarnessVersion') + self._version = version + + @property + def organization(self) -> Optional['OrganizationCard']: + """The associated Organization, if any. Ignored on create and update.""" + return self._organization or None + + @organization.setter + def organization(self, organization: Optional[Optional['OrganizationCard']]): + if organization is None: + del self.organization + return + if not isinstance(organization, OrganizationCard): + raise TypeError('organization must be of type OrganizationCard') + self._organization = organization + + +class ApiHarnessVersion(KaggleObject): + r""" + API equivalent of HarnessVersion from agent_types.proto. + + Attributes: + id (int) + Output-only on create. + display_name (str) + slug (str) + is_public (bool) + harness_id (int) + Required for standalone CreateHarnessVersion; ignored when nested in + ApiHarness.version on CreateHarness. + harbor_canonical (ApiHarborCanonicalHarnessVersion) + kernel_game_arena (ApiKernelGameArenaHarnessVersion) + kernel_comps_bench (ApiKernelCompsBenchHarnessVersion) + organization (OrganizationCard) + Fields from the parent Harness for convenience. Ignored on create and + update. + type (HarnessType) + """ + + def __init__(self): + self._id = 0 + self._display_name = "" + self._slug = "" + self._is_public = False + self._harness_id = 0 + self._harbor_canonical = None + self._kernel_game_arena = None + self._kernel_comps_bench = None + self._organization = None + self._type = HarnessType.HARNESS_TYPE_UNSPECIFIED + self._freeze() + + @property + def id(self) -> int: + """Output-only on create.""" + 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 display_name(self) -> str: + return self._display_name + + @display_name.setter + def display_name(self, display_name: str): + if display_name is None: + del self.display_name + return + if not isinstance(display_name, str): + raise TypeError('display_name must be of type str') + self._display_name = display_name + + @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_public(self) -> bool: + return self._is_public + + @is_public.setter + def is_public(self, is_public: bool): + if is_public is None: + del self.is_public + return + if not isinstance(is_public, bool): + raise TypeError('is_public must be of type bool') + self._is_public = is_public + + @property + def harness_id(self) -> int: + r""" + Required for standalone CreateHarnessVersion; ignored when nested in + ApiHarness.version on CreateHarness. + """ + return self._harness_id + + @harness_id.setter + def harness_id(self, harness_id: int): + if harness_id is None: + del self.harness_id + return + if not isinstance(harness_id, int): + raise TypeError('harness_id must be of type int') + self._harness_id = harness_id + + @property + def harbor_canonical(self) -> Optional['ApiHarborCanonicalHarnessVersion']: + return self._harbor_canonical or None + + @harbor_canonical.setter + def harbor_canonical(self, harbor_canonical: Optional['ApiHarborCanonicalHarnessVersion']): + if harbor_canonical is None: + del self.harbor_canonical + return + if not isinstance(harbor_canonical, ApiHarborCanonicalHarnessVersion): + raise TypeError('harbor_canonical must be of type ApiHarborCanonicalHarnessVersion') + del self.kernel_game_arena + del self.kernel_comps_bench + self._harbor_canonical = harbor_canonical + + @property + def kernel_game_arena(self) -> Optional['ApiKernelGameArenaHarnessVersion']: + return self._kernel_game_arena or None + + @kernel_game_arena.setter + def kernel_game_arena(self, kernel_game_arena: Optional['ApiKernelGameArenaHarnessVersion']): + if kernel_game_arena is None: + del self.kernel_game_arena + return + if not isinstance(kernel_game_arena, ApiKernelGameArenaHarnessVersion): + raise TypeError('kernel_game_arena must be of type ApiKernelGameArenaHarnessVersion') + del self.harbor_canonical + del self.kernel_comps_bench + self._kernel_game_arena = kernel_game_arena + + @property + def kernel_comps_bench(self) -> Optional['ApiKernelCompsBenchHarnessVersion']: + return self._kernel_comps_bench or None + + @kernel_comps_bench.setter + def kernel_comps_bench(self, kernel_comps_bench: Optional['ApiKernelCompsBenchHarnessVersion']): + if kernel_comps_bench is None: + del self.kernel_comps_bench + return + if not isinstance(kernel_comps_bench, ApiKernelCompsBenchHarnessVersion): + raise TypeError('kernel_comps_bench must be of type ApiKernelCompsBenchHarnessVersion') + del self.harbor_canonical + del self.kernel_game_arena + self._kernel_comps_bench = kernel_comps_bench + + @property + def organization(self) -> Optional['OrganizationCard']: + r""" + Fields from the parent Harness for convenience. Ignored on create and + update. + """ + return self._organization or None + + @organization.setter + def organization(self, organization: Optional[Optional['OrganizationCard']]): + if organization is None: + del self.organization + return + if not isinstance(organization, OrganizationCard): + raise TypeError('organization must be of type OrganizationCard') + self._organization = organization + + @property + def type(self) -> 'HarnessType': + return self._type + + @type.setter + def type(self, type: 'HarnessType'): + if type is None: + del self.type + return + if not isinstance(type, HarnessType): + raise TypeError('type must be of type HarnessType') + self._type = type + + +class ApiKernelCompsBenchHarnessVersion(KaggleObject): + r""" + API equivalent of KernelCompsBenchHarnessVersion. + + Attributes: + kernel_session_id (int) + """ + + def __init__(self): + self._kernel_session_id = 0 + self._freeze() + + @property + def kernel_session_id(self) -> int: + return self._kernel_session_id + + @kernel_session_id.setter + def kernel_session_id(self, kernel_session_id: int): + if kernel_session_id is None: + del self.kernel_session_id + return + if not isinstance(kernel_session_id, int): + raise TypeError('kernel_session_id must be of type int') + self._kernel_session_id = kernel_session_id + + +class ApiKernelGameArenaHarnessVersion(KaggleObject): + r""" + API equivalent of KernelGameArenaHarnessVersion. + + Attributes: + kernel_session_id (int) + """ + + def __init__(self): + self._kernel_session_id = 0 + self._freeze() + + @property + def kernel_session_id(self) -> int: + return self._kernel_session_id + + @kernel_session_id.setter + def kernel_session_id(self, kernel_session_id: int): + if kernel_session_id is None: + del self.kernel_session_id + return + if not isinstance(kernel_session_id, int): + raise TypeError('kernel_session_id must be of type int') + self._kernel_session_id = kernel_session_id + + +ApiCreateHarnessRequest._fields = [ + FieldMetadata("harness", "harness", "_harness", ApiHarness, None, KaggleObjectSerializer()), +] + +ApiCreateHarnessVersionRequest._fields = [ + FieldMetadata("harnessVersion", "harness_version", "_harness_version", ApiHarnessVersion, None, KaggleObjectSerializer()), +] + +ApiGetHarnessRequest._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), +] + +ApiGetHarnessVersionRequest._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), +] + +ApiHarborCanonicalHarnessVersion._fields = [ + FieldMetadata("harborSlug", "harbor_slug", "_harbor_slug", str, "", PredefinedSerializer()), + FieldMetadata("harborVersionSlug", "harbor_version_slug", "_harbor_version_slug", str, "", PredefinedSerializer()), +] + +ApiHarness._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("displayName", "display_name", "_display_name", str, "", PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("isPublic", "is_public", "_is_public", bool, False, PredefinedSerializer()), + FieldMetadata("organizationId", "organization_id", "_organization_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("type", "type", "_type", HarnessType, HarnessType.HARNESS_TYPE_UNSPECIFIED, EnumSerializer()), + FieldMetadata("version", "version", "_version", ApiHarnessVersion, None, KaggleObjectSerializer()), + FieldMetadata("organization", "organization", "_organization", OrganizationCard, None, KaggleObjectSerializer(), optional=True), +] + +ApiHarnessVersion._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("displayName", "display_name", "_display_name", str, "", PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("isPublic", "is_public", "_is_public", bool, False, PredefinedSerializer()), + FieldMetadata("harnessId", "harness_id", "_harness_id", int, 0, PredefinedSerializer()), + FieldMetadata("harborCanonical", "harbor_canonical", "_harbor_canonical", ApiHarborCanonicalHarnessVersion, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("kernelGameArena", "kernel_game_arena", "_kernel_game_arena", ApiKernelGameArenaHarnessVersion, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("kernelCompsBench", "kernel_comps_bench", "_kernel_comps_bench", ApiKernelCompsBenchHarnessVersion, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("organization", "organization", "_organization", OrganizationCard, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("type", "type", "_type", HarnessType, HarnessType.HARNESS_TYPE_UNSPECIFIED, EnumSerializer()), +] + +ApiKernelCompsBenchHarnessVersion._fields = [ + FieldMetadata("kernelSessionId", "kernel_session_id", "_kernel_session_id", int, 0, PredefinedSerializer()), +] + +ApiKernelGameArenaHarnessVersion._fields = [ + FieldMetadata("kernelSessionId", "kernel_session_id", "_kernel_session_id", int, 0, PredefinedSerializer()), +] + diff --git a/kagglesdk/benchmarks/services/benchmarks_api_service.py b/kagglesdk/benchmarks/services/benchmarks_api_service.py index edab594..498004b 100644 --- a/kagglesdk/benchmarks/services/benchmarks_api_service.py +++ b/kagglesdk/benchmarks/services/benchmarks_api_service.py @@ -1,4 +1,4 @@ -from kagglesdk.benchmarks.types.benchmarks_api_service import ApiBenchmarkLeaderboard, ApiGetBenchmarkLeaderboardRequest, ApiListBenchmarkModelsRequest, ApiListBenchmarkModelsResponse +from kagglesdk.benchmarks.types.benchmarks_api_service import ApiBenchmarkLeaderboard, ApiBenchmarkModelVersionConfig, ApiCreateBenchmarkModelVersionConfigRequest, ApiGetBenchmarkLeaderboardRequest, ApiGetBenchmarkModelVersionConfigRequest, ApiListBenchmarkModelsRequest, ApiListBenchmarkModelsResponse, ApiListBenchmarkModelVersionConfigsRequest, ApiListBenchmarkModelVersionConfigsResponse from kagglesdk.kaggle_http_client import KaggleHttpClient class BenchmarksApiClient(object): @@ -6,6 +6,78 @@ class BenchmarksApiClient(object): def __init__(self, client: KaggleHttpClient): self._client = client + def create_benchmark_model_version_config(self, request: ApiCreateBenchmarkModelVersionConfigRequest = None) -> ApiBenchmarkModelVersionConfig: + r""" + Create a fully-configured, runnable BenchmarkModelVersion: pins the + exact sampling/decoding parameters (temperature, top-p, reasoning effort, + etc.) used when invoking the parent BenchmarkModelVersion. + + Example: + curl -sSL -u andrewmingwang:local_api_token \ + -X POST + http://localhost/api/v1/benchmarks/models/versions/configs/create \ + -H 'Content-Type: application/json' \ + -d '{ + 'config': { + 'benchmarkModelVersionId': 1, + 'displayName': 'Claude Opus 4.8 High Reasoning Effort', + 'slug': 'claude-opus-4.8-high-reasoning-effort', + 'reasoningEffort': 'high', + 'temperature': 1.0, + 'topP': 1.0, + 'maxOutputTokens': 8192 + } + }' + + Args: + request (ApiCreateBenchmarkModelVersionConfigRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiCreateBenchmarkModelVersionConfigRequest() + + return self._client.call("benchmarks.BenchmarksApiService", "CreateBenchmarkModelVersionConfig", request, ApiBenchmarkModelVersionConfig) + + def get_benchmark_model_version_config(self, request: ApiGetBenchmarkModelVersionConfigRequest = None) -> ApiBenchmarkModelVersionConfig: + r""" + Get a BenchmarkModelVersionConfig by id. + + Example: + curl -sSL -u andrewmingwang:local_api_token \ + http://localhost/api/v1/benchmarks/models/versions/configs/1 + + Args: + request (ApiGetBenchmarkModelVersionConfigRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiGetBenchmarkModelVersionConfigRequest() + + return self._client.call("benchmarks.BenchmarksApiService", "GetBenchmarkModelVersionConfig", request, ApiBenchmarkModelVersionConfig) + + def list_benchmark_model_version_configs(self, request: ApiListBenchmarkModelVersionConfigsRequest = None) -> ApiListBenchmarkModelVersionConfigsResponse: + r""" + List BenchmarkModelVersionConfigs, optionally filtered by parent + BenchmarkModelVersion id(s). Paginated. + + Example: + curl -sSL -u andrewmingwang:local_api_token \ + -G http://localhost/api/v1/benchmarks/models/versions/configs/list \ + --data-urlencode 'benchmarkModelVersionIds=1' \ + --data-urlencode 'pageSize=20' + + Args: + request (ApiListBenchmarkModelVersionConfigsRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiListBenchmarkModelVersionConfigsRequest() + + return self._client.call("benchmarks.BenchmarksApiService", "ListBenchmarkModelVersionConfigs", request, ApiListBenchmarkModelVersionConfigsResponse) + def get_benchmark_leaderboard(self, request: ApiGetBenchmarkLeaderboardRequest = None) -> ApiBenchmarkLeaderboard: r""" Args: diff --git a/kagglesdk/benchmarks/types/benchmark_tasks_api_service.py b/kagglesdk/benchmarks/types/benchmark_tasks_api_service.py index 94fea04..e69a42b 100644 --- a/kagglesdk/benchmarks/types/benchmark_tasks_api_service.py +++ b/kagglesdk/benchmarks/types/benchmark_tasks_api_service.py @@ -2,7 +2,7 @@ from kagglesdk.benchmarks.types.benchmark_enums import BenchmarkTaskRunState, BenchmarkTaskVersionCreationState, BenchmarkTaskVersionSource from kagglesdk.benchmarks.types.benchmark_task_run_service import BatchScheduleBenchmarkModelVersionResult from kagglesdk.benchmarks.types.benchmark_task_service import EnvVariable, UserSecret -from kagglesdk.benchmarks.types.benchmark_types import BenchmarkTaskOptions +from kagglesdk.benchmarks.types.benchmark_types import BenchmarkTaskKaggleDatasetsDefinition, BenchmarkTaskOptions from kagglesdk.kaggle_object import * from typing import List, Optional @@ -1213,12 +1213,14 @@ class BenchmarkTaskDefinition(KaggleObject): notebook (BenchmarkTaskNotebookDefinition) docker_image (BenchmarkTaskDockerImageDefinition) harbor_git (BenchmarkTaskGitDefinition) + harbor_kaggle_datasets (BenchmarkTaskKaggleDatasetsDefinition) """ def __init__(self): self._notebook = None self._docker_image = None self._harbor_git = None + self._harbor_kaggle_datasets = None self._freeze() @property @@ -1234,6 +1236,7 @@ def notebook(self, notebook: Optional['BenchmarkTaskNotebookDefinition']): raise TypeError('notebook must be of type BenchmarkTaskNotebookDefinition') del self.docker_image del self.harbor_git + del self.harbor_kaggle_datasets self._notebook = notebook @property @@ -1249,6 +1252,7 @@ def docker_image(self, docker_image: Optional['BenchmarkTaskDockerImageDefinitio raise TypeError('docker_image must be of type BenchmarkTaskDockerImageDefinition') del self.notebook del self.harbor_git + del self.harbor_kaggle_datasets self._docker_image = docker_image @property @@ -1264,8 +1268,25 @@ def harbor_git(self, harbor_git: Optional['BenchmarkTaskGitDefinition']): raise TypeError('harbor_git must be of type BenchmarkTaskGitDefinition') del self.notebook del self.docker_image + del self.harbor_kaggle_datasets self._harbor_git = harbor_git + @property + def harbor_kaggle_datasets(self) -> Optional['BenchmarkTaskKaggleDatasetsDefinition']: + return self._harbor_kaggle_datasets or None + + @harbor_kaggle_datasets.setter + def harbor_kaggle_datasets(self, harbor_kaggle_datasets: Optional['BenchmarkTaskKaggleDatasetsDefinition']): + if harbor_kaggle_datasets is None: + del self.harbor_kaggle_datasets + return + if not isinstance(harbor_kaggle_datasets, BenchmarkTaskKaggleDatasetsDefinition): + raise TypeError('harbor_kaggle_datasets must be of type BenchmarkTaskKaggleDatasetsDefinition') + del self.notebook + del self.docker_image + del self.harbor_git + self._harbor_kaggle_datasets = harbor_kaggle_datasets + class BenchmarkTaskDockerImageDefinition(KaggleObject): r""" @@ -1632,6 +1653,7 @@ class BenchmarkTaskNotebookDefinition(KaggleObject): FieldMetadata("notebook", "notebook", "_notebook", BenchmarkTaskNotebookDefinition, None, KaggleObjectSerializer(), optional=True), FieldMetadata("dockerImage", "docker_image", "_docker_image", BenchmarkTaskDockerImageDefinition, None, KaggleObjectSerializer(), optional=True), FieldMetadata("harborGit", "harbor_git", "_harbor_git", BenchmarkTaskGitDefinition, None, KaggleObjectSerializer(), optional=True), + FieldMetadata("harborKaggleDatasets", "harbor_kaggle_datasets", "_harbor_kaggle_datasets", BenchmarkTaskKaggleDatasetsDefinition, None, KaggleObjectSerializer(), optional=True), ] BenchmarkTaskDockerImageDefinition._fields = [ diff --git a/kagglesdk/benchmarks/types/benchmark_types.py b/kagglesdk/benchmarks/types/benchmark_types.py index 045ed7c..4c6fcea 100644 --- a/kagglesdk/benchmarks/types/benchmark_types.py +++ b/kagglesdk/benchmarks/types/benchmark_types.py @@ -683,6 +683,155 @@ def evaluation_date(self, evaluation_date: Optional[datetime]): self._evaluation_date = evaluation_date +class BenchmarkTaskKaggleDatasetsDefinition(KaggleObject): + r""" + Task definition and asset mounts for a Harbor task whose definition and data + live in mounted Kaggle datasets instead of a git clone. Dataset references + are pinned to an immutable version for reproducibility. + + Attributes: + definition_source (BenchmarkTaskKaggleDatasetsDefinition.DefinitionSource) + mounts (BenchmarkTaskKaggleDatasetsDefinition.DatasetMount) + """ + + class DatasetMount(KaggleObject): + r""" + Attributes: + dataset_version_slug (str) + 'owner/slug/versions/N' — the version segment is REQUIRED for + reproducibility. Requests without an explicit version are rejected. + mount_path (str) + Absolute path inside the container where the dataset is mounted. Callers + pick this so tasks can locate their data anywhere. Unique across the + mount list; must not shadow the task-definition mount. + """ + + def __init__(self): + self._dataset_version_slug = "" + self._mount_path = "" + self._freeze() + + @property + def dataset_version_slug(self) -> str: + r""" + 'owner/slug/versions/N' — the version segment is REQUIRED for + reproducibility. Requests without an explicit version are rejected. + """ + return self._dataset_version_slug + + @dataset_version_slug.setter + def dataset_version_slug(self, dataset_version_slug: str): + if dataset_version_slug is None: + del self.dataset_version_slug + return + if not isinstance(dataset_version_slug, str): + raise TypeError('dataset_version_slug must be of type str') + self._dataset_version_slug = dataset_version_slug + + @property + def mount_path(self) -> str: + r""" + Absolute path inside the container where the dataset is mounted. Callers + pick this so tasks can locate their data anywhere. Unique across the + mount list; must not shadow the task-definition mount. + """ + return self._mount_path + + @mount_path.setter + def mount_path(self, mount_path: str): + if mount_path is None: + del self.mount_path + return + if not isinstance(mount_path, str): + raise TypeError('mount_path must be of type str') + self._mount_path = mount_path + + + class DefinitionSource(KaggleObject): + r""" + Attributes: + dataset_version_slug (str) + 'owner/slug/versions/N' — the version segment is REQUIRED for + reproducibility. Requests without an explicit version are rejected. + sub_path (str) + Sub-directory within the dataset containing task.toml. Empty means the + dataset root. + """ + + def __init__(self): + self._dataset_version_slug = "" + self._sub_path = "" + self._freeze() + + @property + def dataset_version_slug(self) -> str: + r""" + 'owner/slug/versions/N' — the version segment is REQUIRED for + reproducibility. Requests without an explicit version are rejected. + """ + return self._dataset_version_slug + + @dataset_version_slug.setter + def dataset_version_slug(self, dataset_version_slug: str): + if dataset_version_slug is None: + del self.dataset_version_slug + return + if not isinstance(dataset_version_slug, str): + raise TypeError('dataset_version_slug must be of type str') + self._dataset_version_slug = dataset_version_slug + + @property + def sub_path(self) -> str: + r""" + Sub-directory within the dataset containing task.toml. Empty means the + dataset root. + """ + return self._sub_path + + @sub_path.setter + def sub_path(self, sub_path: str): + if sub_path is None: + del self.sub_path + return + if not isinstance(sub_path, str): + raise TypeError('sub_path must be of type str') + self._sub_path = sub_path + + + def __init__(self): + self._definition_source = None + self._mounts = [] + self._freeze() + + @property + def definition_source(self) -> Optional['BenchmarkTaskKaggleDatasetsDefinition.DefinitionSource']: + return self._definition_source + + @definition_source.setter + def definition_source(self, definition_source: Optional['BenchmarkTaskKaggleDatasetsDefinition.DefinitionSource']): + if definition_source is None: + del self.definition_source + return + if not isinstance(definition_source, BenchmarkTaskKaggleDatasetsDefinition.DefinitionSource): + raise TypeError('definition_source must be of type BenchmarkTaskKaggleDatasetsDefinition.DefinitionSource') + self._definition_source = definition_source + + @property + def mounts(self) -> Optional[List[Optional['BenchmarkTaskKaggleDatasetsDefinition.DatasetMount']]]: + return self._mounts + + @mounts.setter + def mounts(self, mounts: Optional[List[Optional['BenchmarkTaskKaggleDatasetsDefinition.DatasetMount']]]): + if mounts is None: + del self.mounts + return + if not isinstance(mounts, list): + raise TypeError('mounts must be of type list') + if not all([isinstance(t, BenchmarkTaskKaggleDatasetsDefinition.DatasetMount) for t in mounts]): + raise TypeError('mounts must contain only items of type BenchmarkTaskKaggleDatasetsDefinition.DatasetMount') + self._mounts = mounts + + class BenchmarkTaskOptions(KaggleObject): r""" Options persisted on a BenchmarkTaskVersion. Currently only carries @@ -916,6 +1065,21 @@ def minus(self, minus: float): FieldMetadata("taskVersionId", "task_version_id", "_task_version_id", int, None, PredefinedSerializer(), optional=True), ] +BenchmarkTaskKaggleDatasetsDefinition.DatasetMount._fields = [ + FieldMetadata("datasetVersionSlug", "dataset_version_slug", "_dataset_version_slug", str, "", PredefinedSerializer()), + FieldMetadata("mountPath", "mount_path", "_mount_path", str, "", PredefinedSerializer()), +] + +BenchmarkTaskKaggleDatasetsDefinition.DefinitionSource._fields = [ + FieldMetadata("datasetVersionSlug", "dataset_version_slug", "_dataset_version_slug", str, "", PredefinedSerializer()), + FieldMetadata("subPath", "sub_path", "_sub_path", str, "", PredefinedSerializer()), +] + +BenchmarkTaskKaggleDatasetsDefinition._fields = [ + FieldMetadata("definitionSource", "definition_source", "_definition_source", BenchmarkTaskKaggleDatasetsDefinition.DefinitionSource, None, KaggleObjectSerializer()), + FieldMetadata("mounts", "mounts", "_mounts", BenchmarkTaskKaggleDatasetsDefinition.DatasetMount, [], ListSerializer(KaggleObjectSerializer())), +] + BenchmarkTaskOptions._fields = [ FieldMetadata("datasetDataSources", "dataset_data_sources", "_dataset_data_sources", str, [], ListSerializer(PredefinedSerializer())), ] diff --git a/kagglesdk/benchmarks/types/benchmarks_api_service.py b/kagglesdk/benchmarks/types/benchmarks_api_service.py index 0d0d58c..cfc3645 100644 --- a/kagglesdk/benchmarks/types/benchmarks_api_service.py +++ b/kagglesdk/benchmarks/types/benchmarks_api_service.py @@ -154,6 +154,241 @@ def rows(self, rows: Optional[List[Optional['ApiBenchmarkLeaderboard.Leaderboard self._rows = rows +class ApiBenchmarkModelVersionConfig(KaggleObject): + r""" + API equivalent of BenchmarkModelVersionConfig from benchmark_types.proto: + a fully-configured, runnable BenchmarkModelVersion (which LLM + all its + sampling parameters). + + Attributes: + id (int) + Output-only on create. + benchmark_model_version_id (int) + The BenchmarkModelVersion (i.e. the LLM) being configured. + display_name (str) + ex: 'Claude Opus 4.8 High Reasoning Effort'. + slug (str) + ex: 'claude-opus-4.8-high-reasoning-effort'. + reasoning_effort (str) + temperature (float) + top_p (float) + max_output_tokens (int) + top_k (int) + Only supported by some providers (e.g. Anthropic, Google). + seed (int) + Only supported by some providers. + thinking_budget (int) + Alternative to reasoning_effort for providers that expose a token budget + directly. + """ + + def __init__(self): + self._id = 0 + self._benchmark_model_version_id = 0 + self._display_name = "" + self._slug = "" + self._reasoning_effort = "" + self._temperature = 0.0 + self._top_p = 0.0 + self._max_output_tokens = 0 + self._top_k = None + self._seed = None + self._thinking_budget = None + self._freeze() + + @property + def id(self) -> int: + """Output-only on create.""" + 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 benchmark_model_version_id(self) -> int: + """The BenchmarkModelVersion (i.e. the LLM) being configured.""" + return self._benchmark_model_version_id + + @benchmark_model_version_id.setter + def benchmark_model_version_id(self, benchmark_model_version_id: int): + if benchmark_model_version_id is None: + del self.benchmark_model_version_id + return + if not isinstance(benchmark_model_version_id, int): + raise TypeError('benchmark_model_version_id must be of type int') + self._benchmark_model_version_id = benchmark_model_version_id + + @property + def display_name(self) -> str: + """ex: 'Claude Opus 4.8 High Reasoning Effort'.""" + return self._display_name + + @display_name.setter + def display_name(self, display_name: str): + if display_name is None: + del self.display_name + return + if not isinstance(display_name, str): + raise TypeError('display_name must be of type str') + self._display_name = display_name + + @property + def slug(self) -> str: + """ex: 'claude-opus-4.8-high-reasoning-effort'.""" + 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 reasoning_effort(self) -> str: + return self._reasoning_effort + + @reasoning_effort.setter + def reasoning_effort(self, reasoning_effort: str): + if reasoning_effort is None: + del self.reasoning_effort + return + if not isinstance(reasoning_effort, str): + raise TypeError('reasoning_effort must be of type str') + self._reasoning_effort = reasoning_effort + + @property + def temperature(self) -> float: + return self._temperature + + @temperature.setter + def temperature(self, temperature: float): + if temperature is None: + del self.temperature + return + if not isinstance(temperature, float): + raise TypeError('temperature must be of type float') + self._temperature = temperature + + @property + def top_p(self) -> float: + return self._top_p + + @top_p.setter + def top_p(self, top_p: float): + if top_p is None: + del self.top_p + return + if not isinstance(top_p, float): + raise TypeError('top_p must be of type float') + self._top_p = top_p + + @property + def max_output_tokens(self) -> int: + return self._max_output_tokens + + @max_output_tokens.setter + def max_output_tokens(self, max_output_tokens: int): + if max_output_tokens is None: + del self.max_output_tokens + return + if not isinstance(max_output_tokens, int): + raise TypeError('max_output_tokens must be of type int') + self._max_output_tokens = max_output_tokens + + @property + def top_k(self) -> int: + """Only supported by some providers (e.g. Anthropic, Google).""" + return self._top_k or 0 + + @top_k.setter + def top_k(self, top_k: Optional[int]): + if top_k is None: + del self.top_k + return + if not isinstance(top_k, int): + raise TypeError('top_k must be of type int') + self._top_k = top_k + + @property + def seed(self) -> int: + """Only supported by some providers.""" + return self._seed or 0 + + @seed.setter + def seed(self, seed: Optional[int]): + if seed is None: + del self.seed + return + if not isinstance(seed, int): + raise TypeError('seed must be of type int') + self._seed = seed + + @property + def thinking_budget(self) -> int: + r""" + Alternative to reasoning_effort for providers that expose a token budget + directly. + """ + return self._thinking_budget or 0 + + @thinking_budget.setter + def thinking_budget(self, thinking_budget: Optional[int]): + if thinking_budget is None: + del self.thinking_budget + return + if not isinstance(thinking_budget, int): + raise TypeError('thinking_budget must be of type int') + self._thinking_budget = thinking_budget + + +class ApiCreateBenchmarkModelVersionConfigRequest(KaggleObject): + r""" + Attributes: + config (ApiBenchmarkModelVersionConfig) + The config to create. + """ + + def __init__(self): + self._config = None + self._freeze() + + @property + def config(self) -> Optional['ApiBenchmarkModelVersionConfig']: + """The config to create.""" + return self._config + + @config.setter + def config(self, config: Optional['ApiBenchmarkModelVersionConfig']): + if config is None: + del self.config + return + if not isinstance(config, ApiBenchmarkModelVersionConfig): + raise TypeError('config must be of type ApiBenchmarkModelVersionConfig') + self._config = config + + def endpoint(self): + path = '/api/v1/benchmarks/models/versions/configs/create' + return path.format_map(self.to_field_map(self)) + + + @staticmethod + def method(): + return 'POST' + + @staticmethod + def body_fields(): + return '*' + + class ApiGetBenchmarkLeaderboardRequest(KaggleObject): r""" Attributes: @@ -219,6 +454,40 @@ def endpoint_path(): return '/api/v1/benchmarks/{owner_slug}/{benchmark_slug}/leaderboard' +class ApiGetBenchmarkModelVersionConfigRequest(KaggleObject): + r""" + Attributes: + id (int) + Id of the config to fetch. + """ + + def __init__(self): + self._id = 0 + self._freeze() + + @property + def id(self) -> int: + """Id of the config to fetch.""" + 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 + + def endpoint(self): + path = '/api/v1/benchmarks/models/versions/configs/{id}' + return path.format_map(self.to_field_map(self)) + + @staticmethod + def endpoint_path(): + return '/api/v1/benchmarks/models/versions/configs/{id}' + + class ApiListBenchmarkModelsRequest(KaggleObject): r""" Attributes: @@ -332,6 +601,117 @@ def nextPageToken(self): return self.next_page_token +class ApiListBenchmarkModelVersionConfigsRequest(KaggleObject): + r""" + Attributes: + benchmark_model_version_ids (int) + If set, only return configs whose parent BenchmarkModelVersionId is in + this list. + page_size (int) + page_token (str) + """ + + def __init__(self): + self._benchmark_model_version_ids = [] + self._page_size = 0 + self._page_token = "" + self._freeze() + + @property + def benchmark_model_version_ids(self) -> Optional[List[int]]: + r""" + If set, only return configs whose parent BenchmarkModelVersionId is in + this list. + """ + return self._benchmark_model_version_ids + + @benchmark_model_version_ids.setter + def benchmark_model_version_ids(self, benchmark_model_version_ids: Optional[List[int]]): + if benchmark_model_version_ids is None: + del self.benchmark_model_version_ids + return + if not isinstance(benchmark_model_version_ids, list): + raise TypeError('benchmark_model_version_ids must be of type list') + if not all([isinstance(t, int) for t in benchmark_model_version_ids]): + raise TypeError('benchmark_model_version_ids must contain only items of type int') + self._benchmark_model_version_ids = benchmark_model_version_ids + + @property + def page_size(self) -> int: + return self._page_size + + @page_size.setter + def page_size(self, page_size: int): + if page_size is None: + del self.page_size + return + if not isinstance(page_size, int): + raise TypeError('page_size must be of type int') + self._page_size = page_size + + @property + def page_token(self) -> str: + return self._page_token + + @page_token.setter + def page_token(self, page_token: str): + if page_token is None: + del self.page_token + return + if not isinstance(page_token, str): + raise TypeError('page_token must be of type str') + self._page_token = page_token + + def endpoint(self): + path = '/api/v1/benchmarks/models/versions/configs/list' + return path.format_map(self.to_field_map(self)) + + +class ApiListBenchmarkModelVersionConfigsResponse(KaggleObject): + r""" + Attributes: + configs (ApiBenchmarkModelVersionConfig) + next_page_token (str) + """ + + def __init__(self): + self._configs = [] + self._next_page_token = None + self._freeze() + + @property + def configs(self) -> Optional[List[Optional['ApiBenchmarkModelVersionConfig']]]: + return self._configs + + @configs.setter + def configs(self, configs: Optional[List[Optional['ApiBenchmarkModelVersionConfig']]]): + if configs is None: + del self.configs + return + if not isinstance(configs, list): + raise TypeError('configs must be of type list') + if not all([isinstance(t, ApiBenchmarkModelVersionConfig) for t in configs]): + raise TypeError('configs must contain only items of type ApiBenchmarkModelVersionConfig') + self._configs = configs + + @property + def next_page_token(self) -> str: + return self._next_page_token or "" + + @next_page_token.setter + def next_page_token(self, next_page_token: Optional[str]): + if next_page_token is None: + del self.next_page_token + return + if not isinstance(next_page_token, str): + raise TypeError('next_page_token must be of type str') + self._next_page_token = next_page_token + + @property + def nextPageToken(self): + return self.next_page_token + + ApiBenchmarkLeaderboard.LeaderboardRow._fields = [ FieldMetadata("modelVersionName", "model_version_name", "_model_version_name", str, "", PredefinedSerializer()), FieldMetadata("modelVersionSlug", "model_version_slug", "_model_version_slug", str, "", PredefinedSerializer()), @@ -349,12 +729,34 @@ def nextPageToken(self): FieldMetadata("rows", "rows", "_rows", ApiBenchmarkLeaderboard.LeaderboardRow, [], ListSerializer(KaggleObjectSerializer())), ] +ApiBenchmarkModelVersionConfig._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), + FieldMetadata("benchmarkModelVersionId", "benchmark_model_version_id", "_benchmark_model_version_id", int, 0, PredefinedSerializer()), + FieldMetadata("displayName", "display_name", "_display_name", str, "", PredefinedSerializer()), + FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()), + FieldMetadata("reasoningEffort", "reasoning_effort", "_reasoning_effort", str, "", PredefinedSerializer()), + FieldMetadata("temperature", "temperature", "_temperature", float, 0.0, PredefinedSerializer()), + FieldMetadata("topP", "top_p", "_top_p", float, 0.0, PredefinedSerializer()), + FieldMetadata("maxOutputTokens", "max_output_tokens", "_max_output_tokens", int, 0, PredefinedSerializer()), + FieldMetadata("topK", "top_k", "_top_k", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("seed", "seed", "_seed", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("thinkingBudget", "thinking_budget", "_thinking_budget", int, None, PredefinedSerializer(), optional=True), +] + +ApiCreateBenchmarkModelVersionConfigRequest._fields = [ + FieldMetadata("config", "config", "_config", ApiBenchmarkModelVersionConfig, None, KaggleObjectSerializer()), +] + ApiGetBenchmarkLeaderboardRequest._fields = [ FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()), FieldMetadata("benchmarkSlug", "benchmark_slug", "_benchmark_slug", str, "", PredefinedSerializer()), FieldMetadata("versionNumber", "version_number", "_version_number", int, None, PredefinedSerializer(), optional=True), ] +ApiGetBenchmarkModelVersionConfigRequest._fields = [ + FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), +] + ApiListBenchmarkModelsRequest._fields = [ FieldMetadata("pageSize", "page_size", "_page_size", int, 0, PredefinedSerializer()), FieldMetadata("pageToken", "page_token", "_page_token", str, "", PredefinedSerializer()), @@ -366,3 +768,14 @@ def nextPageToken(self): FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, None, PredefinedSerializer(), optional=True), ] +ApiListBenchmarkModelVersionConfigsRequest._fields = [ + FieldMetadata("benchmarkModelVersionIds", "benchmark_model_version_ids", "_benchmark_model_version_ids", int, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("pageSize", "page_size", "_page_size", int, 0, PredefinedSerializer()), + FieldMetadata("pageToken", "page_token", "_page_token", str, "", PredefinedSerializer()), +] + +ApiListBenchmarkModelVersionConfigsResponse._fields = [ + FieldMetadata("configs", "configs", "_configs", ApiBenchmarkModelVersionConfig, [], ListSerializer(KaggleObjectSerializer())), + FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, None, PredefinedSerializer(), optional=True), +] + diff --git a/kagglesdk/competitions/services/competition_api_service.py b/kagglesdk/competitions/services/competition_api_service.py index 75838a9..20dc5c6 100644 --- a/kagglesdk/competitions/services/competition_api_service.py +++ b/kagglesdk/competitions/services/competition_api_service.py @@ -1,6 +1,6 @@ from kagglesdk.common.types.file_download import FileDownload from kagglesdk.common.types.http_redirect import HttpRedirect -from kagglesdk.competitions.types.competition_api_service import ApiCompetition, ApiCompetitionPage, ApiCompetitionSolutionStatus, ApiCreateCodeSubmissionRequest, ApiCreateCodeSubmissionResponse, ApiCreateCompetitionDataRequest, ApiCreateCompetitionDataResponse, ApiCreateCompetitionPageRequest, ApiCreateCompetitionRequest, ApiCreateCompetitionResponse, ApiCreateCompetitionSampleSubmissionRequest, ApiCreateCompetitionSolutionRequest, ApiCreateSubmissionRequest, ApiCreateSubmissionResponse, ApiDeleteCompetitionPageRequest, ApiDownloadDataFileRequest, ApiDownloadDataFilesRequest, ApiDownloadLeaderboardRequest, ApiGetCompetitionDataFilesSummaryRequest, ApiGetCompetitionRequest, ApiGetCompetitionSettingsRequest, ApiGetCompetitionSolutionStatusRequest, ApiGetEpisodeAgentLogsRequest, ApiGetEpisodeReplayRequest, ApiGetLeaderboardRequest, ApiGetLeaderboardResponse, ApiGetSubmissionLimitsRequest, ApiGetSubmissionRequest, ApiLaunchCompetitionRequest, ApiListCompetitionHostsRequest, ApiListCompetitionHostsResponse, ApiListCompetitionPagesRequest, ApiListCompetitionPagesResponse, ApiListCompetitionsRequest, ApiListCompetitionsResponse, ApiListCompetitionTopicsRequest, ApiListCompetitionTopicsResponse, ApiListDataFilesRequest, ApiListDataFilesResponse, ApiListDataTreeFilesRequest, ApiListSubmissionEpisodesRequest, ApiListSubmissionEpisodesResponse, ApiListSubmissionsRequest, ApiListSubmissionsResponse, ApiListTeamPublicSubmissionsRequest, ApiListTeamPublicSubmissionsResponse, ApiListTopicMessagesRequest, ApiListTopicMessagesResponse, ApiStartSubmissionUploadRequest, ApiStartSubmissionUploadResponse, ApiSubmission, ApiSubmissionLimits, ApiUpdateCompetitionPageRequest, ApiUpdateCompetitionSettingsRequest +from kagglesdk.competitions.types.competition_api_service import ApiCompetition, ApiCompetitionPage, ApiCompetitionSolutionStatus, ApiCreateCodeSubmissionRequest, ApiCreateCodeSubmissionResponse, ApiCreateCompetitionDataRequest, ApiCreateCompetitionDataResponse, ApiCreateCompetitionPageRequest, ApiCreateCompetitionRequest, ApiCreateCompetitionResponse, ApiCreateCompetitionSampleSubmissionRequest, ApiCreateCompetitionSolutionRequest, ApiCreateSubmissionRequest, ApiCreateSubmissionResponse, ApiDeleteCompetitionPageRequest, ApiDownloadDataFileRequest, ApiDownloadDataFilesRequest, ApiDownloadLeaderboardRequest, ApiDownloadSubmissionRequest, ApiGetCompetitionDataFilesSummaryRequest, ApiGetCompetitionRequest, ApiGetCompetitionSettingsRequest, ApiGetCompetitionSolutionStatusRequest, ApiGetEpisodeAgentLogsRequest, ApiGetEpisodeReplayRequest, ApiGetLeaderboardRequest, ApiGetLeaderboardResponse, ApiGetSubmissionLimitsRequest, ApiGetSubmissionRequest, ApiLaunchCompetitionRequest, ApiListCompetitionHostsRequest, ApiListCompetitionHostsResponse, ApiListCompetitionPagesRequest, ApiListCompetitionPagesResponse, ApiListCompetitionsRequest, ApiListCompetitionsResponse, ApiListCompetitionTopicsRequest, ApiListCompetitionTopicsResponse, ApiListDataFilesRequest, ApiListDataFilesResponse, ApiListDataTreeFilesRequest, ApiListSubmissionEpisodesRequest, ApiListSubmissionEpisodesResponse, ApiListSubmissionsRequest, ApiListSubmissionsResponse, ApiListTeamPublicSubmissionsRequest, ApiListTeamPublicSubmissionsResponse, ApiListTopicMessagesRequest, ApiListTopicMessagesResponse, ApiStartSubmissionUploadRequest, ApiStartSubmissionUploadResponse, ApiSubmission, ApiSubmissionLimits, ApiUpdateCompetitionPageRequest, ApiUpdateCompetitionSettingsRequest from kagglesdk.competitions.types.host_service import CompetitionSettings from kagglesdk.datasets.databundles.types.databundle_api_types import ApiDirectoryContent, ApiFilesSummary from kagglesdk.kaggle_http_client import KaggleHttpClient @@ -142,6 +142,18 @@ def get_submission(self, request: ApiGetSubmissionRequest = None) -> ApiSubmissi return self._client.call("competitions.CompetitionApiService", "GetSubmission", request, ApiSubmission) + def download_submission(self, request: ApiDownloadSubmissionRequest = None) -> HttpRedirect: + r""" + Args: + request (ApiDownloadSubmissionRequest): + The request object; initialized to empty instance if not specified. + """ + + if request is None: + request = ApiDownloadSubmissionRequest() + + return self._client.call("competitions.CompetitionApiService", "DownloadSubmission", request, HttpRedirect) + def get_submission_limits(self, request: ApiGetSubmissionLimitsRequest = None) -> ApiSubmissionLimits: r""" Args: diff --git a/kagglesdk/competitions/types/competition_api_service.py b/kagglesdk/competitions/types/competition_api_service.py index 1075c20..eb03ead 100644 --- a/kagglesdk/competitions/types/competition_api_service.py +++ b/kagglesdk/competitions/types/competition_api_service.py @@ -2348,6 +2348,38 @@ def endpoint_path(): return '/api/v1/competitions/{competition_name}/leaderboard/download' +class ApiDownloadSubmissionRequest(KaggleObject): + r""" + Attributes: + submission_id (int) + """ + + def __init__(self): + self._submission_id = 0 + self._freeze() + + @property + def submission_id(self) -> int: + return self._submission_id + + @submission_id.setter + def submission_id(self, submission_id: int): + if submission_id is None: + del self.submission_id + return + if not isinstance(submission_id, int): + raise TypeError('submission_id must be of type int') + self._submission_id = submission_id + + def endpoint(self): + path = '/api/v1/competitions/submissions/download/{submission_id}' + return path.format_map(self.to_field_map(self)) + + @staticmethod + def endpoint_path(): + return '/api/v1/competitions/submissions/download/{submission_id}' + + class ApiEpisode(KaggleObject): r""" Attributes: @@ -4982,7 +5014,7 @@ class ApiUpdateCompetitionSettingsRequest(KaggleObject): competition_name (str) settings (CompetitionSettings) Only fields listed in update_mask are written. Reserved CompetitionSettings - fields (deadline, reward, num_prizes, max_team_size, etc.) are web-only. + fields (reward, num_prizes, max_team_size, etc.) are web-only. update_mask (FieldMask) """ @@ -5009,7 +5041,7 @@ def competition_name(self, competition_name: str): def settings(self) -> Optional['CompetitionSettings']: r""" Only fields listed in update_mask are written. Reserved CompetitionSettings - fields (deadline, reward, num_prizes, max_team_size, etc.) are web-only. + fields (reward, num_prizes, max_team_size, etc.) are web-only. """ return self._settings @@ -5237,6 +5269,10 @@ def body_fields(): FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()), ] +ApiDownloadSubmissionRequest._fields = [ + FieldMetadata("submissionId", "submission_id", "_submission_id", int, 0, PredefinedSerializer()), +] + ApiEpisode._fields = [ FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), FieldMetadata("createTime", "create_time", "_create_time", datetime, None, DateTimeSerializer()), diff --git a/kagglesdk/competitions/types/host_service.py b/kagglesdk/competitions/types/host_service.py index 293a405..76ffcdd 100644 --- a/kagglesdk/competitions/types/host_service.py +++ b/kagglesdk/competitions/types/host_service.py @@ -43,6 +43,9 @@ class CompetitionSettings(KaggleObject): --) Should only be set if enable_team_files is true. Team File Drop Deadline' in the UI. + deadline (datetime) + KEY DATES SETTINGS GROUP (field numbers 40-59) + 'Competition Deadline' in the UI. team_merger_explicit_deadline (datetime) KEY DATES SETTINGS GROUP: ADMIN ONLY 'Team Merger Deadline' in the UI. @@ -113,6 +116,7 @@ def __init__(self): self._requires_identity_verification = False self._enable_team_files = False self._team_file_deadline = None + self._deadline = None self._team_merger_explicit_deadline = None self._prohibit_new_entrants_explicit_deadline = None self._kernels_publishing_disabled_deadline = None @@ -299,6 +303,23 @@ def team_file_deadline(self, team_file_deadline: datetime): raise TypeError('team_file_deadline must be of type datetime') self._team_file_deadline = team_file_deadline + @property + def deadline(self) -> datetime: + r""" + KEY DATES SETTINGS GROUP (field numbers 40-59) + 'Competition Deadline' in the UI. + """ + 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 team_merger_explicit_deadline(self) -> datetime: r""" @@ -604,6 +625,7 @@ def directly_responsible_user_id(self, directly_responsible_user_id: Optional[in FieldMetadata("requiresIdentityVerification", "requires_identity_verification", "_requires_identity_verification", bool, False, PredefinedSerializer()), FieldMetadata("enableTeamFiles", "enable_team_files", "_enable_team_files", bool, False, PredefinedSerializer()), FieldMetadata("teamFileDeadline", "team_file_deadline", "_team_file_deadline", datetime, None, DateTimeSerializer()), + FieldMetadata("deadline", "deadline", "_deadline", datetime, None, DateTimeSerializer()), FieldMetadata("teamMergerExplicitDeadline", "team_merger_explicit_deadline", "_team_merger_explicit_deadline", datetime, None, DateTimeSerializer()), FieldMetadata("prohibitNewEntrantsExplicitDeadline", "prohibit_new_entrants_explicit_deadline", "_prohibit_new_entrants_explicit_deadline", datetime, None, DateTimeSerializer()), FieldMetadata("kernelsPublishingDisabledDeadline", "kernels_publishing_disabled_deadline", "_kernels_publishing_disabled_deadline", datetime, None, DateTimeSerializer()), diff --git a/kagglesdk/kaggle_client.py b/kagglesdk/kaggle_client.py index 166b88c..805ddec 100644 --- a/kagglesdk/kaggle_client.py +++ b/kagglesdk/kaggle_client.py @@ -1,5 +1,6 @@ from kagglesdk.admin.services.inbox_file_service import InboxFileClient from kagglesdk.agents.services.agent_exam_service import AgentExamClient +from kagglesdk.agents.services.agents_api_service import AgentsApiClient from kagglesdk.benchmarks.services.benchmarks_api_service import BenchmarksApiClient from kagglesdk.benchmarks.services.benchmark_tasks_api_service import BenchmarkTasksApiClient from kagglesdk.blobs.services.blob_api_service import BlobApiClient @@ -32,6 +33,7 @@ def __init__(self, http_client: KaggleHttpClient): class Agents(object): def __init__(self, http_client: KaggleHttpClient): self.agent_exam_client = AgentExamClient(http_client) + self.agents_api_client = AgentsApiClient(http_client) class Benchmarks(object): def __init__(self, http_client: KaggleHttpClient): diff --git a/kagglesdk/search/types/search_service.py b/kagglesdk/search/types/search_service.py index 5cffb91..006dae3 100644 --- a/kagglesdk/search/types/search_service.py +++ b/kagglesdk/search/types/search_service.py @@ -169,6 +169,15 @@ class WriteUpItemInfo(KaggleObject): Id of the WriteUp hackathon_track_ids (int) The track ids of the Hackathon + awarded_hackathon_track_prize_ids (int) + Hackathon track prize ids this WriteUp has been awarded + team_leader_user_id (int) + User id of the team leader + template (bool) + True if this WriteUp is a sample/template project + hackathon_write_up_id (int) + Id of the underlying HackathonWriteUp (distinct from `id`, which is the + WriteUp id). """ def __init__(self): @@ -180,6 +189,10 @@ def __init__(self): self._team_name = None self._id = 0 self._hackathon_track_ids = [] + self._awarded_hackathon_track_prize_ids = [] + self._team_leader_user_id = None + self._template = False + self._hackathon_write_up_id = None self._freeze() @property @@ -298,6 +311,67 @@ def hackathon_track_ids(self, hackathon_track_ids: Optional[List[int]]): raise TypeError('hackathon_track_ids must contain only items of type int') self._hackathon_track_ids = hackathon_track_ids + @property + def awarded_hackathon_track_prize_ids(self) -> Optional[List[int]]: + """Hackathon track prize ids this WriteUp has been awarded""" + return self._awarded_hackathon_track_prize_ids + + @awarded_hackathon_track_prize_ids.setter + def awarded_hackathon_track_prize_ids(self, awarded_hackathon_track_prize_ids: Optional[List[int]]): + if awarded_hackathon_track_prize_ids is None: + del self.awarded_hackathon_track_prize_ids + return + if not isinstance(awarded_hackathon_track_prize_ids, list): + raise TypeError('awarded_hackathon_track_prize_ids must be of type list') + if not all([isinstance(t, int) for t in awarded_hackathon_track_prize_ids]): + raise TypeError('awarded_hackathon_track_prize_ids must contain only items of type int') + self._awarded_hackathon_track_prize_ids = awarded_hackathon_track_prize_ids + + @property + def team_leader_user_id(self) -> int: + """User id of the team leader""" + return self._team_leader_user_id or 0 + + @team_leader_user_id.setter + def team_leader_user_id(self, team_leader_user_id: Optional[int]): + if team_leader_user_id is None: + del self.team_leader_user_id + return + if not isinstance(team_leader_user_id, int): + raise TypeError('team_leader_user_id must be of type int') + self._team_leader_user_id = team_leader_user_id + + @property + def template(self) -> bool: + """True if this WriteUp is a sample/template project""" + return self._template + + @template.setter + def template(self, template: bool): + if template is None: + del self.template + return + if not isinstance(template, bool): + raise TypeError('template must be of type bool') + self._template = template + + @property + def hackathon_write_up_id(self) -> int: + r""" + Id of the underlying HackathonWriteUp (distinct from `id`, which is the + WriteUp id). + """ + return self._hackathon_write_up_id or 0 + + @hackathon_write_up_id.setter + def hackathon_write_up_id(self, hackathon_write_up_id: Optional[int]): + if hackathon_write_up_id is None: + del self.hackathon_write_up_id + return + if not isinstance(hackathon_write_up_id, int): + raise TypeError('hackathon_write_up_id must be of type int') + self._hackathon_write_up_id = hackathon_write_up_id + WriteUpCompetitionInfo._fields = [ FieldMetadata("competitionTitle", "competition_title", "_competition_title", str, "", PredefinedSerializer()), @@ -319,5 +393,9 @@ def hackathon_track_ids(self, hackathon_track_ids: Optional[List[int]]): FieldMetadata("teamName", "team_name", "_team_name", str, None, PredefinedSerializer(), optional=True), FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()), FieldMetadata("hackathonTrackIds", "hackathon_track_ids", "_hackathon_track_ids", int, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("awardedHackathonTrackPrizeIds", "awarded_hackathon_track_prize_ids", "_awarded_hackathon_track_prize_ids", int, [], ListSerializer(PredefinedSerializer())), + FieldMetadata("teamLeaderUserId", "team_leader_user_id", "_team_leader_user_id", int, None, PredefinedSerializer(), optional=True), + FieldMetadata("template", "template", "_template", bool, False, PredefinedSerializer()), + FieldMetadata("hackathonWriteUpId", "hackathon_write_up_id", "_hackathon_write_up_id", int, None, PredefinedSerializer(), optional=True), ] diff --git a/kagglesdk/security/types/security_types.py b/kagglesdk/security/types/security_types.py index e82a51b..109351e 100644 --- a/kagglesdk/security/types/security_types.py +++ b/kagglesdk/security/types/security_types.py @@ -100,6 +100,9 @@ class KaggleResourceType(enum.Enum): KAGGLE_RESOURCE_TYPE_BENCHMARK_TASK_VERSIONS = 712 KAGGLE_RESOURCE_TYPE_BENCHMARK_TASK_RUNS = 714 KAGGLE_RESOURCE_TYPE_KKB_SESSIONS = 716 + KAGGLE_RESOURCE_TYPE_BENCHMARK_MODEL_VERSION_CONFIGS = 718 + KAGGLE_RESOURCE_TYPE_HARNESSES = 720 + KAGGLE_RESOURCE_TYPE_HARNESS_VERSIONS = 722 KAGGLE_RESOURCE_TYPE_COURSE_TRACKS = 800 """---------- Courses ----------""" KAGGLE_RESOURCE_TYPE_COURSE_LESSONS = 802