kagglesdk 0.1.0__py3-none-any.whl

kagglesdk/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.1.0"
+
+from kagglesdk.kaggle_client import KaggleClient
+from kagglesdk.kaggle_creds import KaggleCredentials
+from kagglesdk.kaggle_env import get_access_token_from_env, KaggleEnv
+from kagglesdk.kaggle_oauth import KaggleOAuth

kagglesdk/admin/services/inbox_file_service.py

@@ -0,0 +1,22 @@
+from kagglesdk.admin.types.inbox_file_service import CreateInboxFileRequest, CreateInboxFileResponse
+from kagglesdk.kaggle_http_client import KaggleHttpClient
+
+class InboxFileClient(object):
+  """File drop/pickup functionality."""
+
+  def __init__(self, client: KaggleHttpClient):
+    self._client = client
+
+  def create_inbox_file(self, request: CreateInboxFileRequest = None) -> CreateInboxFileResponse:
+    r"""
+    Creates (aka 'drops') a new file into the inbox.
+
+    Args:
+      request (CreateInboxFileRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = CreateInboxFileRequest()
+
+    return self._client.call("admin.InboxFileService", "CreateInboxFile", request, CreateInboxFileResponse)

kagglesdk/admin/types/inbox_file_service.py

@@ -0,0 +1,74 @@
+from kagglesdk.kaggle_object import *
+
+class CreateInboxFileRequest(KaggleObject):
+  r"""
+  Attributes:
+    virtual_directory (str)
+      Directory name used for tagging the uploaded file.
+    blob_file_token (str)
+      Token representing the uploaded file.
+  """
+
+  def __init__(self):
+    self._virtual_directory = ""
+    self._blob_file_token = ""
+    self._freeze()
+
+  @property
+  def virtual_directory(self) -> str:
+    """Directory name used for tagging the uploaded file."""
+    return self._virtual_directory
+
+  @virtual_directory.setter
+  def virtual_directory(self, virtual_directory: str):
+    if virtual_directory is None:
+      del self.virtual_directory
+      return
+    if not isinstance(virtual_directory, str):
+      raise TypeError('virtual_directory must be of type str')
+    self._virtual_directory = virtual_directory
+
+  @property
+  def blob_file_token(self) -> str:
+    """Token representing the uploaded file."""
+    return self._blob_file_token
+
+  @blob_file_token.setter
+  def blob_file_token(self, blob_file_token: str):
+    if blob_file_token is None:
+      del self.blob_file_token
+      return
+    if not isinstance(blob_file_token, str):
+      raise TypeError('blob_file_token must be of type str')
+    self._blob_file_token = blob_file_token
+
+  def endpoint(self):
+    path = '/api/v1/inbox/files/create'
+    return path.format_map(self.to_field_map(self))
+
+
+  @staticmethod
+  def method():
+    return 'POST'
+
+  @staticmethod
+  def body_fields():
+    return '*'
+
+
+class CreateInboxFileResponse(KaggleObject):
+  r"""
+  NOTE: This is sent to non-admins, so we're intentionally *NOT* sending back
+  the full InboxFile (with its URL for a direct download).
+
+  """
+
+  pass
+
+CreateInboxFileRequest._fields = [
+  FieldMetadata("virtualDirectory", "virtual_directory", "_virtual_directory", str, "", PredefinedSerializer()),
+  FieldMetadata("blobFileToken", "blob_file_token", "_blob_file_token", str, "", PredefinedSerializer()),
+]
+
+CreateInboxFileResponse._fields = []
+

kagglesdk/blobs/services/blob_api_service.py

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

@@ -0,0 +1,177 @@
+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/types/file_download.py

@@ -0,0 +1,102 @@
+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),
+]
+

kagglesdk/common/types/http_redirect.py

@@ -0,0 +1,105 @@
+from datetime import timedelta
+from kagglesdk.kaggle_object import *
+from typing import Optional
+
+class HttpRedirect(KaggleObject):
+  r"""
+  Represents an HTTP redirect (e.g. 301 or 302) response.
+  Patterned after ASP.NET MVC's RedirectResult.
+
+  Attributes:
+    url (str)
+      Destination URL for the redirect.
+    permanent (bool)
+      Should it be an HTTP 301 (permanent) redirect or just temporary (HTTP
+      302)?.
+    bypass_encoding (bool)
+      When `true`, the `url` is already encoded, so bypass `UriHelper.Encode`.
+      Otherwise, invoke `UriHelper.Encode` on the `url` before returning to the
+      client.
+    expiry (timedelta)
+      Specifies how long the redirected url can be cached.
+  """
+
+  def __init__(self):
+    self._url = ""
+    self._permanent = False
+    self._bypass_encoding = None
+    self._expiry = None
+    self._freeze()
+
+  @property
+  def url(self) -> str:
+    """Destination URL for the redirect."""
+    return self._url
+
+  @url.setter
+  def url(self, url: str):
+    if url is None:
+      del self.url
+      return
+    if not isinstance(url, str):
+      raise TypeError('url must be of type str')
+    self._url = url
+
+  @property
+  def permanent(self) -> bool:
+    r"""
+    Should it be an HTTP 301 (permanent) redirect or just temporary (HTTP
+    302)?.
+    """
+    return self._permanent
+
+  @permanent.setter
+  def permanent(self, permanent: bool):
+    if permanent is None:
+      del self.permanent
+      return
+    if not isinstance(permanent, bool):
+      raise TypeError('permanent must be of type bool')
+    self._permanent = permanent
+
+  @property
+  def bypass_encoding(self) -> bool:
+    r"""
+    When `true`, the `url` is already encoded, so bypass `UriHelper.Encode`.
+    Otherwise, invoke `UriHelper.Encode` on the `url` before returning to the
+    client.
+    """
+    return self._bypass_encoding or False
+
+  @bypass_encoding.setter
+  def bypass_encoding(self, bypass_encoding: Optional[bool]):
+    if bypass_encoding is None:
+      del self.bypass_encoding
+      return
+    if not isinstance(bypass_encoding, bool):
+      raise TypeError('bypass_encoding must be of type bool')
+    self._bypass_encoding = bypass_encoding
+
+  @property
+  def expiry(self) -> timedelta:
+    """Specifies how long the redirected url can be cached."""
+    return self._expiry
+
+  @expiry.setter
+  def expiry(self, expiry: timedelta):
+    if expiry is None:
+      del self.expiry
+      return
+    if not isinstance(expiry, timedelta):
+      raise TypeError('expiry must be of type timedelta')
+    self._expiry = expiry
+
+  @classmethod
+  def prepare_from(cls, http_response):
+    return http_response
+
+
+HttpRedirect._fields = [
+  FieldMetadata("url", "url", "_url", str, "", PredefinedSerializer()),
+  FieldMetadata("permanent", "permanent", "_permanent", bool, False, PredefinedSerializer()),
+  FieldMetadata("bypassEncoding", "bypass_encoding", "_bypass_encoding", bool, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("expiry", "expiry", "_expiry", timedelta, None, TimeDeltaSerializer()),
+]
+

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.
+  """
+