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

kagglesdk/datasets/types/dataset_enums.py

@@ -21,6 +21,7 @@ class DatasetFileTypeGroup(enum.Enum):
   DATASET_FILE_TYPE_GROUP_SQLITE = 2
   DATASET_FILE_TYPE_GROUP_JSON = 3
   DATASET_FILE_TYPE_GROUP_BIG_QUERY = 4
+  DATASET_FILE_TYPE_GROUP_PARQUET = 5
 
 class DatasetLicenseGroup(enum.Enum):
   r"""
@@ -75,8 +76,28 @@ class DatasetSortBy(enum.Enum):
   """Old world"""
   DATASET_SORT_BY_LAST_VIEWED = 6
   DATASET_SORT_BY_USABILITY = 7
+  DATASET_SORT_BY_DOWNLOAD_COUNT = 8
+  DATASET_SORT_BY_NOTEBOOK_COUNT = 9
 
 class DatasetViewedGroup(enum.Enum):
   DATASET_VIEWED_GROUP_UNSPECIFIED = 0
   DATASET_VIEWED_GROUP_VIEWED = 1
 
+class DatabundleVersionType(enum.Enum):
+  DATABUNDLE_VERSION_TYPE_UNSPECIFIED = 0
+  FILESET = 1
+  BIG_QUERY = 2
+  REMOTE_URL_FILE_SET = 3
+  REMOTE_GIT_REPOSITORY_FILE_SET = 4
+  KERNEL_OUTPUT_FILE_SET = 5
+  GCS_FILE_SET = 6
+  API_MODEL = 7
+  REMOTE_HUGGING_FACE_REPOSITORY_FILE_SET = 8
+
+class DatasetFileType(enum.Enum):
+  DATASET_FILE_TYPE_UNSPECIFIED = 0
+  DATASET_FILE_TYPE_CSV = 1
+  DATASET_FILE_TYPE_JSON = 2
+  DATASET_FILE_TYPE_SQLITE = 3
+  DATASET_FILE_TYPE_OTHER = 4
+

kagglesdk/datasets/types/dataset_service.py

@@ -0,0 +1,145 @@
+from datetime import datetime
+from kagglesdk.datasets.types.dataset_enums import DatabundleVersionStatus
+from kagglesdk.kaggle_object import *
+from typing import Optional
+
+class DatabundleVersionCreationStatus(KaggleObject):
+  r"""
+  Attributes:
+    status (DatabundleVersionStatus)
+    creation_percent_complete (float)
+    creation_exception (str)
+    creation_last_update (datetime)
+    creation_step (str)
+    creation_start (datetime)
+    user_message (str)
+    version_number (int)
+  """
+
+  def __init__(self):
+    self._status = DatabundleVersionStatus.NOT_YET_PERSISTED
+    self._creation_percent_complete = 0.0
+    self._creation_exception = None
+    self._creation_last_update = None
+    self._creation_step = None
+    self._creation_start = None
+    self._user_message = None
+    self._version_number = None
+    self._freeze()
+
+  @property
+  def status(self) -> 'DatabundleVersionStatus':
+    return self._status
+
+  @status.setter
+  def status(self, status: 'DatabundleVersionStatus'):
+    if status is None:
+      del self.status
+      return
+    if not isinstance(status, DatabundleVersionStatus):
+      raise TypeError('status must be of type DatabundleVersionStatus')
+    self._status = status
+
+  @property
+  def creation_percent_complete(self) -> float:
+    return self._creation_percent_complete
+
+  @creation_percent_complete.setter
+  def creation_percent_complete(self, creation_percent_complete: float):
+    if creation_percent_complete is None:
+      del self.creation_percent_complete
+      return
+    if not isinstance(creation_percent_complete, float):
+      raise TypeError('creation_percent_complete must be of type float')
+    self._creation_percent_complete = creation_percent_complete
+
+  @property
+  def creation_exception(self) -> str:
+    return self._creation_exception or ""
+
+  @creation_exception.setter
+  def creation_exception(self, creation_exception: Optional[str]):
+    if creation_exception is None:
+      del self.creation_exception
+      return
+    if not isinstance(creation_exception, str):
+      raise TypeError('creation_exception must be of type str')
+    self._creation_exception = creation_exception
+
+  @property
+  def creation_last_update(self) -> datetime:
+    return self._creation_last_update
+
+  @creation_last_update.setter
+  def creation_last_update(self, creation_last_update: datetime):
+    if creation_last_update is None:
+      del self.creation_last_update
+      return
+    if not isinstance(creation_last_update, datetime):
+      raise TypeError('creation_last_update must be of type datetime')
+    self._creation_last_update = creation_last_update
+
+  @property
+  def creation_step(self) -> str:
+    return self._creation_step or ""
+
+  @creation_step.setter
+  def creation_step(self, creation_step: Optional[str]):
+    if creation_step is None:
+      del self.creation_step
+      return
+    if not isinstance(creation_step, str):
+      raise TypeError('creation_step must be of type str')
+    self._creation_step = creation_step
+
+  @property
+  def creation_start(self) -> datetime:
+    return self._creation_start
+
+  @creation_start.setter
+  def creation_start(self, creation_start: datetime):
+    if creation_start is None:
+      del self.creation_start
+      return
+    if not isinstance(creation_start, datetime):
+      raise TypeError('creation_start must be of type datetime')
+    self._creation_start = creation_start
+
+  @property
+  def user_message(self) -> str:
+    return self._user_message or ""
+
+  @user_message.setter
+  def user_message(self, user_message: Optional[str]):
+    if user_message is None:
+      del self.user_message
+      return
+    if not isinstance(user_message, str):
+      raise TypeError('user_message must be of type str')
+    self._user_message = user_message
+
+  @property
+  def version_number(self) -> int:
+    return self._version_number or 0
+
+  @version_number.setter
+  def version_number(self, version_number: Optional[int]):
+    if version_number is None:
+      del self.version_number
+      return
+    if not isinstance(version_number, int):
+      raise TypeError('version_number must be of type int')
+    self._version_number = version_number
+
+
+DatabundleVersionCreationStatus._fields = [
+  FieldMetadata("status", "status", "_status", DatabundleVersionStatus, DatabundleVersionStatus.NOT_YET_PERSISTED, EnumSerializer()),
+  FieldMetadata("creationPercentComplete", "creation_percent_complete", "_creation_percent_complete", float, 0.0, PredefinedSerializer()),
+  FieldMetadata("creationException", "creation_exception", "_creation_exception", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("creationLastUpdate", "creation_last_update", "_creation_last_update", datetime, None, DateTimeSerializer()),
+  FieldMetadata("creationStep", "creation_step", "_creation_step", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("creationStart", "creation_start", "_creation_start", datetime, None, DateTimeSerializer()),
+  FieldMetadata("userMessage", "user_message", "_user_message", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("versionNumber", "version_number", "_version_number", int, None, PredefinedSerializer(), optional=True),
+]
+

kagglesdk/datasets/types/dataset_types.py

@@ -2,6 +2,62 @@ from kagglesdk.kaggle_object import *
 from kagglesdk.users.types.users_enums import CollaboratorType
 from typing import Optional, List
 
+class DatasetCollaborator(KaggleObject):
+  r"""
+  Attributes:
+    username (str)
+    group_slug (str)
+    role (CollaboratorType)
+  """
+
+  def __init__(self):
+    self._username = None
+    self._group_slug = None
+    self._role = CollaboratorType.COLLABORATOR_TYPE_UNSPECIFIED
+    self._freeze()
+
+  @property
+  def username(self) -> str:
+    return self._username or ""
+
+  @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')
+    del self.group_slug
+    self._username = username
+
+  @property
+  def group_slug(self) -> str:
+    return self._group_slug or ""
+
+  @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')
+    del self.username
+    self._group_slug = group_slug
+
+  @property
+  def role(self) -> 'CollaboratorType':
+    return self._role
+
+  @role.setter
+  def role(self, role: 'CollaboratorType'):
+    if role is None:
+      del self.role
+      return
+    if not isinstance(role, CollaboratorType):
+      raise TypeError('role must be of type CollaboratorType')
+    self._role = role
+
+
 class DatasetInfo(KaggleObject):
   r"""
   Attributes:
