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

kagglesdk/users/types/group_api_service.py

@@ -0,0 +1,315 @@
+from kagglesdk.kaggle_object import *
+from typing import Optional, List
+
+class ApiGroupMembership(KaggleObject):
+  r"""
+  Attributes:
+    user_id (int)
+    username (str)
+  """
+
+  def __init__(self):
+    self._user_id = 0
+    self._username = ""
+    self._freeze()
+
+  @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 username(self) -> str:
+    return self._username
+
+  @username.setter
+  def username(self, username: str):
+    if username is None:
+      del self.username
+      return
+    if not isinstance(username, str):
+      raise TypeError('username must be of type str')
+    self._username = username
+
+
+class ApiListSynchronizedGroupMembershipsRequest(KaggleObject):
+  r"""
+  Attributes:
+    page_size (int)
+    page_token (str)
+    skip (int)
+    group_slug (str)
+  """
+
+  def __init__(self):
+    self._page_size = 0
+    self._page_token = None
+    self._skip = None
+    self._group_slug = ""
+    self._freeze()
+
+  @property
+  def page_size(self) -> int:
+    return self._page_size
+
+  @page_size.setter
+  def page_size(self, page_size: int):
+    if page_size is None:
+      del self.page_size
+      return
+    if not isinstance(page_size, int):
+      raise TypeError('page_size must be of type int')
+    self._page_size = page_size
+
+  @property
+  def page_token(self) -> str:
+    return self._page_token or ""
+
+  @page_token.setter
+  def page_token(self, page_token: Optional[str]):
+    if page_token is None:
+      del self.page_token
+      return
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
+
+  @property
+  def skip(self) -> int:
+    return self._skip or 0
+
+  @skip.setter
+  def skip(self, skip: Optional[int]):
+    if skip is None:
+      del self.skip
+      return
+    if not isinstance(skip, int):
+      raise TypeError('skip must be of type int')
+    self._skip = skip
+
+  @property
+  def group_slug(self) -> str:
+    return self._group_slug
+
+  @group_slug.setter
+  def group_slug(self, group_slug: str):
+    if group_slug is None:
+      del self.group_slug
+      return
+    if not isinstance(group_slug, str):
+      raise TypeError('group_slug must be of type str')
+    self._group_slug = group_slug
+
+  def endpoint(self):
+    path = '/api/v1/sync_groups/{group_slug}/members'
+    return path.format_map(self.to_field_map(self))
+
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/sync_groups/{group_slug}/members'
+
+
+class ApiListSynchronizedGroupMembershipsResponse(KaggleObject):
+  r"""
+  Attributes:
+    memberships (ApiGroupMembership)
+    next_page_token (str)
+  """
+
+  def __init__(self):
+    self._memberships = []
+    self._next_page_token = ""
+    self._freeze()
+
+  @property
+  def memberships(self) -> Optional[List[Optional['ApiGroupMembership']]]:
+    return self._memberships
+
+  @memberships.setter
+  def memberships(self, memberships: Optional[List[Optional['ApiGroupMembership']]]):
+    if memberships is None:
+      del self.memberships
+      return
+    if not isinstance(memberships, list):
+      raise TypeError('memberships must be of type list')
+    if not all([isinstance(t, ApiGroupMembership) for t in memberships]):
+      raise TypeError('memberships must contain only items of type ApiGroupMembership')
+    self._memberships = memberships
+
+  @property
+  def next_page_token(self) -> str:
+    return self._next_page_token
+
+  @next_page_token.setter
+  def next_page_token(self, next_page_token: str):
+    if next_page_token is None:
+      del self.next_page_token
+      return
+    if not isinstance(next_page_token, str):
+      raise TypeError('next_page_token must be of type str')
+    self._next_page_token = next_page_token
+
+  @property
+  def nextPageToken(self):
+    return self.next_page_token
+
+
+class ApiListUserManagedGroupMembershipsRequest(KaggleObject):
+  r"""
+  Attributes:
+    page_size (int)
+    page_token (str)
+    skip (int)
+    group_slug (str)
+  """
+
+  def __init__(self):
+    self._page_size = 0
+    self._page_token = None
+    self._skip = None
+    self._group_slug = ""
+    self._freeze()
+
+  @property
+  def page_size(self) -> int:
+    return self._page_size
+
+  @page_size.setter
+  def page_size(self, page_size: int):
+    if page_size is None:
+      del self.page_size
+      return
+    if not isinstance(page_size, int):
+      raise TypeError('page_size must be of type int')
+    self._page_size = page_size
+
+  @property
+  def page_token(self) -> str:
+    return self._page_token or ""
+
+  @page_token.setter
+  def page_token(self, page_token: Optional[str]):
+    if page_token is None:
+      del self.page_token
+      return
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
+
+  @property
+  def skip(self) -> int:
+    return self._skip or 0
+
+  @skip.setter
+  def skip(self, skip: Optional[int]):
+    if skip is None:
+      del self.skip
+      return
+    if not isinstance(skip, int):
+      raise TypeError('skip must be of type int')
+    self._skip = skip
+
+  @property
+  def group_slug(self) -> str:
+    return self._group_slug
+
+  @group_slug.setter
+  def group_slug(self, group_slug: str):
+    if group_slug is None:
+      del self.group_slug
+      return
+    if not isinstance(group_slug, str):
+      raise TypeError('group_slug must be of type str')
+    self._group_slug = group_slug
+
+  def endpoint(self):
+    path = '/api/v1/groups/{group_slug}/members'
+    return path.format_map(self.to_field_map(self))
+
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/groups/{group_slug}/members'
+
+
+class ApiListUserManagedGroupMembershipsResponse(KaggleObject):
+  r"""
+  Attributes:
+    memberships (ApiGroupMembership)
+    next_page_token (str)
+  """
+
+  def __init__(self):
+    self._memberships = []
+    self._next_page_token = ""
+    self._freeze()
+
+  @property
+  def memberships(self) -> Optional[List[Optional['ApiGroupMembership']]]:
+    return self._memberships
+
+  @memberships.setter
+  def memberships(self, memberships: Optional[List[Optional['ApiGroupMembership']]]):
+    if memberships is None:
+      del self.memberships
+      return
+    if not isinstance(memberships, list):
+      raise TypeError('memberships must be of type list')
+    if not all([isinstance(t, ApiGroupMembership) for t in memberships]):
+      raise TypeError('memberships must contain only items of type ApiGroupMembership')
+    self._memberships = memberships
+
+  @property
+  def next_page_token(self) -> str:
+    return self._next_page_token
+
+  @next_page_token.setter
+  def next_page_token(self, next_page_token: str):
+    if next_page_token is None:
+      del self.next_page_token
+      return
+    if not isinstance(next_page_token, str):
+      raise TypeError('next_page_token must be of type str')
+    self._next_page_token = next_page_token
+
+  @property
+  def nextPageToken(self):
+    return self.next_page_token
+
+
+ApiGroupMembership._fields = [
+  FieldMetadata("userId", "user_id", "_user_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("username", "username", "_username", str, "", PredefinedSerializer()),
+]
+
+ApiListSynchronizedGroupMembershipsRequest._fields = [
+  FieldMetadata("pageSize", "page_size", "_page_size", int, 0, PredefinedSerializer()),
+  FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("skip", "skip", "_skip", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("groupSlug", "group_slug", "_group_slug", str, "", PredefinedSerializer()),
+]
+
+ApiListSynchronizedGroupMembershipsResponse._fields = [
+  FieldMetadata("memberships", "memberships", "_memberships", ApiGroupMembership, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()),
+]
+
+ApiListUserManagedGroupMembershipsRequest._fields = [
+  FieldMetadata("pageSize", "page_size", "_page_size", int, 0, PredefinedSerializer()),
+  FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("skip", "skip", "_skip", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("groupSlug", "group_slug", "_group_slug", str, "", PredefinedSerializer()),
+]
+
+ApiListUserManagedGroupMembershipsResponse._fields = [
+  FieldMetadata("memberships", "memberships", "_memberships", ApiGroupMembership, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()),
+]
+

kagglesdk/users/types/group_types.py

@@ -0,0 +1,165 @@
+from kagglesdk.kaggle_object import *
+from kagglesdk.users.types.groups_enum import GroupMembershipRole
+from kagglesdk.users.types.user_avatar import UserAvatar
+from typing import Optional, List
+
+class UserManagedGroup(KaggleObject):
+  r"""
+  Attributes:
+    id (int)
+    name (str)
+    slug (str)
+    description (str)
+    owner (UserAvatar)
+    member_count (int)
+    current_user_role (GroupMembershipRole)
+    avatar_infos (UserAvatar)
+      List of up to three avatars sorted by join date.
+    share_token (str)
+  """
+
+  def __init__(self):
+    self._id = 0
+    self._name = ""
+    self._slug = ""
+    self._description = None
+    self._owner = None
+    self._member_count = None
+    self._current_user_role = None
+    self._avatar_infos = []
+    self._share_token = None
+    self._freeze()
+
+  @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 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 slug(self) -> str:
+    return self._slug
+
+  @slug.setter
+  def slug(self, slug: str):
+    if slug is None:
+      del self.slug
+      return
+    if not isinstance(slug, str):
+      raise TypeError('slug must be of type str')
+    self._slug = slug
+
+  @property
+  def description(self) -> str:
+    return self._description or ""
+
+  @description.setter
+  def description(self, description: Optional[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 owner(self) -> Optional['UserAvatar']:
+    return self._owner or None
+
+  @owner.setter
+  def owner(self, owner: Optional[Optional['UserAvatar']]):
+    if owner is None:
+      del self.owner
+      return
+    if not isinstance(owner, UserAvatar):
+      raise TypeError('owner must be of type UserAvatar')
+    self._owner = owner
+
+  @property
+  def member_count(self) -> int:
+    return self._member_count or 0
+
+  @member_count.setter
+  def member_count(self, member_count: Optional[int]):
+    if member_count is None:
+      del self.member_count
+      return
+    if not isinstance(member_count, int):
+      raise TypeError('member_count must be of type int')
+    self._member_count = member_count
+
+  @property
+  def current_user_role(self) -> 'GroupMembershipRole':
+    return self._current_user_role or GroupMembershipRole.GROUP_MEMBERSHIP_ROLE_UNSPECIFIED
+
+  @current_user_role.setter
+  def current_user_role(self, current_user_role: Optional['GroupMembershipRole']):
+    if current_user_role is None:
+      del self.current_user_role
+      return
+    if not isinstance(current_user_role, GroupMembershipRole):
+      raise TypeError('current_user_role must be of type GroupMembershipRole')
+    self._current_user_role = current_user_role
+
+  @property
+  def avatar_infos(self) -> Optional[List[Optional['UserAvatar']]]:
+    """List of up to three avatars sorted by join date."""
+    return self._avatar_infos
+
+  @avatar_infos.setter
+  def avatar_infos(self, avatar_infos: Optional[List[Optional['UserAvatar']]]):
+    if avatar_infos is None:
+      del self.avatar_infos
+      return
+    if not isinstance(avatar_infos, list):
+      raise TypeError('avatar_infos must be of type list')
+    if not all([isinstance(t, UserAvatar) for t in avatar_infos]):
+      raise TypeError('avatar_infos must contain only items of type UserAvatar')
+    self._avatar_infos = avatar_infos
+
+  @property
+  def share_token(self) -> str:
+    return self._share_token or ""
+
+  @share_token.setter
+  def share_token(self, share_token: Optional[str]):
+    if share_token is None:
+      del self.share_token
+      return
+    if not isinstance(share_token, str):
+      raise TypeError('share_token must be of type str')
+    self._share_token = share_token
+
+
+UserManagedGroup._fields = [
+  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
+  FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("owner", "owner", "_owner", UserAvatar, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("memberCount", "member_count", "_member_count", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("currentUserRole", "current_user_role", "_current_user_role", GroupMembershipRole, None, EnumSerializer(), optional=True),
+  FieldMetadata("avatarInfos", "avatar_infos", "_avatar_infos", UserAvatar, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("shareToken", "share_token", "_share_token", str, None, PredefinedSerializer(), optional=True),
+]
+

kagglesdk/users/types/groups_enum.py

@@ -0,0 +1,8 @@
+import enum
+
+class GroupMembershipRole(enum.Enum):
+  GROUP_MEMBERSHIP_ROLE_UNSPECIFIED = 0
+  GROUP_MEMBERSHIP_ROLE_ADMIN = 1
+  GROUP_MEMBERSHIP_ROLE_OWNER = 2
+  GROUP_MEMBERSHIP_ROLE_MEMBER = 3
+

kagglesdk/users/types/progression_service.py

@@ -0,0 +1,9 @@
+import enum
+
+class UserAchievementType(enum.Enum):
+  USER_ACHIEVEMENT_TYPE_UNSPECIFIED = 0
+  USER_ACHIEVEMENT_TYPE_COMPETITIONS = 1
+  USER_ACHIEVEMENT_TYPE_NOTEBOOKS = 2
+  USER_ACHIEVEMENT_TYPE_DISCUSSION = 3
+  USER_ACHIEVEMENT_TYPE_DATASETS = 4
+

kagglesdk/users/types/search_users.py

@@ -0,0 +1,23 @@
+import enum
+
+class SearchUsersOrderBy(enum.Enum):
+  SEARCH_USERS_ORDER_BY_UNSPECIFIED = 0
+  SEARCH_USERS_ORDER_BY_COMPETITION_RANKING = 1
+  """Ordered by current competition ranking, ascending (best rank first)."""
+  SEARCH_USERS_ORDER_BY_KERNEL_RANKING = 2
+  """Ordered by current kernel ranking, ascending (best rank first)."""
+  SEARCH_USERS_ORDER_BY_DATASET_RANKING = 3
+  """Ordered by current dataset ranking, ascending (best rank first)."""
+  SEARCH_USERS_ORDER_BY_DISPLAY_NAME = 4
+  """Ordered by display name, alphabetically, ascending."""
+  SEARCH_USERS_ORDER_BY_TIER_AND_LEVEL = 5
+  r"""
+  Ordered by tier and tier levels, descending. Tier levels are awarded
+  starting at Grandmaster. The first user returned will have the highest tier
+  and level (GM 7x, etc.).
+  """
+  SEARCH_USERS_ORDER_BY_OLDEST_JOIN_DATE = 6
+  """Ordered by user create date, ascending (i.e. oldest account first)."""
+  SEARCH_USERS_ORDER_BY_NEWEST_JOIN_DATE = 7
+  """Ordered by user create date, descending (i.e. newest account first)."""
+