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

kagglesdk/kaggle_object.py

@@ -5,31 +5,36 @@ from google.protobuf.field_mask_pb2 import FieldMask
 
 
 class ObjectSerializer(object):
+
   def __init__(self, to_dict_value, from_dict_value):
     self.to_dict_value = to_dict_value
     self.from_dict_value = from_dict_value
 
 
 class PredefinedSerializer(ObjectSerializer):
+
   def __init__(self):
     """Predefined objects such as int, float etc are serialized/deserialized directly."""
     ObjectSerializer.__init__(self, lambda cls, v, _: v, lambda cls, v: v)
 
 
 # Adapted from https://stackoverflow.com/questions/1175208/elegant-python-function-to-convert-camelcase-to-snake-case
-_pascal_to_upper_snake_case_regex = re.compile('((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))')
+_pascal_to_upper_snake_case_regex = re.compile(
+    '((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))'
+)
 
 
 def _pascal_case_to_upper_snake_case(string):
   return _pascal_to_upper_snake_case_regex.sub(r'_\1', string).upper()
 
 
-def _convert (camel_input):
+def _convert(camel_input):
   words = re.findall(r'[A-Z]?[a-z]+|[A-Z]{2,}(?=[A-Z][a-z]|\d|\W|$)|\d+', camel_input)
   return '_'.join(map(str.lower, words))
 
 
 class EnumSerializer(ObjectSerializer):
+
   def __init__(self):
     """
     Enum objects are serialized using their ".name" field and deserialized by indexing the string in the Enum type.
@@ -40,21 +45,23 @@ class EnumSerializer(ObjectSerializer):
     foo.name # => returns "TEST"
     Foo["TEST"] # => returns Foo.TEST enum value.
     """
-    ObjectSerializer.__init__(self,
-                              lambda cls, v, _: EnumSerializer._to_str(cls, v),
-                              lambda cls, v: EnumSerializer._from_str(cls, v))
+    ObjectSerializer.__init__(
+        self,
+        lambda cls, v, _: EnumSerializer._to_str(cls, v),
+        lambda cls, v: EnumSerializer._from_str(cls, v),
+    )
 
   @staticmethod
   def _to_str(cls, v):
     # "v" corresponds to an enum instance: Example foo or Foo.Test above.
     # "cls" corresponds to the enum type Foo above.
-    #enum_prefix = f'{_pascal_case_to_upper_snake_case(cls.__name__)}_'
-    #if v.name.startswith(enum_prefix):
+    # enum_prefix = f'{_pascal_case_to_upper_snake_case(cls.__name__)}_'
+    # if v.name.startswith(enum_prefix):
     #  return v.name
-    #return f'{enum_prefix}{v.name}'
+    # return f'{enum_prefix}{v.name}'
     enum_prefix = f'{_pascal_case_to_upper_snake_case(cls.__name__)}_'
     if v.name.find(enum_prefix) == 0:
-      return v.name[len(enum_prefix):].lower()
+      return v.name[len(enum_prefix) :].lower()
     return v.name
 
   @staticmethod
@@ -64,13 +71,13 @@ class EnumSerializer(ObjectSerializer):
     # enum_items = {item.name: item for item in cls}
     # if v in enum_items:
     #   return enum_items[v]
-    # 
+    #
     # # Try with enum prefix. Example: EnvironmentType.JSON -> "ENVIRONMENT_TYPE_JSON"
     # enum_prefix = _pascal_case_to_upper_snake_case(cls.__name__)
     # if v.startswith(enum_prefix):
     #   ix_start = len(enum_prefix) + 1
     #   return enum_items[v[ix_start:]]
-    # 
+    #
     # return enum_items[f'{enum_prefix}_{v}']
     try:
       return cls[v]
@@ -89,33 +96,49 @@ class EnumSerializer(ObjectSerializer):
 
 
 class ListSerializer(ObjectSerializer):
+
   def __init__(self, item_serializer: ObjectSerializer):
     """
     Lists are serialized based on the type they contain. Since objects are generated from proto files, a list always
     contains objects of the same type, which is serialized/deserialized using "item_serializer".
     """
-    ObjectSerializer.__init__(self,
-                              lambda cls, l, ignore_defaults: [item_serializer.to_dict_value(cls, v, ignore_defaults) for v in l],
-                              lambda cls, l: [item_serializer.from_dict_value(cls, v) for v in l])
+    ObjectSerializer.__init__(
+        self,
+        lambda cls, l, ignore_defaults: [
+            item_serializer.to_dict_value(cls, v, ignore_defaults) for v in l
+        ],
+        lambda cls, l: [item_serializer.from_dict_value(cls, v) for v in l],
+    )
 
 
 class MapSerializer(ObjectSerializer):
