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

kagglesdk/security/types/roles.py

@@ -1,8 +0,0 @@
-import enum
-
-class CanonicalRole(enum.Enum):
-  CANONICAL_ROLE_UNSPECIFIED = 0
-  CANONICAL_ROLE_VIEWER = 1
-  CANONICAL_ROLE_EDITOR = 2
-  CANONICAL_ROLE_ADMIN = 3
-

kagglesdk/security/types/security_types.py

@@ -1,159 +0,0 @@
-import enum
-from kagglesdk.kaggle_object import *
-from typing import Optional
-
-class KaggleResourceType(enum.Enum):
-  r"""
-  Types of Kaggle resources on which permissions can be defined. Each entry in
-  this proto must correspond to a permission block in the Permission enum in
-  'permissions.proto'. For example COMPETITIONS_GET permission
-  applies to resource of type COMPETITIONS and thus has value of 300 because
-  COMPETITIONS_X permissions block start at 3000. The formula
-  ValueOfFirstCanonicalPermission / 10. (COMPETITIONS_GET = 3001) / 10 =>
-  (COMPETITIONS = 300).
-  Please see the documentation of the Permission enum to understand permission
-  blocks better.
-  """
-  KAGGLE_RESOURCE_TYPE_UNSPECIFIED = 0
-  KAGGLE_RESOURCE_TYPE_WILDCARD_ALL = -1
-  KAGGLE_RESOURCE_TYPE_USERS = 100
-  """---------- Shared ----------"""
-  KAGGLE_RESOURCE_TYPE_USER_ATTRIBUTES = 102
-  KAGGLE_RESOURCE_TYPE_ATTRIBUTES = 104
-  KAGGLE_RESOURCE_TYPE_ACCESS_TOKENS = 106
-  KAGGLE_RESOURCE_TYPE_API_TOKENS = 108
-  KAGGLE_RESOURCE_TYPE_SYNCHRONIZED_GROUPS = 110
-  KAGGLE_RESOURCE_TYPE_BLOBS = 112
-  KAGGLE_RESOURCE_TYPE_LICENSES = 114
-  KAGGLE_RESOURCE_TYPE_LICENSE_USER_AGREEMENTS = 116
-  KAGGLE_RESOURCE_TYPE_SEARCH_PROXY = 118
-  KAGGLE_RESOURCE_TYPE_SECRETS = 120
-  KAGGLE_RESOURCE_TYPE_SECRET_ATTACHMENTS = 122
-  KAGGLE_RESOURCE_TYPE_TAGS = 124
-  KAGGLE_RESOURCE_TYPE_RESOURCES = 130
-  KAGGLE_RESOURCE_TYPE_USER_MANAGED_GROUPS = 132
-  KAGGLE_RESOURCE_TYPE_USER_MANAGED_GROUP_INVITES = 134
-  KAGGLE_RESOURCE_TYPE_USER_MANAGED_GROUP_MEMBERSHIPS = 136
-  KAGGLE_RESOURCE_TYPE_OAUTH_CLIENTS = 138
-  KAGGLE_RESOURCE_TYPE_RESOURCE_ACCESS_GROUPS = 140
-  KAGGLE_RESOURCE_TYPE_OPERATIONS = 142
-  KAGGLE_RESOURCE_TYPE_FORUMS = 200
-  """---------- Community ----------"""
-  KAGGLE_RESOURCE_TYPE_FORUM_TOPICS = 202
-  KAGGLE_RESOURCE_TYPE_FORUM_MESSAGES = 204
-  KAGGLE_RESOURCE_TYPE_FORUM_MESSAGE_ATTACHMENTS = 208
-  KAGGLE_RESOURCE_TYPE_BADGES = 210
-  KAGGLE_RESOURCE_TYPE_USER_BADGES = 212
-  KAGGLE_RESOURCE_TYPE_BOOKMARKS = 214
-  KAGGLE_RESOURCE_TYPE_COLLECTIONS = 216
-  KAGGLE_RESOURCE_TYPE_NUDGES = 218
-  KAGGLE_RESOURCE_TYPE_ORGANIZATIONS = 220
-  KAGGLE_RESOURCE_TYPE_ORGANIZATION_MEMBERS = 224
-  KAGGLE_RESOURCE_TYPE_SUGGESTED_ITEMS = 226
-  KAGGLE_RESOURCE_TYPE_WRITE_UPS = 228
-  KAGGLE_RESOURCE_TYPE_VOTES = 230
-  KAGGLE_RESOURCE_TYPE_OPEN_GRAPH_IMAGE_METADATUM = 232
-  KAGGLE_RESOURCE_TYPE_COMPETITIONS = 300
-  """---------- Competitions ----------"""
-  KAGGLE_RESOURCE_TYPE_COMPETITION_LEADERBOARDS = 304
-  KAGGLE_RESOURCE_TYPE_EPISODES = 306
-  KAGGLE_RESOURCE_TYPE_EPISODE_AGENTS = 308
-  KAGGLE_RESOURCE_TYPE_EVALUATION_ALGORITHMS = 310
-  KAGGLE_RESOURCE_TYPE_HOST_SEGMENTS = 312
-  KAGGLE_RESOURCE_TYPE_PAGES = 314
-  KAGGLE_RESOURCE_TYPE_SUBMISSIONS = 316
-  KAGGLE_RESOURCE_TYPE_SUBMISSION_RESCORES = 318
-  KAGGLE_RESOURCE_TYPE_TEAMS = 320
-  KAGGLE_RESOURCE_TYPE_TEAM_MERGE_REQUESTS = 322
-  KAGGLE_RESOURCE_TYPE_HACKATHON_WRITE_UPS = 324
-  KAGGLE_RESOURCE_TYPE_COMPETITION_METRIC_VERSIONS = 326
-  KAGGLE_RESOURCE_TYPE_DATASETS = 400
-  """---------- Datasets ----------"""
-  KAGGLE_RESOURCE_TYPE_DATASET_VERSIONS = 404
-  KAGGLE_RESOURCE_TYPE_DATASET_SUGGESTION_BUNDLES = 406
-  KAGGLE_RESOURCE_TYPE_DATABUNDLES = 408
-  KAGGLE_RESOURCE_TYPE_DATABUNDLE_VERSIONS = 410
-  KAGGLE_RESOURCE_TYPE_DATA_VIEWS = 412
-  KAGGLE_RESOURCE_TYPE_KERNELS = 500
-  """---------- Kernels ----------"""
-  KAGGLE_RESOURCE_TYPE_KERNEL_SESSIONS = 504
-  KAGGLE_RESOURCE_TYPE_KERNEL_SNIPPETS = 508
-  KAGGLE_RESOURCE_TYPE_KERNEL_SOURCE_REFERENCES = 510
-  KAGGLE_RESOURCE_TYPE_KERNEL_VERSIONS = 512
-  KAGGLE_RESOURCE_TYPE_RESOURCE_REFERENCES = 520
-  KAGGLE_RESOURCE_TYPE_MODELS = 600
-  """---------- Models ----------"""
-  KAGGLE_RESOURCE_TYPE_MODEL_INSTANCES = 608
-  KAGGLE_RESOURCE_TYPE_MODEL_INSTANCE_VERSIONS = 610
-  KAGGLE_RESOURCE_TYPE_MODEL_VERSIONS = 612
-  KAGGLE_RESOURCE_TYPE_GATING_AGREEMENTS = 614
-  KAGGLE_RESOURCE_TYPE_GATING_AGREEMENTS_USER_CONSENTS = 616
-  KAGGLE_RESOURCE_TYPE_BENCHMARKS = 700
-  """---------- Benchmarks ----------"""
-  KAGGLE_RESOURCE_TYPE_BENCHMARK_VERSIONS = 704
-  KAGGLE_RESOURCE_TYPE_BENCHMARK_MODELS = 706
-  KAGGLE_RESOURCE_TYPE_BENCHMARK_MODEL_VERSIONS = 708
-  KAGGLE_RESOURCE_TYPE_BENCHMARK_TASKS = 710
-  KAGGLE_RESOURCE_TYPE_BENCHMARK_TASK_VERSIONS = 712
-  KAGGLE_RESOURCE_TYPE_BENCHMARK_TASK_RUNS = 714
-
-class KaggleResourceId(KaggleObject):
-  r"""
-  Attributes:
-    type (KaggleResourceType)
-    id (int)
-    hash_link (str)
-  """
-
-  def __init__(self):
-    self._type = KaggleResourceType.KAGGLE_RESOURCE_TYPE_UNSPECIFIED
-    self._id = 0
-    self._hash_link = None
-    self._freeze()
-
-  @property
-  def type(self) -> 'KaggleResourceType':
-    return self._type
-
-  @type.setter
-  def type(self, type: 'KaggleResourceType'):
-    if type is None:
-      del self.type
-      return
-    if not isinstance(type, KaggleResourceType):
-      raise TypeError('type must be of type KaggleResourceType')
-    self._type = type
-
-  @property
-  def id(self) -> int:
-    return self._id
-
-  @id.setter
-  def id(self, id: int):
-    if id is None:
-      del self.id
-      return
-    if not isinstance(id, int):
-      raise TypeError('id must be of type int')
-    self._id = id
-
-  @property
-  def hash_link(self) -> str:
-    return self._hash_link or ""
-
-  @hash_link.setter
-  def hash_link(self, hash_link: Optional[str]):
-    if hash_link is None:
-      del self.hash_link
-      return
-    if not isinstance(hash_link, str):
-      raise TypeError('hash_link must be of type str')
-    self._hash_link = hash_link
-
-
-KaggleResourceId._fields = [
-  FieldMetadata("type", "type", "_type", KaggleResourceType, KaggleResourceType.KAGGLE_RESOURCE_TYPE_UNSPECIFIED, EnumSerializer()),
-  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
-  FieldMetadata("hashLink", "hash_link", "_hash_link", str, None, PredefinedSerializer(), optional=True),
-]
-

