kaggle 1.7.4.5__py3-none-any.whl → 1.8.0__py3-none-any.whl

kagglesdk/benchmarks/types/benchmarks_api_service.py

@@ -0,0 +1,243 @@
+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

@@ -22,4 +22,4 @@ class BlobApiClient(object):
     if request is None:
       request = ApiStartBlobUploadRequest()
 
-    return self._client.call("blobs.BlobApiService", "ApiStartBlobUpload", request, ApiStartBlobUploadResponse)
+    return self._client.call("blobs.BlobApiService", "StartBlobUpload", request, ApiStartBlobUploadResponse)

kagglesdk/blobs/types/blob_api_service.py

@@ -65,7 +65,7 @@ class ApiStartBlobUploadRequest(KaggleObject):
     return self._content_type or ""
 
   @content_type.setter
-  def content_type(self, content_type: str):
+  def content_type(self, content_type: Optional[str]):
     if content_type is None:
       del self.content_type
       return
@@ -93,7 +93,7 @@ class ApiStartBlobUploadRequest(KaggleObject):
     return self._last_modified_epoch_seconds or 0
 
   @last_modified_epoch_seconds.setter
-  def last_modified_epoch_seconds(self, last_modified_epoch_seconds: int):
+  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

kagglesdk/common/services/operations_service.py

@@ -0,0 +1,46 @@
+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

@@ -80,7 +80,7 @@ class FileDownload(KaggleObject):
     return self._content_length or 0
 
   @content_length.setter
-  def content_length(self, content_length: int):
+  def content_length(self, content_length: Optional[int]):
     if content_length is None:
       del self.content_length
       return

kagglesdk/common/types/http_redirect.py

@@ -69,7 +69,7 @@ class HttpRedirect(KaggleObject):
     return self._bypass_encoding or False
 
   @bypass_encoding.setter
-  def bypass_encoding(self, bypass_encoding: bool):
+  def bypass_encoding(self, bypass_encoding: Optional[bool]):
     if bypass_encoding is None:
       del self.bypass_encoding
       return

kagglesdk/common/types/operations.py