+
   def __init__(self, item_serializer: ObjectSerializer):
     """
     Maps are serialized based on type of their values. Since maps keys are always predefined types, we don't need a
     serializer for them.
     """
-    ObjectSerializer.__init__(self,
-                              lambda cls, d, ignore_defaults: {k: item_serializer.to_dict_value(cls, v, ignore_defaults) for k, v in d.items()},
-                              lambda cls, d: {k: item_serializer.from_dict_value(cls, v) for k, v in d.items()})
+    ObjectSerializer.__init__(
+        self,
+        lambda cls, d, ignore_defaults: {
+            k: item_serializer.to_dict_value(cls, v, ignore_defaults)
+            for k, v in d.items()
+        },
+        lambda cls, d: {
+            k: item_serializer.from_dict_value(cls, v) for k, v in d.items()
+        },
+    )
 
 
 class DateTimeSerializer(ObjectSerializer):
+
   def __init__(self):
     """Date times are serialized/deserialized as a string in iso format"""
-    ObjectSerializer.__init__(self,
-                              lambda cls, dt, _: DateTimeSerializer._to_str(dt),
-                              lambda _, v: DateTimeSerializer._from_str(v))
+    ObjectSerializer.__init__(
+        self,
+        lambda cls, dt, _: DateTimeSerializer._to_str(dt),
+        lambda _, v: DateTimeSerializer._from_str(v),
+    )
 
   @staticmethod
   def _to_str(dt):
@@ -132,15 +155,18 @@ class DateTimeSerializer(ObjectSerializer):
     try:
       return datetime.fromisoformat(f'{dt}.{millis}')
     except ValueError:
-      return datetime.fromisoformat(dt) # Python 3.9, 3.10
+      return datetime.fromisoformat(dt)  # Python 3.9, 3.10
 
 
 class TimeDeltaSerializer(ObjectSerializer):
+
   def __init__(self):
     """Time deltas are serialized/deserialized as a string in "mm:ss" format"""
-    ObjectSerializer.__init__(self,
-                              lambda cls, t, _: TimeDeltaSerializer._to_dict_value(t),
-                              lambda cls, v: TimeDeltaSerializer._from_dict_value(v))
+    ObjectSerializer.__init__(
+        self,
+        lambda cls, t, _: TimeDeltaSerializer._to_dict_value(t),
+        lambda cls, v: TimeDeltaSerializer._from_dict_value(v),
+    )
 
   @staticmethod
   def _to_dict_value(delta):
@@ -156,11 +182,14 @@ class TimeDeltaSerializer(ObjectSerializer):
 
 
 class FieldMaskSerializer(ObjectSerializer):
+
   def __init__(self):
     """Field masks are serialized/deserialized as a string that contains a list of paths with a comma delimiter"""
-    ObjectSerializer.__init__(self,
-                              lambda cls, m, _: m.ToJsonString(),
-                              lambda cls, v: FieldMaskSerializer._from_joined_paths(v))
+    ObjectSerializer.__init__(
+        self,
+        lambda cls, m, _: m.ToJsonString(),
+        lambda cls, v: FieldMaskSerializer._from_joined_paths(v),
+    )
 
   @staticmethod
   def _from_joined_paths(joined_paths):
@@ -170,24 +199,37 @@ class FieldMaskSerializer(ObjectSerializer):
 
 
 class KaggleObjectSerializer(ObjectSerializer):
+
   def __init__(self):
     """
     Kaggle objects (i.e., proto-generated types that inherit from KaggleObject) have custom "to_dict" and "from_dict"
     methods that serialize/deserialize them to/from dictionaries.
     """