@@ -60,7 +116,7 @@ class DatasetInfo(KaggleObject):
     return self._dataset_slug or ""
 
   @dataset_slug.setter
-  def dataset_slug(self, dataset_slug: str):
+  def dataset_slug(self, dataset_slug: Optional[str]):
     if dataset_slug is None:
       del self.dataset_slug
       return
@@ -73,7 +129,7 @@ class DatasetInfo(KaggleObject):
     return self._owner_user or ""
 
   @owner_user.setter
-  def owner_user(self, owner_user: str):
+  def owner_user(self, owner_user: Optional[str]):
     if owner_user is None:
       del self.owner_user
       return
@@ -86,7 +142,7 @@ class DatasetInfo(KaggleObject):
     return self._usability_rating or 0.0
 
   @usability_rating.setter
-  def usability_rating(self, usability_rating: float):
+  def usability_rating(self, usability_rating: Optional[float]):
     if usability_rating is None:
       del self.usability_rating
       return
@@ -142,7 +198,7 @@ class DatasetInfo(KaggleObject):
     return self._title or ""
 
   @title.setter
-  def title(self, title: str):
+  def title(self, title: Optional[str]):
     if title is None:
       del self.title
       return
@@ -155,7 +211,7 @@ class DatasetInfo(KaggleObject):
     return self._subtitle or ""
 
   @subtitle.setter