@@ -0,0 +1,194 @@
+from kagglesdk.kaggle_object import *
+from typing import Optional
+
+class Operation(KaggleObject):
+  r"""
+  This resource represents a long-running operation that is the result of a
+  network API call.
+
+  Attributes:
+    name (str)
+      The server-assigned name, which is only unique within the same service that
+      originally returns it. If you use the default HTTP mapping, the
+      `name` should be a resource name ending with `operations/{unique_id}`.
+    metadata (object)
+      Service-specific metadata associated with the operation.  It typically
+      contains progress information and common metadata such as create time.
+      Some services might not provide such metadata.  Any method that returns a
+      long-running operation should document the metadata type, if any.
+    done (bool)
+      If the value is `false`, it means the operation is still in progress.
+      If `true`, the operation is completed, and either `error` or `response` is
+      available.
+    error (Operation.Status)
+      The error result of the operation in case of failure or cancellation.
+    response (object)
+      The normal, successful response of the operation.  If the original
+      method returns no data on success, such as `Delete`, the response is
+      `google.protobuf.Empty`.  If the original method is standard
+      `Get`/`Create`/`Update`, the response should be the resource.  For other
+      methods, the response should have the type `XxxResponse`, where `Xxx`
+      is the original method name.  For example, if the original method name
+      is `TakeSnapshot()`, the inferred response type is
+      `TakeSnapshotResponse`.
+  """
+
+  class Status(KaggleObject):
+    r"""
+    Attributes:
+      code (int)
+        The HTTP status code that corresponds to `google.rpc.Status.code`.
+      message (str)
+        This corresponds to `google.rpc.Status.message`.
+    """
+
+    def __init__(self):
+      self._code = 0
+      self._message = ""
+      self._freeze()
+
+    @property
+    def code(self) -> int:
+      """The HTTP status code that corresponds to `google.rpc.Status.code`."""
+      return self._code
+
+    @code.setter
+    def code(self, code: int):
+      if code is None:
+        del self.code
+        return
+      if not isinstance(code, int):
+        raise TypeError('code must be of type int')
+      self._code = code
+
+    @property
+    def message(self) -> str:
+      """This corresponds to `google.rpc.Status.message`."""
+      return self._message
+
+    @message.setter
+    def message(self, message: str):
+      if message is None:
+        del self.message
+        return
+      if not isinstance(message, str):
+        raise TypeError('message must be of type str')
+      self._message = message
+
+
+  def __init__(self):
+    self._name = ""
+    self._metadata = None
+    self._done = False
+    self._error = None
+    self._response = None
+    self._freeze()
+
+  @property
+  def name(self) -> str:
+    r"""
+    The server-assigned name, which is only unique within the same service that
+    originally returns it. If you use the default HTTP mapping, the
+    `name` should be a resource name ending with `operations/{unique_id}`.
+    """
+    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 metadata(self) -> object:
+    r"""
+    Service-specific metadata associated with the operation.  It typically
+    contains progress information and common metadata such as create time.
+    Some services might not provide such metadata.  Any method that returns a
+    long-running operation should document the metadata type, if any.
+    """
+    return self._metadata
+
+  @metadata.setter
+  def metadata(self, metadata: object):
+    if metadata is None:
+      del self.metadata
+      return
+    if not isinstance(metadata, object):
+      raise TypeError('metadata must be of type object')
+    self._metadata = metadata
+
+  @property
+  def done(self) -> bool:
+    r"""
+    If the value is `false`, it means the operation is still in progress.
+    If `true`, the operation is completed, and either `error` or `response` is
+    available.
+    """
+    return self._done
+
+  @done.setter
+  def done(self, done: bool):
+    if done is None:
+      del self.done
+      return
+    if not isinstance(done, bool):
+      raise TypeError('done must be of type bool')
+    self._done = done
+
+  @property
+  def error(self) -> Optional['Operation.Status']:
+    """The error result of the operation in case of failure or cancellation."""
+    return self._error or None
+
+  @error.setter
+  def error(self, error: Optional['Operation.Status']):
+    if error is None:
+      del self.error
+      return
+    if not isinstance(error, Operation.Status):
+      raise TypeError('error must be of type Operation.Status')
+    del self.response
+    self._error = error
+
+  @property
+  def response(self) -> object:
+    r"""
+    The normal, successful response of the operation.  If the original
+    method returns no data on success, such as `Delete`, the response is
+    `google.protobuf.Empty`.  If the original method is standard
+    `Get`/`Create`/`Update`, the response should be the resource.  For other
+    methods, the response should have the type `XxxResponse`, where `Xxx`
+    is the original method name.  For example, if the original method name
+    is `TakeSnapshot()`, the inferred response type is
+    `TakeSnapshotResponse`.
+    """
+    return self._response or None
+
+  @response.setter
+  def response(self, response: object):
+    if response is None:
+      del self.response
+      return
+    if not isinstance(response, object):
+      raise TypeError('response must be of type object')
+    del self.error
+    self._response = response
+
+
+Operation.Status._fields = [
+  FieldMetadata("code", "code", "_code", int, 0, PredefinedSerializer()),
+  FieldMetadata("message", "message", "_message", str, "", PredefinedSerializer()),
+]
+
+Operation._fields = [
+  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
+  FieldMetadata("metadata", "metadata", "_metadata", object, None, PredefinedSerializer()),
+  FieldMetadata("done", "done", "_done", bool, False, PredefinedSerializer()),
+  FieldMetadata("error", "error", "_error", Operation.Status, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("response", "response", "_response", object, None, PredefinedSerializer(), optional=True),
+]
+

kagglesdk/common/types/operations_service.py

@@ -0,0 +1,48 @@
+from kagglesdk.kaggle_object import *
+
+class GetOperationRequest(KaggleObject):
+  r"""
+  The request message for
+  [Operations.GetOperation][google.longrunning.Operations.GetOperation].
+
+  Attributes:
+    name (str)
+      The name of the operation resource.
+  """
+
+  def __init__(self):
+    self._name = ""
+    self._freeze()
+
+  @property
+  def name(self) -> str:
+    """The name of the operation resource."""
+    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
+
+  def endpoint(self):
+    path = '/api/v1/operations/get'
+    return path.format_map(self.to_field_map(self))
+
+
+  @staticmethod
+  def method():
+    return 'POST'
+
+  @staticmethod
+  def body_fields():
+    return '*'
+
+
+GetOperationRequest._fields = [
+  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
+]
+

kagglesdk/community/types/content_enums.py

@@ -0,0 +1,44 @@
+import enum
+
+class ContentState(enum.Enum):
+  """Keep synced with /Kaggle.Sdk/cloud/kaggle/moderation/sor.proto"""
+  CONTENT_STATE_UNSPECIFIED = 0
+  PENDING_CLASSIFICATION = 1
+  r"""
+  Awaiting abuse classification. This exists as a non-visible state prior to
+  classification.
+  """
+  PUBLISHED = 2
+  r"""
+  Publicly viewable, although access may be restricted outside of its content
+  state.
+  """
+  TEMPORARILY_QUARANTINED = 3
+  r"""
+  Quarantined by an admin or by the system. This means that the content is
+  only visible to the user and admins, however users are able to toggle their
+  content out of this state.
+  """
+  PERMANENTLY_QUARANTINED = 4
+  r"""
+  Quarantined by an admin or by the system, the user cannot toggle their
+  content's state back to public.
+  """
+  USER_DELETED = 5
+  """Deleted by the user."""
+  SYSTEM_DELETED = 6
+  """Deleted by an admin or by a system account."""
+  PENDING_PERMANENT_DELETE = 7
+  """Awaiting hard deletion."""
+  DRAFT = 8
+  r"""
+  Initial state of entity that has never been previously published.
+  Unable to return back to Draft state once published.
+  State flow chart example: http://screen/8vDypV7HPeuHBFK
+  """
+  UNPUBLISHED = 9
+  r"""
+  Intermediate stage that has either been upgraded from the Draft state or
+  downgraded from the Published state.
+  """
+