-    ObjectSerializer.__init__(self,
-                              # "v" is an instance of a KaggleObject. For example: "req = ListCompetitionsRequest()".
-                              # So "req.to_dict()" returns a dictionary with keys as json field names. Example:
-                              # '{"pageSize": 10, "page": 2}'
-                              lambda cls, v, ignore_defaults: cls.to_dict(v, ignore_defaults),
-                              # "cls" is the type of a KaggleObject. For example: ListCompetitionsRequest. All
-                              # generated Kaggle objects have "from_dict" class method that takes a dict to create a
-                              # new instance of the object. See "KaggleObject" class definition below.
-                              lambda cls, v: cls.from_dict(v))
+    ObjectSerializer.__init__(
+        self,
+        # "v" is an instance of a KaggleObject. For example: "req = ListCompetitionsRequest()".
+        # So "req.to_dict()" returns a dictionary with keys as json field names. Example:
+        # '{"pageSize": 10, "page": 2}'
+        lambda cls, v, ignore_defaults: cls.to_dict(v, ignore_defaults),
+        # "cls" is the type of a KaggleObject. For example: ListCompetitionsRequest. All
+        # generated Kaggle objects have "from_dict" class method that takes a dict to create a
+        # new instance of the object. See "KaggleObject" class definition below.
+        lambda cls, v: cls.from_dict(v),
+    )
 
 
 class FieldMetadata(object):
-  def __init__(self, json_name, field_name, private_field_name, field_type, default_value, serializer, optional=False):
+
+  def __init__(
+      self,
+      json_name,
+      field_name,
+      private_field_name,
+      field_type,
+      default_value,
+      serializer,
+      optional=False,
+  ):
     self.json_name = json_name
     self.field_name = field_name
     self.private_field_name = private_field_name
@@ -211,12 +253,17 @@ class FieldMetadata(object):
     if value == self.default_value:
       return  # Ignore default values
     try:
-      setattr(instance, self.private_field_name, self.serializer.from_dict_value(self.field_type, value))
+      setattr(
+          instance,
+          self.private_field_name,
+          self.serializer.from_dict_value(self.field_type, value),
+      )
     except Exception as e:
       raise
 
 
 class KaggleObject(object):
+
   def endpoint(self):
     raise 'Error: endpoint must be defined by the request object'
 
@@ -234,7 +281,7 @@ class KaggleObject(object):
 
   @staticmethod
   def method():
-    return "GET"
+    return 'GET'
 
   def _freeze(self):
     self._is_frozen = True
@@ -245,12 +292,18 @@ class KaggleObject(object):
     object.__setattr__(self, key, value)
 
   def to_dict(self, ignore_defaults=True):
-    kv_pairs = [(field.json_name, field.get_as_dict_item(self, ignore_defaults)) for field in self._fields]
+    kv_pairs = [
+        (field.json_name, field.get_as_dict_item(self, ignore_defaults))
+        for field in self._fields
+    ]
     return {k: v for (k, v) in kv_pairs if not ignore_defaults or v is not None}
 
   @staticmethod
   def to_field_map(self, ignore_defaults=True):
-    kv_pairs = [(field.field_name, field.get_as_dict_item(self, ignore_defaults)) for field in self._fields]
+    kv_pairs = [
+        (field.field_name, field.get_as_dict_item(self, ignore_defaults))
+        for field in self._fields
+    ]
     return {k: v for (k, v) in kv_pairs if not ignore_defaults or v is not None}
 
   @classmethod
@@ -292,5 +345,7 @@ class KaggleObject(object):
   def _get_field(self, field_name):
     field = next((f for f in self._fields if f.field_name == field_name), None)
     if field is None:
-      raise ValueError(f'Protocol message {self.__class__.__name__} has no "{field_name}" field.')
+      raise ValueError(
+          f'Protocol message {self.__class__.__name__} has no "{field_name}" field.'
+      )
     return field

kagglesdk/kernels/types/kernels_api_service.py

@@ -1219,6 +1219,10 @@ class ApiSaveKernelRequest(KaggleObject):
     session_timeout_seconds (int)
       If specified, terminate the kernel session after this many seconds of
       runtime, which must be lower than the global maximum.