-  def subtitle(self, subtitle: str):
+  def subtitle(self, subtitle: Optional[str]):
     if subtitle is None:
       del self.subtitle
       return
@@ -168,7 +224,7 @@ class DatasetInfo(KaggleObject):
     return self._description or ""
 
   @description.setter
-  def description(self, description: str):
+  def description(self, description: Optional[str]):
     if description is None:
       del self.description
       return
@@ -279,7 +335,7 @@ class DatasetSettings(KaggleObject):
     return self._title or ""
 
   @title.setter
-  def title(self, title: str):
+  def title(self, title: Optional[str]):
     if title is None:
       del self.title
       return
@@ -292,7 +348,7 @@ class DatasetSettings(KaggleObject):
     return self._subtitle or ""
 
   @subtitle.setter
-  def subtitle(self, subtitle: str):
+  def subtitle(self, subtitle: Optional[str]):
     if subtitle is None:
       del self.subtitle
       return
@@ -305,7 +361,7 @@ class DatasetSettings(KaggleObject):
     return self._description or ""
 
   @description.setter
-  def description(self, description: str):
+  def description(self, description: Optional[str]):
     if description is None:
       del self.description
       return
@@ -421,7 +477,7 @@ class DatasetSettingsFile(KaggleObject):
     return self._description or ""
 
   @description.setter
-  def description(self, description: str):
+  def description(self, description: Optional[str]):
     if description is None:
       del self.description
       return
@@ -490,7 +546,7 @@ class DatasetSettingsFileColumn(KaggleObject):
     return self._description or ""
 
   @description.setter
-  def description(self, description: str):
+  def description(self, description: Optional[str]):
     if description is None:
       del self.description
       return
@@ -503,7 +559,7 @@ class DatasetSettingsFileColumn(KaggleObject):
     return self._type or ""
 
   @type.setter
-  def type(self, type: str):
+  def type(self, type: Optional[str]):
     if type is None:
       del self.type
       return
@@ -527,7 +583,7 @@ class SettingsLicense(KaggleObject):
     return self._name or ""
 
   @name.setter
-  def name(self, name: str):
+  def name(self, name: Optional[str]):
     if name is None:
       del self.name
       return
@@ -536,61 +592,11 @@ class SettingsLicense(KaggleObject):
     self._name = name
 
 