kagglesdk/test/test_client.py

@@ -1,41 +0,0 @@
-from kagglesdk import kaggle_env
-from kagglesdk import KaggleClient, KaggleEnv
-
-# python -m unittest tests.test_authenticate
-
-import os
-import unittest
-
-
-class TestClient(unittest.TestCase):
-
-    def setUp(self):
-        print("setup             class:%s" % self)
-
-    def tearDown(self):
-        print("teardown          class:TestStuff")
-
-    # Environment
-
-    def test_kaggle_environment(self):
-        os.environ["KAGGLE_API_ENVIRONMENT"] = "PROD"
-
-        env = kaggle_env.get_env()
-        self.assertEqual(env, KaggleEnv.PROD)
-
-        endpoint = kaggle_env.get_endpoint(env)
-        self.assertEqual(endpoint, "https://www.kaggle.com")
-
-    # Client
-
-    def test_kaggle_client(self):
-        client = KaggleClient(env=KaggleEnv.PROD, verbose=False, username="dinosaur", password="xxxxxxxxxxxx")
-
-        self.assertEqual(client.username, "dinosaur")
-        self.assertEqual(client.password, "xxxxxxxxxxxx")
-        self.assertEqual(client.http_client()._endpoint, "https://www.kaggle.com")
-        self.assertEqual(client.http_client()._verbose, False)
-
-
-if __name__ == "__main__":
-    unittest.main()