+    priority (int)
+      Sets the execution priority of this kernel session request when queued,
+      lower is better (10 will get run before 100).
+      Only allowed or certain clients.
   """
 
   def __init__(self):
@@ -1239,6 +1243,7 @@ class ApiSaveKernelRequest(KaggleObject):
     self._docker_image_pinning_type = None
     self._model_data_sources = []
     self._session_timeout_seconds = None
+    self._priority = None
     self._freeze()
 
   @property
@@ -1517,6 +1522,24 @@ class ApiSaveKernelRequest(KaggleObject):
       raise TypeError('session_timeout_seconds must be of type int')
     self._session_timeout_seconds = session_timeout_seconds
 
+  @property
+  def priority(self) -> int:
+    r"""
+    Sets the execution priority of this kernel session request when queued,
+    lower is better (10 will get run before 100).
+    Only allowed or certain clients.
+    """
+    return self._priority or 0
+
+  @priority.setter
+  def priority(self, priority: int):
+    if priority is None:
+      del self.priority
+      return
+    if not isinstance(priority, int):
+      raise TypeError('priority must be of type int')
+    self._priority = priority
+
   def endpoint(self):
     path = '/api/v1/kernels/push'
     return path.format_map(self.to_field_map(self))
@@ -1924,6 +1947,7 @@ ApiSaveKernelRequest._fields = [
   FieldMetadata("dockerImagePinningType", "docker_image_pinning_type", "_docker_image_pinning_type", str, None, PredefinedSerializer(), optional=True),
   FieldMetadata("modelDataSources", "model_data_sources", "_model_data_sources", str, [], ListSerializer(PredefinedSerializer())),
   FieldMetadata("sessionTimeoutSeconds", "session_timeout_seconds", "_session_timeout_seconds", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("priority", "priority", "_priority", int, None, PredefinedSerializer(), optional=True),
 ]
 
 ApiSaveKernelResponse._fields = [

kagglesdk/models/services/model_api_service.py

@@ -1,6 +1,6 @@
 from kagglesdk.common.types.http_redirect import HttpRedirect
 from kagglesdk.kaggle_http_client import KaggleHttpClient
-from kagglesdk.models.types.model_api_service import ApiCreateModelInstanceRequest, ApiCreateModelInstanceVersionRequest, ApiCreateModelRequest, ApiCreateModelResponse, ApiDeleteModelInstanceRequest, ApiDeleteModelInstanceVersionRequest, ApiDeleteModelRequest, ApiDeleteModelResponse, ApiDownloadModelInstanceVersionRequest, ApiGetModelInstanceRequest, ApiGetModelRequest, ApiListModelGatingUserConsentsRequest, ApiListModelGatingUserConsentsResponse, ApiListModelInstanceVersionFilesRequest, ApiListModelInstanceVersionFilesResponse, ApiListModelsRequest, ApiListModelsResponse, ApiModel, ApiModelInstance, ApiReviewGatingUserConsentRequest, ApiUpdateModelInstanceRequest, ApiUpdateModelRequest, ApiUpdateModelResponse, ApiUploadModelFileRequest, ApiUploadModelFileResponse, CreateModelSigningTokenRequest, CreateModelSigningTokenResponse, KeysRequest, KeysResponse, WellKnowEndpointRequest, WellKnowEndpointResponse
+from kagglesdk.models.types.model_api_service import ApiCreateModelInstanceRequest, ApiCreateModelInstanceVersionRequest, ApiCreateModelRequest, ApiCreateModelResponse, ApiDeleteModelInstanceRequest, ApiDeleteModelInstanceVersionRequest, ApiDeleteModelRequest, ApiDeleteModelResponse, ApiDownloadModelInstanceVersionRequest, ApiGetModelInstanceRequest, ApiGetModelRequest, ApiListModelGatingUserConsentsRequest, ApiListModelGatingUserConsentsResponse, ApiListModelInstanceVersionFilesRequest, ApiListModelInstanceVersionFilesResponse, ApiListModelsRequest, ApiListModelsResponse, ApiModel, ApiModelInstance, ApiReviewModelGatingUserConsentRequest, ApiUpdateModelInstanceRequest, ApiUpdateModelRequest, ApiUpdateModelResponse, ApiUploadModelFileRequest, ApiUploadModelFileResponse, CreateModelSigningTokenRequest, CreateModelSigningTokenResponse, KeysRequest, KeysResponse, WellKnowEndpointRequest, WellKnowEndpointResponse
 
 class ModelApiClient(object):
 
@@ -240,16 +240,17 @@ class ModelApiClient(object):
 
     return self._client.call("models.ModelApiService", "ApiListModelGatingUserConsents", request, ApiListModelGatingUserConsentsResponse)
 
-  def review_gating_user_consent(self, request: ApiReviewGatingUserConsentRequest = None):
+  def review_model_gating_user_consent(self, request: ApiReviewModelGatingUserConsentRequest = None):
     r"""
-    Review the user consents for an agreement.
+    Review the user consents for a gated model, under the model's current
+    active agreement.
 
     Args:
