kaggle 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

kagglesdk/benchmarks/types/benchmarks_api_service.py

@@ -1,243 +0,0 @@
-from kagglesdk.benchmarks.types.benchmark_types import BenchmarkResult
-from kagglesdk.kaggle_object import *
-from typing import List, Optional
-
-class ApiBenchmarkLeaderboard(KaggleObject):
-  r"""
-  Attributes:
-    rows (ApiBenchmarkLeaderboard.LeaderboardRow)
-  """
-
-  class LeaderboardRow(KaggleObject):
-    r"""
-    Attributes:
-      model_version_name (str)
-      model_version_slug (str)
-      task_results (ApiBenchmarkLeaderboard.TaskResult)
-    """
-
-    def __init__(self):
-      self._model_version_name = ""
-      self._model_version_slug = ""
-      self._task_results = []
-      self._freeze()
-
-    @property
-    def model_version_name(self) -> str:
-      return self._model_version_name
-
-    @model_version_name.setter
-    def model_version_name(self, model_version_name: str):
-      if model_version_name is None:
-        del self.model_version_name
-        return
-      if not isinstance(model_version_name, str):
-        raise TypeError('model_version_name must be of type str')
-      self._model_version_name = model_version_name
-
-    @property
-    def model_version_slug(self) -> str:
-      return self._model_version_slug
-
-    @model_version_slug.setter
-    def model_version_slug(self, model_version_slug: str):
-      if model_version_slug is None:
-        del self.model_version_slug
-        return
-      if not isinstance(model_version_slug, str):
-        raise TypeError('model_version_slug must be of type str')
-      self._model_version_slug = model_version_slug
-
-    @property
-    def task_results(self) -> Optional[List[Optional['ApiBenchmarkLeaderboard.TaskResult']]]:
-      return self._task_results
-
-    @task_results.setter
-    def task_results(self, task_results: Optional[List[Optional['ApiBenchmarkLeaderboard.TaskResult']]]):
-      if task_results is None:
-        del self.task_results
-        return
-      if not isinstance(task_results, list):
-        raise TypeError('task_results must be of type list')
-      if not all([isinstance(t, ApiBenchmarkLeaderboard.TaskResult) for t in task_results]):
-        raise TypeError('task_results must contain only items of type ApiBenchmarkLeaderboard.TaskResult')
-      self._task_results = task_results
-
-
-  class TaskResult(KaggleObject):
-    r"""
-    Attributes:
-      benchmark_task_name (str)
-      benchmark_task_slug (str)
-      task_version (int)
-      result (BenchmarkResult)
-    """
-
-    def __init__(self):
-      self._benchmark_task_name = ""
-      self._benchmark_task_slug = ""
-      self._task_version = 0
-      self._result = None
-      self._freeze()
-
-    @property
-    def benchmark_task_name(self) -> str:
-      return self._benchmark_task_name
-
-    @benchmark_task_name.setter
-    def benchmark_task_name(self, benchmark_task_name: str):
-      if benchmark_task_name is None:
-        del self.benchmark_task_name
-        return
-      if not isinstance(benchmark_task_name, str):
-        raise TypeError('benchmark_task_name must be of type str')
-      self._benchmark_task_name = benchmark_task_name
-
-    @property
-    def benchmark_task_slug(self) -> str:
-      return self._benchmark_task_slug
-
-    @benchmark_task_slug.setter
-    def benchmark_task_slug(self, benchmark_task_slug: str):
-      if benchmark_task_slug is None:
-        del self.benchmark_task_slug
-        return
-      if not isinstance(benchmark_task_slug, str):
-        raise TypeError('benchmark_task_slug must be of type str')
-      self._benchmark_task_slug = benchmark_task_slug
-
-    @property
-    def task_version(self) -> int:
-      return self._task_version
-
-    @task_version.setter
-    def task_version(self, task_version: int):
-      if task_version is None:
-        del self.task_version
-        return
-      if not isinstance(task_version, int):
-        raise TypeError('task_version must be of type int')
-      self._task_version = task_version
-
-    @property
-    def result(self) -> Optional['BenchmarkResult']:
-      return self._result
-
-    @result.setter
-    def result(self, result: Optional['BenchmarkResult']):
-      if result is None:
-        del self.result
-        return
-      if not isinstance(result, BenchmarkResult):
-        raise TypeError('result must be of type BenchmarkResult')
-      self._result = result
-
-
-  def __init__(self):
-    self._rows = []
-    self._freeze()
-
-  @property
-  def rows(self) -> Optional[List[Optional['ApiBenchmarkLeaderboard.LeaderboardRow']]]:
-    return self._rows
-
-  @rows.setter
-  def rows(self, rows: Optional[List[Optional['ApiBenchmarkLeaderboard.LeaderboardRow']]]):
-    if rows is None:
-      del self.rows
-      return
-    if not isinstance(rows, list):
-      raise TypeError('rows must be of type list')
-    if not all([isinstance(t, ApiBenchmarkLeaderboard.LeaderboardRow) for t in rows]):
-      raise TypeError('rows must contain only items of type ApiBenchmarkLeaderboard.LeaderboardRow')
-    self._rows = rows
-
-
-class ApiGetBenchmarkLeaderboardRequest(KaggleObject):
-  r"""
-  Attributes:
-    owner_slug (str)
-    benchmark_slug (str)
-    version_number (int)
-  """
-
-  def __init__(self):
-    self._owner_slug = ""
-    self._benchmark_slug = ""
-    self._version_number = None
-    self._freeze()
-
-  @property
-  def owner_slug(self) -> str:
-    return self._owner_slug
-
-  @owner_slug.setter
-  def owner_slug(self, owner_slug: str):
-    if owner_slug is None:
-      del self.owner_slug
-      return
-    if not isinstance(owner_slug, str):
-      raise TypeError('owner_slug must be of type str')
-    self._owner_slug = owner_slug
-
-  @property
-  def benchmark_slug(self) -> str:
-    return self._benchmark_slug
-
-  @benchmark_slug.setter
-  def benchmark_slug(self, benchmark_slug: str):
-    if benchmark_slug is None:
-      del self.benchmark_slug
-      return
-    if not isinstance(benchmark_slug, str):
-      raise TypeError('benchmark_slug must be of type str')
-    self._benchmark_slug = benchmark_slug
-
-  @property
-  def version_number(self) -> int:
-    return self._version_number or 0
-
-  @version_number.setter
-  def version_number(self, version_number: Optional[int]):
-    if version_number is None:
-      del self.version_number
-      return
-    if not isinstance(version_number, int):
-      raise TypeError('version_number must be of type int')
-    self._version_number = version_number
-
-  def endpoint(self):
-    if self.version_number:
-      path = '/api/v1/benchmarks/{owner_slug}/{benchmark_slug}/versions/{version_number}/leaderboard'
-    else:
-      path = '/api/v1/benchmarks/{owner_slug}/{benchmark_slug}/leaderboard'
-    return path.format_map(self.to_field_map(self))
-
-  @staticmethod
-  def endpoint_path():
-    return '/api/v1/benchmarks/{owner_slug}/{benchmark_slug}/leaderboard'
-
-
-ApiBenchmarkLeaderboard.LeaderboardRow._fields = [
-  FieldMetadata("modelVersionName", "model_version_name", "_model_version_name", str, "", PredefinedSerializer()),
-  FieldMetadata("modelVersionSlug", "model_version_slug", "_model_version_slug", str, "", PredefinedSerializer()),
-  FieldMetadata("taskResults", "task_results", "_task_results", ApiBenchmarkLeaderboard.TaskResult, [], ListSerializer(KaggleObjectSerializer())),
-]
-
-ApiBenchmarkLeaderboard.TaskResult._fields = [
-  FieldMetadata("benchmarkTaskName", "benchmark_task_name", "_benchmark_task_name", str, "", PredefinedSerializer()),
-  FieldMetadata("benchmarkTaskSlug", "benchmark_task_slug", "_benchmark_task_slug", str, "", PredefinedSerializer()),
-  FieldMetadata("taskVersion", "task_version", "_task_version", int, 0, PredefinedSerializer()),
-  FieldMetadata("result", "result", "_result", BenchmarkResult, None, KaggleObjectSerializer()),
-]
-
-ApiBenchmarkLeaderboard._fields = [
-  FieldMetadata("rows", "rows", "_rows", ApiBenchmarkLeaderboard.LeaderboardRow, [], ListSerializer(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),
-]
-

kagglesdk/blobs/services/blob_api_service.py

@@ -1,25 +0,0 @@
-from kagglesdk.blobs.types.blob_api_service import ApiStartBlobUploadRequest, ApiStartBlobUploadResponse
-from kagglesdk.kaggle_http_client import KaggleHttpClient
-
-class BlobApiClient(object):
-  r"""
-  Binary Large OBject (BLOB) service used for uploading files to Google Cloud
-  Storage (GCS).
-  """
-
-  def __init__(self, client: KaggleHttpClient):
-    self._client = client
-
-  def start_blob_upload(self, request: ApiStartBlobUploadRequest = None) -> ApiStartBlobUploadResponse:
-    r"""
-    Starts a blob upload (i.e. reserves a spot for the upload on GCS).
-
-    Args:
-      request (ApiStartBlobUploadRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiStartBlobUploadRequest()
-
-    return self._client.call("blobs.BlobApiService", "StartBlobUpload", request, ApiStartBlobUploadResponse)

kagglesdk/blobs/types/blob_api_service.py

@@ -1,177 +0,0 @@
-import enum
-from kagglesdk.kaggle_object import *
-from typing import Optional
-
-class ApiBlobType(enum.Enum):
-  API_BLOB_TYPE_UNSPECIFIED = 0
-  DATASET = 1
-  MODEL = 2
-  INBOX = 3
-
-class ApiStartBlobUploadRequest(KaggleObject):
-  r"""
-  Attributes:
-    type (ApiBlobType)
-      The type of the blob.
-    name (str)
-      Name (e.g. file name) of the blob.
-    content_type (str)
-      Content/MIME type (e.g. 'text/plain').
-    content_length (int)
-      Size in bytes of the blob.
-    last_modified_epoch_seconds (int)
-      Optional user-reported time when the blob was last updated/modified.
-  """
-
-  def __init__(self):
-    self._type = ApiBlobType.API_BLOB_TYPE_UNSPECIFIED
-    self._name = ""
-    self._content_type = None
-    self._content_length = 0
-    self._last_modified_epoch_seconds = None
-    self._freeze()
-
-  @property
-  def type(self) -> 'ApiBlobType':
-    """The type of the blob."""
-    return self._type
-
-  @type.setter
-  def type(self, type: 'ApiBlobType'):
-    if type is None:
-      del self.type
-      return
-    if not isinstance(type, ApiBlobType):
-      raise TypeError('type must be of type ApiBlobType')
-    self._type = type
-
-  @property
-  def name(self) -> str:
-    """Name (e.g. file name) of the blob."""
-    return self._name
-
-  @name.setter
-  def name(self, name: str):
-    if name is None:
-      del self.name
-      return
-    if not isinstance(name, str):
-      raise TypeError('name must be of type str')
-    self._name = name
-
-  @property
-  def content_type(self) -> str:
-    """Content/MIME type (e.g. 'text/plain')."""
-    return self._content_type or ""
-
-  @content_type.setter
-  def content_type(self, content_type: Optional[str]):
-    if content_type is None:
-      del self.content_type
-      return
-    if not isinstance(content_type, str):
-      raise TypeError('content_type must be of type str')
-    self._content_type = content_type
-
-  @property
-  def content_length(self) -> int:
-    """Size in bytes of the blob."""
-    return self._content_length
-
-  @content_length.setter
-  def content_length(self, content_length: int):
-    if content_length is None:
-      del self.content_length
-      return
-    if not isinstance(content_length, int):
-      raise TypeError('content_length must be of type int')
-    self._content_length = content_length
-
-  @property
-  def last_modified_epoch_seconds(self) -> int:
-    """Optional user-reported time when the blob was last updated/modified."""
-    return self._last_modified_epoch_seconds or 0
-
-  @last_modified_epoch_seconds.setter
-  def last_modified_epoch_seconds(self, last_modified_epoch_seconds: Optional[int]):
-    if last_modified_epoch_seconds is None:
-      del self.last_modified_epoch_seconds
-      return
-    if not isinstance(last_modified_epoch_seconds, int):
-      raise TypeError('last_modified_epoch_seconds must be of type int')
-    self._last_modified_epoch_seconds = last_modified_epoch_seconds
-
-  def endpoint(self):
-    path = '/api/v1/blobs/upload'
-    return path.format_map(self.to_field_map(self))
-
-
-  @staticmethod
-  def method():
-    return 'POST'
-
-  @staticmethod
-  def body_fields():
-    return '*'
-
-
-class ApiStartBlobUploadResponse(KaggleObject):
-  r"""
-  Attributes:
-    token (str)
-      Opaque string token used to reference the new blob/file.
-    create_url (str)
-      URL to use to start the upload.
-  """
-
-  def __init__(self):
-    self._token = ""
-    self._create_url = ""
-    self._freeze()
-
-  @property
-  def token(self) -> str:
-    """Opaque string token used to reference the new blob/file."""
-    return self._token
-
-  @token.setter
-  def token(self, token: str):
-    if token is None:
-      del self.token
-      return
-    if not isinstance(token, str):
-      raise TypeError('token must be of type str')
-    self._token = token
-
-  @property
-  def create_url(self) -> str:
-    """URL to use to start the upload."""
-    return self._create_url
-
-  @create_url.setter
-  def create_url(self, create_url: str):
-    if create_url is None:
-      del self.create_url
-      return
-    if not isinstance(create_url, str):
-      raise TypeError('create_url must be of type str')
-    self._create_url = create_url
-
-  @property
-  def createUrl(self):
-    return self.create_url
-
-
-ApiStartBlobUploadRequest._fields = [
-  FieldMetadata("type", "type", "_type", ApiBlobType, ApiBlobType.API_BLOB_TYPE_UNSPECIFIED, EnumSerializer()),
-  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
-  FieldMetadata("contentType", "content_type", "_content_type", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("contentLength", "content_length", "_content_length", int, 0, PredefinedSerializer()),
-  FieldMetadata("lastModifiedEpochSeconds", "last_modified_epoch_seconds", "_last_modified_epoch_seconds", int, None, PredefinedSerializer(), optional=True),
-]
-
-ApiStartBlobUploadResponse._fields = [
-  FieldMetadata("token", "token", "_token", str, "", PredefinedSerializer()),
-  FieldMetadata("createUrl", "create_url", "_create_url", str, "", PredefinedSerializer()),
-]
-

kagglesdk/common/services/operations_service.py

@@ -1,46 +0,0 @@
-from kagglesdk.common.types.operations import Operation
-from kagglesdk.common.types.operations_service import GetOperationRequest
-from kagglesdk.kaggle_http_client import KaggleHttpClient
-
-class OperationsClient(object):
-  r"""
-  Manages long-running operations with an API service.
-
-  When an API method normally takes long time to complete, it can be designed
-  to return [Operation][google.longrunning.Operation] to the client, and the
-  client can use this interface to receive the real response asynchronously by
-  polling the operation resource, or pass the operation resource to another API
-  (such as Pub/Sub API) to receive the response.  Any API service that returns
-  long-running operations should implement the `Operations` interface so
-  developers can have a consistent client experience.
-  """
-
-  def __init__(self, client: KaggleHttpClient):
-    self._client = client
-
-  def get_operation(self, request: GetOperationRequest = None, name: str = None) -> Operation:
-    r"""
-    Gets the latest state of a long-running operation.  Clients can use this
-    method to poll the operation result at intervals as recommended by the API
-    service.
-
-    Args:
-      request (GetOperationRequest):
-        The request object; initialized to empty instance if not specified.
-        May not be specified if any of the flattened field params are specified.
-      name (str)
-        This corresponds to the ``name`` field on the ``request`` instance;
-        if ``request`` is provided, this should not be set.
-    """
-
-    has_flattened_args = any([name])
-    if request is not None and has_flattened_args:
-      raise ValueError('If the `request` argument is set, then none of '
-                       'the individual field arguments should be set.')
-
-    if request is None:
-      request = GetOperationRequest()
-      if name is not None:
-        request.name = name
-
-    return self._client.call("common.OperationsService", "GetOperation", request, Operation)

kagglesdk/common/types/file_download.py

@@ -1,102 +0,0 @@
-from kagglesdk.kaggle_object import *
-from typing import Optional
-
-class FileDownload(KaggleObject):
-  r"""
-  Standard response object representing a file download.
-  See http://go/kaggle-proto-handler-file-downloads
-  Some field names/descriptions borrowed from
-  google3/gdata/rosy/proto/data.proto
-
-  Attributes:
-    content_type (str)
-      MIME type of the data
-      TODO(aip.dev/143): (-- api-linter: core::0143::standardized-codes=disabled
-      --)
-    file_name (str)
-      Original file name
-    token (str)
-      A unique fingerprint for the file/media data
-    content_length (int)
-      Size of the data, in bytes (if known)
-  """
-
-  def __init__(self):
-    self._content_type = ""
-    self._file_name = ""
-    self._token = ""
-    self._content_length = None
-    self._freeze()
-
-  @property
-  def content_type(self) -> str:
-    r"""
-    MIME type of the data
-    TODO(aip.dev/143): (-- api-linter: core::0143::standardized-codes=disabled
-    --)
-    """
-    return self._content_type
-
-  @content_type.setter
-  def content_type(self, content_type: str):
-    if content_type is None:
-      del self.content_type
-      return
-    if not isinstance(content_type, str):
-      raise TypeError('content_type must be of type str')
-    self._content_type = content_type
-
-  @property
-  def file_name(self) -> str:
-    """Original file name"""
-    return self._file_name
-
-  @file_name.setter
-  def file_name(self, file_name: str):
-    if file_name is None:
-      del self.file_name
-      return
-    if not isinstance(file_name, str):
-      raise TypeError('file_name must be of type str')
-    self._file_name = file_name
-
-  @property
-  def token(self) -> str:
-    """A unique fingerprint for the file/media data"""
-    return self._token
-
-  @token.setter
-  def token(self, token: str):
-    if token is None:
-      del self.token
-      return
-    if not isinstance(token, str):
-      raise TypeError('token must be of type str')
-    self._token = token
-
-  @property
-  def content_length(self) -> int:
-    """Size of the data, in bytes (if known)"""
-    return self._content_length or 0
-
-  @content_length.setter
-  def content_length(self, content_length: Optional[int]):
-    if content_length is None:
-      del self.content_length
-      return
-    if not isinstance(content_length, int):
-      raise TypeError('content_length must be of type int')
-    self._content_length = content_length
-
-  @classmethod
-  def prepare_from(cls, http_response):
-    return http_response
-
-
-FileDownload._fields = [
-  FieldMetadata("contentType", "content_type", "_content_type", str, "", PredefinedSerializer()),
-  FieldMetadata("fileName", "file_name", "_file_name", str, "", PredefinedSerializer()),
-  FieldMetadata("token", "token", "_token", str, "", PredefinedSerializer()),
-  FieldMetadata("contentLength", "content_length", "_content_length", int, None, PredefinedSerializer(), optional=True),
-]
-