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

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

kagglesdk/community/types/content_enums.py

@@ -1,44 +0,0 @@
-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.
-  """
-