kagglesdk/users/services/account_service.py

@@ -1,31 +0,0 @@
-from kagglesdk.kaggle_http_client import KaggleHttpClient
-from kagglesdk.users.types.account_service import ExpireApiTokenRequest, GenerateAccessTokenRequest, GenerateAccessTokenResponse
-
-class AccountClient(object):
-
-  def __init__(self, client: KaggleHttpClient):
-    self._client = client
-
-  def expire_api_token(self, request: ExpireApiTokenRequest = None):
-    r"""
-    Args:
-      request (ExpireApiTokenRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ExpireApiTokenRequest()
-
-    self._client.call("users.AccountService", "ExpireApiToken", request, None)
-
-  def generate_access_token(self, request: GenerateAccessTokenRequest = None) -> GenerateAccessTokenResponse:
-    r"""
-    Args:
-      request (GenerateAccessTokenRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = GenerateAccessTokenRequest()
-
-    return self._client.call("users.AccountService", "GenerateAccessToken", request, GenerateAccessTokenResponse)

kagglesdk/users/services/group_api_service.py

@@ -1,31 +0,0 @@
-from kagglesdk.kaggle_http_client import KaggleHttpClient
-from kagglesdk.users.types.group_api_service import ApiListSynchronizedGroupMembershipsRequest, ApiListSynchronizedGroupMembershipsResponse, ApiListUserManagedGroupMembershipsRequest, ApiListUserManagedGroupMembershipsResponse
-
-class GroupApiClient(object):
-
-  def __init__(self, client: KaggleHttpClient):
-    self._client = client
-
-  def list_user_managed_group_memberships(self, request: ApiListUserManagedGroupMembershipsRequest = None) -> ApiListUserManagedGroupMembershipsResponse:
-    r"""
-    Args:
-      request (ApiListUserManagedGroupMembershipsRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiListUserManagedGroupMembershipsRequest()
-
-    return self._client.call("users.GroupApiService", "ListUserManagedGroupMemberships", request, ApiListUserManagedGroupMembershipsResponse)
-
-  def list_synchronized_group_memberships(self, request: ApiListSynchronizedGroupMembershipsRequest = None) -> ApiListSynchronizedGroupMembershipsResponse:
-    r"""
-    Args:
-      request (ApiListSynchronizedGroupMembershipsRequest):
-        The request object; initialized to empty instance if not specified.
-    """
-
-    if request is None:
-      request = ApiListSynchronizedGroupMembershipsRequest()
-
-    return self._client.call("users.GroupApiService", "ListSynchronizedGroupMemberships", request, ApiListSynchronizedGroupMembershipsResponse)

kagglesdk/users/types/account_service.py

@@ -1,345 +0,0 @@
-from datetime import timedelta
-import enum
-from kagglesdk.kaggle_object import *
-from kagglesdk.security.types.authentication import AuthorizationScope
-from typing import Optional, List
-
-class ApiVersion(enum.Enum):
-  API_VERSION_UNSPECIFIED = 0
-  API_VERSION_V1 = 1
-  """Publicly available ('/api/v1' endpoints)."""
-  API_VERSION_V2 = 2
-  """Experimental, admin-only, internal ('/api/i' endpoints)."""
-
-class AuthorizationContext(KaggleObject):
-  r"""
-  Attributes:
-    kernel_session_id (int)
-      If set, access token is restricted to be used only from the specified
-      notebook session.
-  """
-
-  def __init__(self):
-    self._kernel_session_id = None
-    self._freeze()
-
-  @property
-  def kernel_session_id(self) -> int:
-    r"""
-    If set, access token is restricted to be used only from the specified
-    notebook session.
-    """
-    return self._kernel_session_id or 0
-
-  @kernel_session_id.setter
-  def kernel_session_id(self, kernel_session_id: Optional[int]):
-    if kernel_session_id is None:
-      del self.kernel_session_id
-      return
-    if not isinstance(kernel_session_id, int):
-      raise TypeError('kernel_session_id must be of type int')
-    self._kernel_session_id = kernel_session_id
-
-
-class ExpireApiTokenRequest(KaggleObject):
-  r"""
-  Attributes:
-    token_id (int)
-      Id of the token.
-    token (str)
-      Value of the token.
-    reason (str)
-      Reason why this token is expired.
-  """
-
-  def __init__(self):
-    self._token_id = None
-    self._token = None
-    self._reason = None
-    self._freeze()
-
-  @property
-  def token_id(self) -> int:
-    """Id of the token."""
-    return self._token_id or 0
-
-  @token_id.setter
-  def token_id(self, token_id: int):
-    if token_id is None:
-      del self.token_id
-      return
-    if not isinstance(token_id, int):
-      raise TypeError('token_id must be of type int')
-    del self.token
-    self._token_id = token_id
-
-  @property
-  def token(self) -> str:
-    """Value of the token."""
-    return self._token or ""
-
-  @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')
-    del self.token_id
-    self._token = token
-
-  @property
-  def reason(self) -> str:
-    """Reason why this token is expired."""
-    return self._reason or ""
-
-  @reason.setter
-  def reason(self, reason: Optional[str]):
-    if reason is None:
-      del self.reason
-      return
-    if not isinstance(reason, str):
-      raise TypeError('reason must be of type str')
-    self._reason = reason
-
-  def endpoint(self):
-    path = '/api/v1/tokens/revoke'
-    return path.format_map(self.to_field_map(self))
-
-
-  @staticmethod
-  def method():
-    return 'POST'
-
-  @staticmethod
-  def body_fields():
-    return '*'
-
-
-class GenerateAccessTokenRequest(KaggleObject):
-  r"""
-  Attributes:
-    refresh_token (str)
-      Refresh token used to generate a short-lived restricted access token.
-      If not specified current user credentials will be used to generate an
-      unrestricted access token.
-    api_version (ApiVersion)
-      Version of the Kaggle API for which this token will be used.
-    expiration_duration (timedelta)
-      Token expiration.
-    authorization_context (AuthorizationContext)
-      On which context (such as a Kaggle notebook) this token can be used.
-    authorization_scopes (AuthorizationScope)
-      Set of scopes to further restrict the token. If 'refresh_token' is
-      specified, these should be a subset of the scopes allowed by the
-      'refresh_token'.
-  """
-
-  def __init__(self):
-    self._refresh_token = None
-    self._api_version = ApiVersion.API_VERSION_UNSPECIFIED
-    self._expiration_duration = None
-    self._authorization_context = None
-    self._authorization_scopes = []
-    self._freeze()
-
-  @property
-  def refresh_token(self) -> str:
-    r"""
-    Refresh token used to generate a short-lived restricted access token.
-    If not specified current user credentials will be used to generate an
-    unrestricted access token.
-    """
-    return self._refresh_token or ""
-
-  @refresh_token.setter
-  def refresh_token(self, refresh_token: Optional[str]):
-    if refresh_token is None:
-      del self.refresh_token
-      return
-    if not isinstance(refresh_token, str):
-      raise TypeError('refresh_token must be of type str')
-    self._refresh_token = refresh_token
-
-  @property
-  def api_version(self) -> 'ApiVersion':
-    """Version of the Kaggle API for which this token will be used."""
-    return self._api_version
-
-  @api_version.setter
-  def api_version(self, api_version: 'ApiVersion'):
-    if api_version is None:
-      del self.api_version
-      return
-    if not isinstance(api_version, ApiVersion):
-      raise TypeError('api_version must be of type ApiVersion')
-    self._api_version = api_version
-
-  @property
-  def expiration_duration(self) -> timedelta:
-    """Token expiration."""
-    return self._expiration_duration
-
-  @expiration_duration.setter
-  def expiration_duration(self, expiration_duration: timedelta):
-    if expiration_duration is None:
-      del self.expiration_duration
-      return
-    if not isinstance(expiration_duration, timedelta):
-      raise TypeError('expiration_duration must be of type timedelta')
-    self._expiration_duration = expiration_duration
-
-  @property
-  def authorization_context(self) -> Optional['AuthorizationContext']:
-    """On which context (such as a Kaggle notebook) this token can be used."""
-    return self._authorization_context
-
-  @authorization_context.setter
-  def authorization_context(self, authorization_context: Optional['AuthorizationContext']):
-    if authorization_context is None:
-      del self.authorization_context
-      return
-    if not isinstance(authorization_context, AuthorizationContext):
-      raise TypeError('authorization_context must be of type AuthorizationContext')
-    self._authorization_context = authorization_context
-
-  @property
-  def authorization_scopes(self) -> Optional[List[Optional['AuthorizationScope']]]:
-    r"""
-    Set of scopes to further restrict the token. If 'refresh_token' is
-    specified, these should be a subset of the scopes allowed by the
-    'refresh_token'.
-    """
-    return self._authorization_scopes
-
-  @authorization_scopes.setter
-  def authorization_scopes(self, authorization_scopes: Optional[List[Optional['AuthorizationScope']]]):
-    if authorization_scopes is None:
-      del self.authorization_scopes
-      return
-    if not isinstance(authorization_scopes, list):
-      raise TypeError('authorization_scopes must be of type list')
-    if not all([isinstance(t, AuthorizationScope) for t in authorization_scopes]):
-      raise TypeError('authorization_scopes must contain only items of type AuthorizationScope')
-    self._authorization_scopes = authorization_scopes
-
-  def endpoint(self):
-    path = '/api/v1/access-tokens/generate'
-    return path.format_map(self.to_field_map(self))
-
-
-  @staticmethod
-  def method():
-    return 'POST'
-
-  @staticmethod
-  def body_fields():
-    return '*'
-
-
-class GenerateAccessTokenResponse(KaggleObject):
-  r"""
-  Attributes:
-    token (str)
-    expires_in (int)
-    user_name (str)
-    user_id (int)
-  """
-
-  def __init__(self):
-    self._token = ""
-    self._expires_in = 0
-    self._user_name = ""
-    self._user_id = 0
-    self._freeze()
-
-  @property
-  def token(self) -> str:
-    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 expires_in(self) -> int:
-    return self._expires_in
-
-  @expires_in.setter
-  def expires_in(self, expires_in: int):
-    if expires_in is None:
-      del self.expires_in
-      return
-    if not isinstance(expires_in, int):
-      raise TypeError('expires_in must be of type int')
-    self._expires_in = expires_in
-
-  @property
-  def user_name(self) -> str:
-    return self._user_name
-
-  @user_name.setter
-  def user_name(self, user_name: str):
-    if user_name is None:
-      del self.user_name
-      return
-    if not isinstance(user_name, str):
-      raise TypeError('user_name must be of type str')
-    self._user_name = user_name
-
-  @property
-  def user_id(self) -> int:
-    return self._user_id
-
-  @user_id.setter
-  def user_id(self, user_id: int):
-    if user_id is None:
-      del self.user_id
-      return
-    if not isinstance(user_id, int):
-      raise TypeError('user_id must be of type int')
-    self._user_id = user_id
-
-  @property
-  def expiresIn(self):
-    return self.expires_in
-
-  @property
-  def userName(self):
-    return self.user_name
-
-  @property
-  def userId(self):
-    return self.user_id
-
-
-AuthorizationContext._fields = [
-  FieldMetadata("kernelSessionId", "kernel_session_id", "_kernel_session_id", int, None, PredefinedSerializer(), optional=True),
-]
-
-ExpireApiTokenRequest._fields = [
-  FieldMetadata("tokenId", "token_id", "_token_id", int, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("token", "token", "_token", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("reason", "reason", "_reason", str, None, PredefinedSerializer(), optional=True),
-]
-
-GenerateAccessTokenRequest._fields = [
-  FieldMetadata("refreshToken", "refresh_token", "_refresh_token", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("apiVersion", "api_version", "_api_version", ApiVersion, ApiVersion.API_VERSION_UNSPECIFIED, EnumSerializer()),
-  FieldMetadata("expirationDuration", "expiration_duration", "_expiration_duration", timedelta, None, TimeDeltaSerializer()),
-  FieldMetadata("authorizationContext", "authorization_context", "_authorization_context", AuthorizationContext, None, KaggleObjectSerializer()),
-  FieldMetadata("authorizationScopes", "authorization_scopes", "_authorization_scopes", AuthorizationScope, [], ListSerializer(KaggleObjectSerializer())),
-]
-
-GenerateAccessTokenResponse._fields = [
-  FieldMetadata("token", "token", "_token", str, "", PredefinedSerializer()),
-  FieldMetadata("expiresIn", "expires_in", "_expires_in", int, 0, PredefinedSerializer()),
-  FieldMetadata("userName", "user_name", "_user_name", str, "", PredefinedSerializer()),
-  FieldMetadata("userId", "user_id", "_user_id", int, 0, PredefinedSerializer()),
-]
-