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

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),
-]
-

kagglesdk/common/types/http_redirect.py

@@ -1,105 +0,0 @@
-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/common/types/operations.py

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

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