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

kagglesdk/security/types/roles.py

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

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

@@ -9,35 +9,33 @@ import unittest
 
 class TestClient(unittest.TestCase):
 
-  def setUp(self):
-    print('setup             class:%s' % self)
+    def setUp(self):
+        print("setup             class:%s" % self)
 
-  def tearDown(self):
-    print('teardown          class:TestStuff')
+    def tearDown(self):
+        print("teardown          class:TestStuff")
 
-  # Environment
+    # Environment
 
-  def test_kaggle_environment(self):
-    os.environ['KAGGLE_API_ENVIRONMENT'] = 'PROD'
+    def test_kaggle_environment(self):
+        os.environ["KAGGLE_API_ENVIRONMENT"] = "PROD"
 
-    env = kaggle_env.get_env()
-    self.assertEqual(env, KaggleEnv.PROD)
+        env = kaggle_env.get_env()
+        self.assertEqual(env, KaggleEnv.PROD)
 
-    endpoint = kaggle_env.get_endpoint(env)
-    self.assertEqual(endpoint, 'https://www.kaggle.com')
+        endpoint = kaggle_env.get_endpoint(env)
+        self.assertEqual(endpoint, "https://www.kaggle.com")
 
-  # Client
+    # Client
 
-  def test_kaggle_client(self):
-    client = KaggleClient(
-        env=KaggleEnv.PROD, verbose=False, username='dinosaur', password='xxxxxxxxxxxx'
-    )
+    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)
+        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()
+if __name__ == "__main__":
+    unittest.main()

kagglesdk/users/services/account_service.py

@@ -1,11 +1,23 @@
 from kagglesdk.kaggle_http_client import KaggleHttpClient
-from kagglesdk.users.types.account_service import GenerateAccessTokenRequest, GenerateAccessTokenResponse
+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:

kagglesdk/users/services/group_api_service.py

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

@@ -11,6 +11,111 @@ class ApiVersion(enum.Enum):
   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:
@@ -48,7 +153,7 @@ class GenerateAccessTokenRequest(KaggleObject):
     return self._refresh_token or ""
 
   @refresh_token.setter
-  def refresh_token(self, refresh_token: str):
+  def refresh_token(self, refresh_token: Optional[str]):
     if refresh_token is None:
       del self.refresh_token
       return
@@ -136,10 +241,16 @@ 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
@@ -155,36 +266,67 @@ class GenerateAccessTokenResponse(KaggleObject):
       raise TypeError('token must be of type str')
     self._token = token
 
+  @property
+  def expires_in(self) -> int:
+    return self._expires_in
 
-class AuthorizationContext(KaggleObject):
-  r"""
-  Attributes:
-    kernel_session_id (int)
-      If set, access token is restricted to be used only from the specified
-      notebook session.
-  """
+  @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
 
-  def __init__(self):
-    self._kernel_session_id = None
-    self._freeze()
+  @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 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
+  def user_id(self) -> int:
+    return self._user_id
 
-  @kernel_session_id.setter
-  def kernel_session_id(self, kernel_session_id: int):
-    if kernel_session_id is None:
-      del self.kernel_session_id
+  @user_id.setter
+  def user_id(self, user_id: int):
+    if user_id is None:
+      del self.user_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
+    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),
@@ -196,9 +338,8 @@ GenerateAccessTokenRequest._fields = [
 
 GenerateAccessTokenResponse._fields = [
   FieldMetadata("token", "token", "_token", str, "", PredefinedSerializer()),
-]
-
-AuthorizationContext._fields = [
-  FieldMetadata("kernelSessionId", "kernel_session_id", "_kernel_session_id", int, None, PredefinedSerializer(), optional=True),
+  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()),
 ]