kaggle 1.7.4.2__py3-none-any.whl → 1.8.0__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,37 +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

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

@@ -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

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