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

kagglesdk/search/types/search_content_shared.py

@@ -0,0 +1,50 @@
+from kagglesdk.kaggle_object import *
+
+class ListSearchContentRangeFilter(KaggleObject):
+  r"""
+  Attributes:
+    min (int)
+      The minimum value (inclusive) to apply to filtering
+    max (int)
+      The maximum value (inclusive) to apply to filtering
+  """
+
+  def __init__(self):
+    self._min = 0
+    self._max = 0
+    self._freeze()
+
+  @property
+  def min(self) -> int:
+    """The minimum value (inclusive) to apply to filtering"""
+    return self._min
+
+  @min.setter
+  def min(self, min: int):
+    if min is None:
+      del self.min
+      return
+    if not isinstance(min, int):
+      raise TypeError('min must be of type int')
+    self._min = min
+
+  @property
+  def max(self) -> int:
+    """The maximum value (inclusive) to apply to filtering"""
+    return self._max
+
+  @max.setter
+  def max(self, max: int):
+    if max is None:
+      del self.max
+      return
+    if not isinstance(max, int):
+      raise TypeError('max must be of type int')
+    self._max = max
+
+
+ListSearchContentRangeFilter._fields = [
+  FieldMetadata("min", "min", "_min", int, 0, PredefinedSerializer()),
+  FieldMetadata("max", "max", "_max", int, 0, PredefinedSerializer()),
+]
+

kagglesdk/search/types/search_enums.py

@@ -0,0 +1,45 @@
+import enum
+
+class ListSearchContentOrderBy(enum.Enum):
+  LIST_SEARCH_CONTENT_ORDER_BY_UNSPECIFIED = 0
+  LIST_SEARCH_CONTENT_ORDER_BY_DATE_CREATED = 1
+  LIST_SEARCH_CONTENT_ORDER_BY_DATE_UPDATED = 2
+  LIST_SEARCH_CONTENT_ORDER_BY_HOTNESS = 3
+  LIST_SEARCH_CONTENT_ORDER_BY_LAST_VIEWED = 4
+  LIST_SEARCH_CONTENT_ORDER_BY_TOTAL_COMMENTS = 5
+  LIST_SEARCH_CONTENT_ORDER_BY_VOTES = 6
+
+class DocumentType(enum.Enum):
+  DOCUMENT_TYPE_UNSPECIFIED = 0
+  BLOG = 1
+  COMPETITION = 2
+  DATASET = 3
+  KERNEL = 5
+  COMMENT = 6
+  TOPIC = 8
+  USER = 9
+  COURSE = 10
+  TUTORIAL = 11
+  MODEL = 12
+  RESOURCEREFERENCE = 13
+  BENCHMARKTASK = 14
+  BENCHMARK = 15
+
+class OwnerType(enum.Enum):
+  OWNER_TYPE_UNSPECIFIED = 0
+  """ownerUserId is sole owner of content or is in read/writeGroupId"""
+  OWNER_TYPE_OWNS = 1
+  """ownerUserId is sole owner of content"""
+  OWNER_TYPE_COLLABORATIONS = 2
+  """ownerUserId is in read/writeGroupId, but not owner [Profiles only]"""
+  OWNER_TYPE_SHARED_WITH_CURRENT_USER = 3
+  """ownerUserId is sole owner of content, currentUser is in read/writeGroupId"""
+
+class PrivacyFilter(enum.Enum):
+  ALL = 0
+  """Return all search results (private and public)."""
+  PRIVATE = 1
+  """Return only private search results (if caller has access, of course)."""
+  PUBLIC = 2
+  """Return only public search results."""
+

kagglesdk/search/types/search_service.py