-      request (ApiReviewGatingUserConsentRequest):
+      request (ApiReviewModelGatingUserConsentRequest):
         The request object; initialized to empty instance if not specified.
     """
 
     if request is None:
-      request = ApiReviewGatingUserConsentRequest()
+      request = ApiReviewModelGatingUserConsentRequest()
 
-    self._client.call("models.ModelApiService", "ApiReviewGatingUserConsent", request, None)
+    self._client.call("models.ModelApiService", "ApiReviewModelGatingUserConsent", request, None)

kagglesdk/models/types/model_api_service.py

@@ -2226,34 +2226,49 @@ class ApiModelInstance(KaggleObject):
     self._total_uncompressed_bytes = total_uncompressed_bytes
 
 
-class ApiReviewGatingUserConsentRequest(KaggleObject):
+class ApiReviewModelGatingUserConsentRequest(KaggleObject):
   r"""
   Attributes:
-    agreement_id (int)
+    owner_slug (str)
+    model_slug (str)
     user_name (str)
     review_status (GatingAgreementRequestsReviewStatus)
     publisher_notes (str)
   """
 
   def __init__(self):
-    self._agreement_id = 0
+    self._owner_slug = ""
+    self._model_slug = ""
     self._user_name = ""
     self._review_status = GatingAgreementRequestsReviewStatus.GATING_AGREEMENT_REQUESTS_REVIEW_STATUS_UNSPECIFIED
     self._publisher_notes = None
     self._freeze()
 
   @property
-  def agreement_id(self) -> int:
-    return self._agreement_id
+  def owner_slug(self) -> str:
+    return self._owner_slug
 
-  @agreement_id.setter
-  def agreement_id(self, agreement_id: int):
-    if agreement_id is None:
-      del self.agreement_id
+  @owner_slug.setter
+  def owner_slug(self, owner_slug: str):
+    if owner_slug is None:
+      del self.owner_slug
       return
-    if not isinstance(agreement_id, int):
-      raise TypeError('agreement_id must be of type int')
-    self._agreement_id = agreement_id
+    if not isinstance(owner_slug, str):
+      raise TypeError('owner_slug must be of type str')
+    self._owner_slug = owner_slug
+
+  @property
+  def model_slug(self) -> str:
+    return self._model_slug
+
+  @model_slug.setter
+  def model_slug(self, model_slug: str):
+    if model_slug is None:
+      del self.model_slug
+      return
+    if not isinstance(model_slug, str):
+      raise TypeError('model_slug must be of type str')
+    self._model_slug = model_slug
 
   @property
   def user_name(self) -> str:
@@ -2295,7 +2310,7 @@ class ApiReviewGatingUserConsentRequest(KaggleObject):
     self._publisher_notes = publisher_notes
 
   def endpoint(self):
-    path = '/api/v1/gating/{agreement_id}/user-consent/review'
+    path = '/api/v1/models/{owner_slug}/{model_slug}/user-consents/review'
     return path.format_map(self.to_field_map(self))
 
 
@@ -3599,8 +3614,9 @@ ApiModelInstance._fields = [
   FieldMetadata("totalUncompressedBytes", "total_uncompressed_bytes", "_total_uncompressed_bytes", int, 0, PredefinedSerializer()),
 ]
 
-ApiReviewGatingUserConsentRequest._fields = [
-  FieldMetadata("agreementId", "agreement_id", "_agreement_id", int, 0, PredefinedSerializer()),
+ApiReviewModelGatingUserConsentRequest._fields = [
+  FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()),
   FieldMetadata("userName", "user_name", "_user_name", str, "", PredefinedSerializer()),
   FieldMetadata("reviewStatus", "review_status", "_review_status", GatingAgreementRequestsReviewStatus, GatingAgreementRequestsReviewStatus.GATING_AGREEMENT_REQUESTS_REVIEW_STATUS_UNSPECIFIED, EnumSerializer()),
   FieldMetadata("publisherNotes", "publisher_notes", "_publisher_notes", str, None, PredefinedSerializer(), optional=True),

kagglesdk/security/services/oauth_service.py

@@ -0,0 +1,32 @@
+from kagglesdk.common.types.http_redirect import HttpRedirect
+from kagglesdk.kaggle_http_client import KaggleHttpClient
+from kagglesdk.security.types.oauth_service import ExchangeOAuthTokenRequest, ExchangeOAuthTokenResponse, StartOAuthFlowRequest
+
+class OAuthClient(object):
+
+  def __init__(self, client: KaggleHttpClient):
+    self._client = client
+
+  def start_oauth_flow(self, request: StartOAuthFlowRequest = None) -> HttpRedirect:
+    r"""
+    Args:
+      request (StartOAuthFlowRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = StartOAuthFlowRequest()
+
+    return self._client.call("security.OAuthService", "StartOAuthFlow", request, HttpRedirect)
+
+  def exchange_oauth_token(self, request: ExchangeOAuthTokenRequest = None) -> ExchangeOAuthTokenResponse:
+    r"""
+    Args:
+      request (ExchangeOAuthTokenRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = ExchangeOAuthTokenRequest()
+
+    return self._client.call("security.OAuthService", "ExchangeOAuthToken", request, ExchangeOAuthTokenResponse)

kagglesdk/security/types/authentication.py

@@ -0,0 +1,171 @@
+from kagglesdk.kaggle_object import *
+from typing import Optional, List
+
+class AuthorizationScope(KaggleObject):
+  r"""
+  Attributes:
+    resource_id (int)
+    permission (AuthorizationPermissionScope)
+    role (AuthorizationRoleScope)
+  """
+
+  def __init__(self):
+    self._resource_id = 0
+    self._permission = None
+    self._role = None
+    self._freeze()
+
+  @property
+  def resource_id(self) -> int:
+    return self._resource_id
+
+  @resource_id.setter
+  def resource_id(self, resource_id: int):
+    if resource_id is None:
+      del self.resource_id
+      return
+    if not isinstance(resource_id, int):
+      raise TypeError('resource_id must be of type int')
+    self._resource_id = resource_id
+
+  @property
+  def permission(self) -> Optional['AuthorizationPermissionScope']:
+    return self._permission or None
+
+  @permission.setter
+  def permission(self, permission: Optional['AuthorizationPermissionScope']):
+    if permission is None:
+      del self.permission
+      return
+    if not isinstance(permission, AuthorizationPermissionScope):
+      raise TypeError('permission must be of type AuthorizationPermissionScope')
+    del self.role
+    self._permission = permission
+
+  @property
+  def role(self) -> Optional['AuthorizationRoleScope']:
+    return self._role or None
+
+  @role.setter
+  def role(self, role: Optional['AuthorizationRoleScope']):
+    if role is None:
+      del self.role
+      return
+    if not isinstance(role, AuthorizationRoleScope):
+      raise TypeError('role must be of type AuthorizationRoleScope')
+    del self.permission
+    self._role = role
+
+
+class AuthorizationPermissionScope(KaggleObject):
+  r"""
+  Attributes:
+    name (str)
+    description (str)
+  """
+
+  def __init__(self):
+    self._name = ""
+    self._description = None
+    self._freeze()
+
+  @property
+  def name(self) -> str:
+    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 description(self) -> str:
+    return self._description or ""
+
+  @description.setter
+  def description(self, description: str):
+    if description is None:
+      del self.description
+      return
+    if not isinstance(description, str):
+      raise TypeError('description must be of type str')
+    self._description = description
+
+
+class AuthorizationRoleScope(KaggleObject):
+  r"""
+  Attributes:
+    name (str)
+    description (str)
+    permissions (AuthorizationPermissionScope)
+  """
+
+  def __init__(self):
+    self._name = ""
+    self._description = None
+    self._permissions = []
+    self._freeze()
+
+  @property
+  def name(self) -> str:
+    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 description(self) -> str:
+    return self._description or ""
+
+  @description.setter
+  def description(self, description: str):
+    if description is None:
+      del self.description
+      return
+    if not isinstance(description, str):
+      raise TypeError('description must be of type str')
+    self._description = description
+
+  @property
+  def permissions(self) -> Optional[List[Optional['AuthorizationPermissionScope']]]:
+    return self._permissions
+
+  @permissions.setter
+  def permissions(self, permissions: Optional[List[Optional['AuthorizationPermissionScope']]]):
+    if permissions is None:
+      del self.permissions
+      return
+    if not isinstance(permissions, list):
+      raise TypeError('permissions must be of type list')
+    if not all([isinstance(t, AuthorizationPermissionScope) for t in permissions]):
+      raise TypeError('permissions must contain only items of type AuthorizationPermissionScope')
+    self._permissions = permissions
+
+
+AuthorizationScope._fields = [
+  FieldMetadata("resourceId", "resource_id", "_resource_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("permission", "permission", "_permission", AuthorizationPermissionScope, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("role", "role", "_role", AuthorizationRoleScope, None, KaggleObjectSerializer(), optional=True),
+]
+
+AuthorizationPermissionScope._fields = [
+  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
+  FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True),
+]
+
+AuthorizationRoleScope._fields = [
+  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
+  FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("permissions", "permissions", "_permissions", AuthorizationPermissionScope, [], ListSerializer(KaggleObjectSerializer())),
+]
+