-class DatasetCollaborator(KaggleObject):
-  r"""
-  Attributes:
-    username (str)
-    group_slug (str)
-    role (CollaboratorType)
-  """
-
-  def __init__(self):
-    self._username = None
-    self._group_slug = None
-    self._role = CollaboratorType.COLLABORATOR_TYPE_UNSPECIFIED
-    self._freeze()
-
-  @property
-  def username(self) -> str:
-    return self._username or ""
-
-  @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')
-    del self.group_slug
-    self._username = username
-
-  @property
-  def group_slug(self) -> str:
-    return self._group_slug or ""
-
-  @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')
-    del self.username
-    self._group_slug = group_slug
-
-  @property
-  def role(self) -> 'CollaboratorType':
-    return self._role
-
-  @role.setter
-  def role(self, role: 'CollaboratorType'):
-    if role is None:
-      del self.role
-      return
-    if not isinstance(role, CollaboratorType):
-      raise TypeError('role must be of type CollaboratorType')
-    self._role = role
-
+DatasetCollaborator._fields = [
+  FieldMetadata("username", "username", "_username", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("groupSlug", "group_slug", "_group_slug", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("role", "role", "_role", CollaboratorType, CollaboratorType.COLLABORATOR_TYPE_UNSPECIFIED, EnumSerializer()),
+]
 
 DatasetInfo._fields = [
   FieldMetadata("datasetId", "dataset_id", "_dataset_id", int, 0, PredefinedSerializer()),
@@ -638,9 +644,3 @@ SettingsLicense._fields = [
   FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True),
 ]
 
-DatasetCollaborator._fields = [
-  FieldMetadata("username", "username", "_username", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("groupSlug", "group_slug", "_group_slug", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("role", "role", "_role", CollaboratorType, CollaboratorType.COLLABORATOR_TYPE_UNSPECIFIED, EnumSerializer()),
-]
-

kagglesdk/datasets/types/search_datasets.py

@@ -0,0 +1,6 @@
+import enum
+
+class SearchDatasetsOrderBy(enum.Enum):
+  SEARCH_DATASETS_ORDER_BY_UNSPECIFIED = 0
+  SEARCH_DATASETS_ORDER_BY_USABILITY_RATING = 1
+

kagglesdk/discussions/types/search_discussions.py

@@ -0,0 +1,43 @@
+import enum
+
+class SearchDiscussionsOrderBy(enum.Enum):
+  SEARCH_DISCUSSIONS_ORDER_BY_UNSPECIFIED = 0
+  SEARCH_DISCUSSIONS_ORDER_BY_LAST_TOPIC_COMMENT_DATE = 1
+
+class SearchDiscussionsDocumentType(enum.Enum):
+  SEARCH_DISCUSSIONS_DOCUMENT_TYPE_UNSPECIFIED = 0
+  SEARCH_DISCUSSIONS_DOCUMENT_TYPE_COMMENT = 1
+  SEARCH_DISCUSSIONS_DOCUMENT_TYPE_TOPIC = 2
+  SEARCH_DISCUSSIONS_DOCUMENT_TYPE_WRITE_UP = 3
+
+class SearchDiscussionsSourceType(enum.Enum):
+  SEARCH_DISCUSSIONS_SOURCE_TYPE_UNSPECIFIED = 0
+  SEARCH_DISCUSSIONS_SOURCE_TYPE_COMPETITION = 1
+  SEARCH_DISCUSSIONS_SOURCE_TYPE_DATASET = 2
+  SEARCH_DISCUSSIONS_SOURCE_TYPE_KERNEL = 4
+  SEARCH_DISCUSSIONS_SOURCE_TYPE_SITE_FORUM = 5
+  SEARCH_DISCUSSIONS_SOURCE_TYPE_COMPETITION_SOLUTION = 6
+  SEARCH_DISCUSSIONS_SOURCE_TYPE_MODEL = 7
+  SEARCH_DISCUSSIONS_SOURCE_TYPE_WRITE_UP = 8
+  SEARCH_DISCUSSIONS_SOURCE_TYPE_LEARN_TRACK = 9
+
+class SearchDiscussionsTopicType(enum.Enum):
+  SEARCH_DISCUSSIONS_TOPIC_TYPE_UNSPECIFIED = 0
+  SEARCH_DISCUSSIONS_TOPIC_TYPE_TOPICS = 1
+  SEARCH_DISCUSSIONS_TOPIC_TYPE_WRITE_UPS = 2
+
+class WriteUpInclusionType(enum.Enum):
+  WRITE_UP_INCLUSION_TYPE_UNSPECIFIED = 0
+  WRITE_UP_INCLUSION_TYPE_EXCLUDE = 1
+  r"""
+  Only ForumTopics will be included, while
+  WriteUps will be excluded
+  """
+  WRITE_UP_INCLUSION_TYPE_INCLUDE = 2
+  """WriteUps and ForumTopics will be included"""
+  WRITE_UP_INCLUSION_TYPE_ONLY = 3
+  r"""
+  Only WriteUps will be included, while
+  ForumTopics will be excluded
+  """
+

kagglesdk/discussions/types/writeup_enums.py

@@ -0,0 +1,11 @@
+import enum
+
+class WriteUpType(enum.Enum):
+  WRITE_UP_TYPE_UNSPECIFIED = 0
+  HACKATHON_PROJECT = 1
+  COMPETITION_SOLUTION = 2
+  PERSONAL_PROJECT = 3
+  KNOWLEDGE = 4
+  FORUM_TOPIC = 5
+  BLOG = 6
+

kagglesdk/education/services/education_api_service.py

@@ -16,4 +16,4 @@ class EducationApiClient(object):
     if request is None:
       request = ApiTrackExerciseInteractionRequest()
 
-    return self._client.call("education.EducationApiService", "ApiTrackExerciseInteraction", request, ApiTrackExerciseInteractionResponse)
+    return self._client.call("education.EducationApiService", "TrackExerciseInteraction", request, ApiTrackExerciseInteractionResponse)

kagglesdk/education/types/education_api_service.py

@@ -159,7 +159,7 @@ class ApiTrackExerciseInteractionRequest(KaggleObject):
     return self._value_towards_completion or 0.0
 
   @value_towards_completion.setter
-  def value_towards_completion(self, value_towards_completion: float):
+  def value_towards_completion(self, value_towards_completion: Optional[float]):
     if value_towards_completion is None:
       del self.value_towards_completion
       return

kagglesdk/kaggle_client.py

@@ -1,34 +1,38 @@
-from kagglesdk.kernels.services.kernels_api_service import KernelsApiClient
+from kagglesdk.admin.services.inbox_file_service import InboxFileClient
+from kagglesdk.benchmarks.services.benchmarks_api_service import BenchmarksApiClient
 from kagglesdk.blobs.services.blob_api_service import BlobApiClient
+from kagglesdk.common.services.operations_service import OperationsClient
+from kagglesdk.competitions.services.competition_api_service import CompetitionApiClient
+from kagglesdk.datasets.services.dataset_api_service import DatasetApiClient
 from kagglesdk.education.services.education_api_service import EducationApiClient
+from kagglesdk.kernels.services.kernels_api_service import KernelsApiClient
 from kagglesdk.models.services.model_api_service import ModelApiClient
 from kagglesdk.models.services.model_service import ModelClient
-from kagglesdk.competitions.services.competition_api_service import CompetitionApiClient
-from kagglesdk.datasets.services.dataset_api_service import DatasetApiClient
-from kagglesdk.admin.services.inbox_file_service import InboxFileClient
+from kagglesdk.search.services.search_api_service import SearchApiClient
+from kagglesdk.security.services.iam_service import IamClient
 from kagglesdk.security.services.oauth_service import OAuthClient
 from kagglesdk.users.services.account_service import AccountClient
+from kagglesdk.users.services.group_api_service import GroupApiClient
 from kagglesdk.kaggle_env import KaggleEnv
 from kagglesdk.kaggle_http_client import KaggleHttpClient
 
 
 class KaggleClient(object):
-  class Kernels(object):
+  class Admin(object):
     def __init__(self, http_client: KaggleHttpClient):
-      self.kernels_api_client = KernelsApiClient(http_client)
+      self.inbox_file_client = InboxFileClient(http_client)
 
-  class Blobs(object):
+  class Benchmarks(object):
     def __init__(self, http_client: KaggleHttpClient):
-      self.blob_api_client = BlobApiClient(http_client)
+      self.benchmarks_api_client = BenchmarksApiClient(http_client)
 
-  class Education(object):
+  class Blobs(object):
     def __init__(self, http_client: KaggleHttpClient):
-      self.education_api_client = EducationApiClient(http_client)
+      self.blob_api_client = BlobApiClient(http_client)
 
-  class Models(object):
+  class Common(object):
     def __init__(self, http_client: KaggleHttpClient):
-      self.model_api_client = ModelApiClient(http_client)
-      self.model_client = ModelClient(http_client)
+      self.operations_client = OperationsClient(http_client)
 
   class Competitions(object):
     def __init__(self, http_client: KaggleHttpClient):
@@ -38,36 +42,55 @@ class KaggleClient(object):
     def __init__(self, http_client: KaggleHttpClient):
       self.dataset_api_client = DatasetApiClient(http_client)
 
-  class Admin(object):
+  class Education(object):
     def __init__(self, http_client: KaggleHttpClient):
-      self.inbox_file_client = InboxFileClient(http_client)
+      self.education_api_client = EducationApiClient(http_client)
+
+  class Kernels(object):
+    def __init__(self, http_client: KaggleHttpClient):
+      self.kernels_api_client = KernelsApiClient(http_client)
+
+  class Models(object):
+    def __init__(self, http_client: KaggleHttpClient):
+      self.model_api_client = ModelApiClient(http_client)
+      self.model_client = ModelClient(http_client)
+
+  class Search(object):
+    def __init__(self, http_client: KaggleHttpClient):
+      self.search_api_client = SearchApiClient(http_client)
 
   class Security(object):
     def __init__(self, http_client: KaggleHttpClient):
+      self.iam_client = IamClient(http_client)
       self.oauth_client = OAuthClient(http_client)
 
   class Users(object):
     def __init__(self, http_client: KaggleHttpClient):
       self.account_client = AccountClient(http_client)
+      self.group_api_client = GroupApiClient(http_client)
 
-  def __init__(self, env: KaggleEnv = None, verbose: bool = False, username: str = None, password: str = None):
-    self._http_client = http_client = KaggleHttpClient(env, verbose, self._renew_iap_token, username=username, password=password)
-    self.kernels = KaggleClient.Kernels(http_client)
+  def __init__(self, env: KaggleEnv = None, verbose: bool = False, username: str = None, password: str = None, api_token: str = None):
+    self._http_client = http_client = KaggleHttpClient(env, verbose, username=username, password=password, api_token=api_token)
+    self.admin = KaggleClient.Admin(http_client)
+    self.benchmarks = KaggleClient.Benchmarks(http_client)
     self.blobs = KaggleClient.Blobs(http_client)
-    self.education = KaggleClient.Education(http_client)
-    self.models = KaggleClient.Models(http_client)
+    self.common = KaggleClient.Common(http_client)
     self.competitions = KaggleClient.Competitions(http_client)
     self.datasets = KaggleClient.Datasets(http_client)
-    self.admin = KaggleClient.Admin(http_client)
+    self.education = KaggleClient.Education(http_client)
+    self.kernels = KaggleClient.Kernels(http_client)
+    self.models = KaggleClient.Models(http_client)
+    self.search = KaggleClient.Search(http_client)
     self.security = KaggleClient.Security(http_client)
     self.users = KaggleClient.Users(http_client)
     self.username = username
     self.password = password
+    self.api_token = api_token
 
-  def http_client(self):
+  def http_client(self) -> str:
     return self._http_client
 
-  def _renew_iap_token(self):
+  def _renew_iap_token(self) -> str:
     return self.admin.admin_client.renew_iap_token()
 
   def __enter__(self):