@@ -0,0 +1,303 @@
+from datetime import datetime
+from kagglesdk.community.types.content_enums import ContentState
+from kagglesdk.discussions.types.writeup_enums import WriteUpType
+from kagglesdk.kaggle_object import *
+from kagglesdk.users.types.user_avatar import UserAvatar
+from typing import Optional, List
+
+class WriteUpCompetitionInfo(KaggleObject):
+  r"""
+  Attributes:
+    competition_title (str)
+      Title of the Competition or Hackathon
+    competition_url (str)
+      Url of the Competition or Hackathon
+    deadline (datetime)
+      Deadline of the Competition or Hackathon
+    write_up_leaderboard_rank (int)
+      Rank of Competition Solution WriteUp on Leaderboard
+    leaderboard_url (str)
+      Leaderboard Tab Url for Competition
+    winners_url (str)
+      Winners Tab Url of Hackathon
+    is_hackathon_winner (bool)
+      Boolean to tell if user's WriteUp is winner of Hackathon
+    competition_id (int)
+      Id of the Competition
+  """
+
+  def __init__(self):
+    self._competition_title = ""
+    self._competition_url = ""
+    self._deadline = None
+    self._write_up_leaderboard_rank = None
+    self._leaderboard_url = None
+    self._winners_url = None
+    self._is_hackathon_winner = None
+    self._competition_id = 0
+    self._freeze()
+
+  @property
+  def competition_title(self) -> str:
+    """Title of the Competition or Hackathon"""
+    return self._competition_title
+
+  @competition_title.setter
+  def competition_title(self, competition_title: str):
+    if competition_title is None:
+      del self.competition_title
+      return
+    if not isinstance(competition_title, str):
+      raise TypeError('competition_title must be of type str')
+    self._competition_title = competition_title
+
+  @property
+  def competition_url(self) -> str:
+    """Url of the Competition or Hackathon"""
+    return self._competition_url
+
+  @competition_url.setter
+  def competition_url(self, competition_url: str):
+    if competition_url is None:
+      del self.competition_url
+      return
+    if not isinstance(competition_url, str):
+      raise TypeError('competition_url must be of type str')
+    self._competition_url = competition_url
+
+  @property
+  def deadline(self) -> datetime:
+    """Deadline of the Competition or Hackathon"""
+    return self._deadline
+
+  @deadline.setter
+  def deadline(self, deadline: datetime):
+    if deadline is None:
+      del self.deadline
+      return
+    if not isinstance(deadline, datetime):
+      raise TypeError('deadline must be of type datetime')
+    self._deadline = deadline
+
+  @property
+  def write_up_leaderboard_rank(self) -> int:
+    """Rank of Competition Solution WriteUp on Leaderboard"""
+    return self._write_up_leaderboard_rank or 0
+
+  @write_up_leaderboard_rank.setter
+  def write_up_leaderboard_rank(self, write_up_leaderboard_rank: Optional[int]):
+    if write_up_leaderboard_rank is None:
+      del self.write_up_leaderboard_rank
+      return
+    if not isinstance(write_up_leaderboard_rank, int):
+      raise TypeError('write_up_leaderboard_rank must be of type int')
+    self._write_up_leaderboard_rank = write_up_leaderboard_rank
+
+  @property
+  def leaderboard_url(self) -> str:
+    """Leaderboard Tab Url for Competition"""
+    return self._leaderboard_url or ""
+
+  @leaderboard_url.setter
+  def leaderboard_url(self, leaderboard_url: Optional[str]):
+    if leaderboard_url is None:
+      del self.leaderboard_url
+      return
+    if not isinstance(leaderboard_url, str):
+      raise TypeError('leaderboard_url must be of type str')
+    self._leaderboard_url = leaderboard_url
+
+  @property
+  def winners_url(self) -> str:
+    """Winners Tab Url of Hackathon"""
+    return self._winners_url or ""
+
+  @winners_url.setter
+  def winners_url(self, winners_url: Optional[str]):
+    if winners_url is None:
+      del self.winners_url
+      return
+    if not isinstance(winners_url, str):
+      raise TypeError('winners_url must be of type str')
+    self._winners_url = winners_url
+
+  @property
+  def is_hackathon_winner(self) -> bool:
+    """Boolean to tell if user's WriteUp is winner of Hackathon"""
+    return self._is_hackathon_winner or False
+
+  @is_hackathon_winner.setter
+  def is_hackathon_winner(self, is_hackathon_winner: Optional[bool]):
+    if is_hackathon_winner is None:
+      del self.is_hackathon_winner
+      return
+    if not isinstance(is_hackathon_winner, bool):
+      raise TypeError('is_hackathon_winner must be of type bool')
+    self._is_hackathon_winner = is_hackathon_winner
+
+  @property
+  def competition_id(self) -> int:
+    """Id of the Competition"""
+    return self._competition_id
+
+  @competition_id.setter
+  def competition_id(self, competition_id: int):
+    if competition_id is None:
+      del self.competition_id
+      return
+    if not isinstance(competition_id, int):
+      raise TypeError('competition_id must be of type int')
+    self._competition_id = competition_id
+
+
+class WriteUpItemInfo(KaggleObject):
+  r"""
+  Attributes:
+    type (WriteUpType)
+      Type of WriteUp
+    subtitle (str)
+      Subtitle of WriteUp
+    collaborators (UserAvatar)
+      List of WriteUp collaborators
+    competition_info (WriteUpCompetitionInfo)
+      Competition metadata associated with WriteUp
+    content_state (ContentState)
+      Content State of WriteUp
+    team_name (str)
+      Name of the team that owns the WriteUp
+    id (int)
+      Id of the WriteUp
+  """
+
+  def __init__(self):
+    self._type = WriteUpType.WRITE_UP_TYPE_UNSPECIFIED
+    self._subtitle = None
+    self._collaborators = []
+    self._competition_info = None
+    self._content_state = ContentState.CONTENT_STATE_UNSPECIFIED
+    self._team_name = None
+    self._id = 0
+    self._freeze()
+
+  @property
+  def type(self) -> 'WriteUpType':
+    """Type of WriteUp"""
+    return self._type
+
+  @type.setter
+  def type(self, type: 'WriteUpType'):
+    if type is None:
+      del self.type
+      return
+    if not isinstance(type, WriteUpType):
+      raise TypeError('type must be of type WriteUpType')
+    self._type = type
+
+  @property
+  def subtitle(self) -> str:
+    """Subtitle of WriteUp"""
+    return self._subtitle or ""
+
+  @subtitle.setter
+  def subtitle(self, subtitle: Optional[str]):
+    if subtitle is None:
+      del self.subtitle
+      return
+    if not isinstance(subtitle, str):
+      raise TypeError('subtitle must be of type str')
+    self._subtitle = subtitle
+
+  @property
+  def collaborators(self) -> Optional[List[Optional['UserAvatar']]]:
+    """List of WriteUp collaborators"""
+    return self._collaborators
+
+  @collaborators.setter
+  def collaborators(self, collaborators: Optional[List[Optional['UserAvatar']]]):
+    if collaborators is None:
+      del self.collaborators
+      return
+    if not isinstance(collaborators, list):
+      raise TypeError('collaborators must be of type list')
+    if not all([isinstance(t, UserAvatar) for t in collaborators]):
+      raise TypeError('collaborators must contain only items of type UserAvatar')
+    self._collaborators = collaborators
+
+  @property
+  def competition_info(self) -> Optional['WriteUpCompetitionInfo']:
+    """Competition metadata associated with WriteUp"""
+    return self._competition_info or None
+
+  @competition_info.setter
+  def competition_info(self, competition_info: Optional[Optional['WriteUpCompetitionInfo']]):
+    if competition_info is None:
+      del self.competition_info
+      return
+    if not isinstance(competition_info, WriteUpCompetitionInfo):
+      raise TypeError('competition_info must be of type WriteUpCompetitionInfo')
+    self._competition_info = competition_info
+
+  @property
+  def content_state(self) -> 'ContentState':
+    """Content State of WriteUp"""
+    return self._content_state
+
+  @content_state.setter
+  def content_state(self, content_state: 'ContentState'):
+    if content_state is None:
+      del self.content_state
+      return
+    if not isinstance(content_state, ContentState):
+      raise TypeError('content_state must be of type ContentState')
+    self._content_state = content_state
+
+  @property
+  def team_name(self) -> str:
+    """Name of the team that owns the WriteUp"""
+    return self._team_name or ""
+
+  @team_name.setter
+  def team_name(self, team_name: Optional[str]):
+    if team_name is None:
+      del self.team_name
+      return
+    if not isinstance(team_name, str):
+      raise TypeError('team_name must be of type str')
+    self._team_name = team_name
+
+  @property
+  def id(self) -> int:
+    """Id of the WriteUp"""
+    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
+
+
+WriteUpCompetitionInfo._fields = [
+  FieldMetadata("competitionTitle", "competition_title", "_competition_title", str, "", PredefinedSerializer()),
+  FieldMetadata("competitionUrl", "competition_url", "_competition_url", str, "", PredefinedSerializer()),
+  FieldMetadata("deadline", "deadline", "_deadline", datetime, None, DateTimeSerializer()),
+  FieldMetadata("writeUpLeaderboardRank", "write_up_leaderboard_rank", "_write_up_leaderboard_rank", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("leaderboardUrl", "leaderboard_url", "_leaderboard_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("winnersUrl", "winners_url", "_winners_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("isHackathonWinner", "is_hackathon_winner", "_is_hackathon_winner", bool, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("competitionId", "competition_id", "_competition_id", int, 0, PredefinedSerializer()),
+]
+
+WriteUpItemInfo._fields = [
+  FieldMetadata("type", "type", "_type", WriteUpType, WriteUpType.WRITE_UP_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("subtitle", "subtitle", "_subtitle", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("collaborators", "collaborators", "_collaborators", UserAvatar, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("competitionInfo", "competition_info", "_competition_info", WriteUpCompetitionInfo, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("contentState", "content_state", "_content_state", ContentState, ContentState.CONTENT_STATE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("teamName", "team_name", "_team_name", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
+]
+

kagglesdk/security/services/iam_service.py

@@ -0,0 +1,31 @@
+from kagglesdk.kaggle_http_client import KaggleHttpClient
+from kagglesdk.security.types.iam_service import GetIamPolicyRequest, IamPolicy, SetIamPolicyRequest
+
+class IamClient(object):
+
+  def __init__(self, client: KaggleHttpClient):
+    self._client = client
+
+  def get_iam_policy(self, request: GetIamPolicyRequest = None) -> IamPolicy:
+    r"""
+    Args:
+      request (GetIamPolicyRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = GetIamPolicyRequest()
+
+    return self._client.call("security.IamService", "GetIamPolicy", request, IamPolicy)
+
+  def set_iam_policy(self, request: SetIamPolicyRequest = None) -> IamPolicy:
+    r"""
+    Args:
+      request (SetIamPolicyRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = SetIamPolicyRequest()
+
+    return self._client.call("security.IamService", "SetIamPolicy", request, IamPolicy)

kagglesdk/security/services/oauth_service.py

@@ -0,0 +1,58 @@
+from kagglesdk.common.types.http_redirect import HttpRedirect
+from kagglesdk.kaggle_http_client import KaggleHttpClient
+from kagglesdk.security.types.oauth_service import ExchangeOAuthTokenRequest, ExchangeOAuthTokenResponse, IntrospectTokenRequest, IntrospectTokenResponse, RegisterOAuthClientRequest, RegisterOAuthClientResponse, 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)
+
+  def introspect_token(self, request: IntrospectTokenRequest = None) -> IntrospectTokenResponse:
+    r"""
+    Args:
+      request (IntrospectTokenRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = IntrospectTokenRequest()
+
+    return self._client.call("security.OAuthService", "IntrospectToken", request, IntrospectTokenResponse)
+
+  def register_oauth_client(self, request: RegisterOAuthClientRequest = None) -> RegisterOAuthClientResponse:
+    r"""
+    Dynamic Client Registration Endpoint (RFC 7591)
+
+    Args:
+      request (RegisterOAuthClientRequest):
+        The request object; initialized to empty instance if not specified.
+    """
+
+    if request is None:
+      request = RegisterOAuthClientRequest()
+
+    return self._client.call("security.OAuthService", "RegisterOAuthClient", request, RegisterOAuthClientResponse)

kagglesdk/security/types/authentication.py

@@ -0,0 +1,171 @@
+from kagglesdk.kaggle_object import *
+from typing import Optional, List
+
+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: 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
+
+
+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: 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 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
+
+
+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
+
+
+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())),
+]
+
+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),
+]
+