kaggle 1.7.3b1__py3-none-any.whl

kagglesdk/models/types/model_enums.py

@@ -0,0 +1,60 @@
+import enum
+
+class GatingAgreementRequestsExpiryStatus(enum.Enum):
+  GATING_AGREEMENT_REQUESTS_EXPIRY_STATUS_UNSPECIFIED = 0
+  GATING_AGREEMENT_REQUESTS_EXPIRY_STATUS_NOT_EXPIRED = 1
+  GATING_AGREEMENT_REQUESTS_EXPIRY_STATUS_IS_EXPIRED = 2
+
+class GatingAgreementRequestsReviewStatus(enum.Enum):
+  GATING_AGREEMENT_REQUESTS_REVIEW_STATUS_UNSPECIFIED = 0
+  GATING_AGREEMENT_REQUESTS_REVIEW_STATUS_PENDING = 1
+  GATING_AGREEMENT_REQUESTS_REVIEW_STATUS_ACCEPTED = 2
+  GATING_AGREEMENT_REQUESTS_REVIEW_STATUS_REJECTED = 3
+
+class ListModelsOrderBy(enum.Enum):
+  LIST_MODELS_ORDER_BY_UNSPECIFIED = 0
+  LIST_MODELS_ORDER_BY_HOTNESS = 1
+  LIST_MODELS_ORDER_BY_DOWNLOAD_COUNT = 2
+  LIST_MODELS_ORDER_BY_VOTE_COUNT = 3
+  LIST_MODELS_ORDER_BY_NOTEBOOK_COUNT = 4
+  LIST_MODELS_ORDER_BY_PUBLISH_TIME = 5
+  LIST_MODELS_ORDER_BY_CREATE_TIME = 6
+  LIST_MODELS_ORDER_BY_UPDATE_TIME = 7
+  LIST_MODELS_ORDER_BY_VIEW_TIME_DESC = 8
+
+class ModelFramework(enum.Enum):
+  MODEL_FRAMEWORK_UNSPECIFIED = 0
+  MODEL_FRAMEWORK_TENSOR_FLOW_1 = 1
+  MODEL_FRAMEWORK_TENSOR_FLOW_2 = 2
+  MODEL_FRAMEWORK_TF_LITE = 3
+  MODEL_FRAMEWORK_TF_JS = 4
+  MODEL_FRAMEWORK_PY_TORCH = 5
+  MODEL_FRAMEWORK_JAX = 6
+  MODEL_FRAMEWORK_FLAX = 14
+  MODEL_FRAMEWORK_PAX = 15
+  MODEL_FRAMEWORK_MAX_TEXT = 17
+  MODEL_FRAMEWORK_GEMMA_CPP = 18
+  MODEL_FRAMEWORK_GGML = 19
+  MODEL_FRAMEWORK_GGUF = 21
+  MODEL_FRAMEWORK_CORAL = 7
+  MODEL_FRAMEWORK_SCIKIT_LEARN = 8
+  MODEL_FRAMEWORK_MXNET = 9
+  MODEL_FRAMEWORK_ONNX = 10
+  MODEL_FRAMEWORK_KERAS = 11
+  MODEL_FRAMEWORK_TRANSFORMERS = 16
+  MODEL_FRAMEWORK_API = 12
+  MODEL_FRAMEWORK_OTHER = 13
+  MODEL_FRAMEWORK_TENSOR_RT_LLM = 20
+  MODEL_FRAMEWORK_TRITON = 22
+
+class ModelInstanceType(enum.Enum):
+  MODEL_INSTANCE_TYPE_UNSPECIFIED = 0
+  MODEL_INSTANCE_TYPE_BASE_MODEL = 1
+  MODEL_INSTANCE_TYPE_KAGGLE_VARIANT = 2
+  MODEL_INSTANCE_TYPE_EXTERNAL_VARIANT = 3
+
+class ModelVersionLinkType(enum.Enum):
+  MODEL_VERSION_LINK_TYPE_UNSPECIFIED = 0
+  MODEL_VERSION_LINK_TYPE_VERTEX_OPEN = 1
+  MODEL_VERSION_LINK_TYPE_VERTEX_DEPLOY = 2
+

kagglesdk/models/types/model_service.py

@@ -0,0 +1,275 @@
+from datetime import datetime
+from kagglesdk.kaggle_object import *
+from kagglesdk.models.types.model_enums import ModelFramework
+from typing import Optional, List
+
+class GetModelMetricsRequest(KaggleObject):
+  r"""
+  Attributes:
+    owner_slug (str)
+    model_slug (str)
+    start_time (datetime)
+      Optional start time for the time series. A year ago by default.
+  """
+
+  def __init__(self):
+    self._owner_slug = ""
+    self._model_slug = ""
+    self._start_time = None
+    self._freeze()
+
+  @property
+  def owner_slug(self) -> str:
+    return self._owner_slug
+
+  @owner_slug.setter
+  def owner_slug(self, owner_slug: str):
+    if owner_slug is None:
+      del self.owner_slug
+      return
+    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 start_time(self) -> datetime:
+    """Optional start time for the time series. A year ago by default."""
+    return self._start_time or None
+
+  @start_time.setter
+  def start_time(self, start_time: datetime):
+    if start_time is None:
+      del self.start_time
+      return
+    if not isinstance(start_time, datetime):
+      raise TypeError('start_time must be of type datetime')
+    self._start_time = start_time
+
+  def endpoint(self):
+    path = '/api/v1/models/{owner_slug}/{model_slug}/metrics'
+    return path.format_map(self.to_field_map(self))
+
+  @staticmethod
+  def endpoint_path():
+    return '/models/{owner_slug}/{model_slug}/metrics'
+
+
+class GetModelMetricsResponse(KaggleObject):
+  r"""
+  Attributes:
+    metrics (ModelMetric)
+  """
+
+  def __init__(self):
+    self._metrics = []
+    self._freeze()
+
+  @property
+  def metrics(self) -> Optional[List[Optional['ModelMetric']]]:
+    return self._metrics
+
+  @metrics.setter
+  def metrics(self, metrics: Optional[List[Optional['ModelMetric']]]):
+    if metrics is None:
+      del self.metrics
+      return
+    if not isinstance(metrics, list):
+      raise TypeError('metrics must be of type list')
+    if not all([isinstance(t, ModelMetric) for t in metrics]):
+      raise TypeError('metrics must contain only items of type ModelMetric')
+    self._metrics = metrics
+
+
+class ModelMetric(KaggleObject):
+  r"""
+  Attributes:
+    date (str)
+    views (int)
+    downloads (int)
+    notebooks (int)
+    instances (ModelInstanceMetric)
+  """
+
+  def __init__(self):
+    self._date = ""
+    self._views = 0
+    self._downloads = 0
+    self._notebooks = 0
+    self._instances = []
+    self._freeze()
+
+  @property
+  def date(self) -> str:
+    return self._date
+
+  @date.setter
+  def date(self, date: str):
+    if date is None:
+      del self.date
+      return
+    if not isinstance(date, str):
+      raise TypeError('date must be of type str')
+    self._date = date
+
+  @property
+  def views(self) -> int:
+    return self._views
+
+  @views.setter
+  def views(self, views: int):
+    if views is None:
+      del self.views
+      return
+    if not isinstance(views, int):
+      raise TypeError('views must be of type int')
+    self._views = views
+
+  @property
+  def downloads(self) -> int:
+    return self._downloads
+
+  @downloads.setter
+  def downloads(self, downloads: int):
+    if downloads is None:
+      del self.downloads
+      return
+    if not isinstance(downloads, int):
+      raise TypeError('downloads must be of type int')
+    self._downloads = downloads
+
+  @property
+  def notebooks(self) -> int:
+    return self._notebooks
+
+  @notebooks.setter
+  def notebooks(self, notebooks: int):
+    if notebooks is None:
+      del self.notebooks
+      return
+    if not isinstance(notebooks, int):
+      raise TypeError('notebooks must be of type int')
+    self._notebooks = notebooks
+
+  @property
+  def instances(self) -> Optional[List[Optional['ModelInstanceMetric']]]:
+    return self._instances
+
+  @instances.setter
+  def instances(self, instances: Optional[List[Optional['ModelInstanceMetric']]]):
+    if instances is None:
+      del self.instances
+      return
+    if not isinstance(instances, list):
+      raise TypeError('instances must be of type list')
+    if not all([isinstance(t, ModelInstanceMetric) for t in instances]):
+      raise TypeError('instances must contain only items of type ModelInstanceMetric')
+    self._instances = instances
+
+
+class ModelInstanceMetric(KaggleObject):
+  r"""
+  Attributes:
+    variation (str)
+    framework (ModelFramework)
+    downloads (int)
+    notebooks (int)
+  """
+
+  def __init__(self):
+    self._variation = ""
+    self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED
+    self._downloads = 0
+    self._notebooks = 0
+    self._freeze()
+
+  @property
+  def variation(self) -> str:
+    return self._variation
+
+  @variation.setter
+  def variation(self, variation: str):
+    if variation is None:
+      del self.variation
+      return
+    if not isinstance(variation, str):
+      raise TypeError('variation must be of type str')
+    self._variation = variation
+
+  @property
+  def framework(self) -> 'ModelFramework':
+    return self._framework
+
+  @framework.setter
+  def framework(self, framework: 'ModelFramework'):
+    if framework is None:
+      del self.framework
+      return
+    if not isinstance(framework, ModelFramework):
+      raise TypeError('framework must be of type ModelFramework')
+    self._framework = framework
+
+  @property
+  def downloads(self) -> int:
+    return self._downloads
+
+  @downloads.setter
+  def downloads(self, downloads: int):
+    if downloads is None:
+      del self.downloads
+      return
+    if not isinstance(downloads, int):
+      raise TypeError('downloads must be of type int')
+    self._downloads = downloads
+
+  @property
+  def notebooks(self) -> int:
+    return self._notebooks
+
+  @notebooks.setter
+  def notebooks(self, notebooks: int):
+    if notebooks is None:
+      del self.notebooks
+      return
+    if not isinstance(notebooks, int):
+      raise TypeError('notebooks must be of type int')
+    self._notebooks = notebooks
+
+
+GetModelMetricsRequest._fields = [
+  FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("startTime", "start_time", "_start_time", datetime, None, DateTimeSerializer(), optional=True),
+]
+
+GetModelMetricsResponse._fields = [
+  FieldMetadata("metrics", "metrics", "_metrics", ModelMetric, [], ListSerializer(KaggleObjectSerializer())),
+]
+
+ModelMetric._fields = [
+  FieldMetadata("date", "date", "_date", str, "", PredefinedSerializer()),
+  FieldMetadata("views", "views", "_views", int, 0, PredefinedSerializer()),
+  FieldMetadata("downloads", "downloads", "_downloads", int, 0, PredefinedSerializer()),
+  FieldMetadata("notebooks", "notebooks", "_notebooks", int, 0, PredefinedSerializer()),
+  FieldMetadata("instances", "instances", "_instances", ModelInstanceMetric, [], ListSerializer(KaggleObjectSerializer())),
+]
+
+ModelInstanceMetric._fields = [
+  FieldMetadata("variation", "variation", "_variation", str, "", PredefinedSerializer()),
+  FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("downloads", "downloads", "_downloads", int, 0, PredefinedSerializer()),
+  FieldMetadata("notebooks", "notebooks", "_notebooks", int, 0, PredefinedSerializer()),
+]
+

kagglesdk/models/types/model_types.py

@@ -0,0 +1,286 @@
+from kagglesdk.kaggle_object import *
+from kagglesdk.models.types.model_enums import ModelFramework, ModelVersionLinkType
+from kagglesdk.users.types.users_enums import UserAchievementTier
+from typing import Optional
+
+class BaseModelInstanceInformation(KaggleObject):
+  r"""
+  Attributes:
+    id (int)
+    owner (Owner)
+    model_slug (str)
+    instance_slug (str)
+    framework (ModelFramework)
+  """
+
+  def __init__(self):
+    self._id = 0
+    self._owner = None
+    self._model_slug = ""
+    self._instance_slug = ""
+    self._framework = ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED
+    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 owner(self) -> Optional['Owner']:
+    return self._owner
+
+  @owner.setter
+  def owner(self, owner: Optional['Owner']):
+    if owner is None:
+      del self.owner
+      return
+    if not isinstance(owner, Owner):
+      raise TypeError('owner must be of type Owner')
+    self._owner = owner
+
+  @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 instance_slug(self) -> str:
+    return self._instance_slug
+
+  @instance_slug.setter
+  def instance_slug(self, instance_slug: str):
+    if instance_slug is None:
+      del self.instance_slug
+      return
+    if not isinstance(instance_slug, str):
+      raise TypeError('instance_slug must be of type str')
+    self._instance_slug = instance_slug
+
+  @property
+  def framework(self) -> 'ModelFramework':
+    return self._framework
+
+  @framework.setter
+  def framework(self, framework: 'ModelFramework'):
+    if framework is None:
+      del self.framework
+      return
+    if not isinstance(framework, ModelFramework):
+      raise TypeError('framework must be of type ModelFramework')
+    self._framework = framework
+
+
+class ModelLink(KaggleObject):
+  r"""
+  Attributes:
+    type (ModelVersionLinkType)
+    url (str)
+  """
+
+  def __init__(self):
+    self._type = ModelVersionLinkType.MODEL_VERSION_LINK_TYPE_UNSPECIFIED
+    self._url = ""
+    self._freeze()
+
+  @property
+  def type(self) -> 'ModelVersionLinkType':
+    return self._type
+
+  @type.setter
+  def type(self, type: 'ModelVersionLinkType'):
+    if type is None:
+      del self.type
+      return
+    if not isinstance(type, ModelVersionLinkType):
+      raise TypeError('type must be of type ModelVersionLinkType')
+    self._type = type
+
+  @property
+  def url(self) -> str:
+    return self._url
+
+  @url.setter
+  def url(self, url: str):
+    if url is None:
+      del self.url
+      return
+    if not isinstance(url, str):
+      raise TypeError('url must be of type str')
+    self._url = url
+
+
+class Owner(KaggleObject):
+  r"""
+  Based off Datasets OwnerDto as the permission model is the same
+  Separate message since Models don't have max_file_size_bytes.
+  Consider renaming more generically to apply to Users/Orgs
+  interchangeably without a strict concept of ownership
+
+  Attributes:
+    id (int)
+    image_url (str)
+    is_organization (bool)
+    name (str)
+    profile_url (str)
+    slug (str)
+    user_tier (UserAchievementTier)
+    allow_model_gating (bool)
+  """
+
+  def __init__(self):
+    self._id = 0
+    self._image_url = None
+    self._is_organization = False
+    self._name = ""
+    self._profile_url = None
+    self._slug = ""
+    self._user_tier = UserAchievementTier.NOVICE
+    self._allow_model_gating = 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 image_url(self) -> str:
+    return self._image_url or ""
+
+  @image_url.setter
+  def image_url(self, image_url: str):
+    if image_url is None:
+      del self.image_url
+      return
+    if not isinstance(image_url, str):
+      raise TypeError('image_url must be of type str')
+    self._image_url = image_url
+
+  @property
+  def is_organization(self) -> bool:
+    return self._is_organization
+
+  @is_organization.setter
+  def is_organization(self, is_organization: bool):
+    if is_organization is None:
+      del self.is_organization
+      return
+    if not isinstance(is_organization, bool):
+      raise TypeError('is_organization must be of type bool')
+    self._is_organization = is_organization
+
+  @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 profile_url(self) -> str:
+    return self._profile_url or ""
+
+  @profile_url.setter
+  def profile_url(self, profile_url: str):
+    if profile_url is None:
+      del self.profile_url
+      return
+    if not isinstance(profile_url, str):
+      raise TypeError('profile_url must be of type str')
+    self._profile_url = profile_url
+
+  @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 user_tier(self) -> 'UserAchievementTier':
+    return self._user_tier
+
+  @user_tier.setter
+  def user_tier(self, user_tier: 'UserAchievementTier'):
+    if user_tier is None:
+      del self.user_tier
+      return
+    if not isinstance(user_tier, UserAchievementTier):
+      raise TypeError('user_tier must be of type UserAchievementTier')
+    self._user_tier = user_tier
+
+  @property
+  def allow_model_gating(self) -> bool:
+    return self._allow_model_gating or False
+
+  @allow_model_gating.setter
+  def allow_model_gating(self, allow_model_gating: bool):
+    if allow_model_gating is None:
+      del self.allow_model_gating
+      return
+    if not isinstance(allow_model_gating, bool):
+      raise TypeError('allow_model_gating must be of type bool')
+    self._allow_model_gating = allow_model_gating
+
+
+BaseModelInstanceInformation._fields = [
+  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("owner", "owner", "_owner", Owner, None, KaggleObjectSerializer()),
+  FieldMetadata("modelSlug", "model_slug", "_model_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("instanceSlug", "instance_slug", "_instance_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("framework", "framework", "_framework", ModelFramework, ModelFramework.MODEL_FRAMEWORK_UNSPECIFIED, EnumSerializer()),
+]
+
+ModelLink._fields = [
+  FieldMetadata("type", "type", "_type", ModelVersionLinkType, ModelVersionLinkType.MODEL_VERSION_LINK_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("url", "url", "_url", str, "", PredefinedSerializer()),
+]
+
+Owner._fields = [
+  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("imageUrl", "image_url", "_image_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("isOrganization", "is_organization", "_is_organization", bool, False, PredefinedSerializer()),
+  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
+  FieldMetadata("profileUrl", "profile_url", "_profile_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("userTier", "user_tier", "_user_tier", UserAchievementTier, UserAchievementTier.NOVICE, EnumSerializer()),
+  FieldMetadata("allowModelGating", "allow_model_gating", "_allow_model_gating", bool, None, PredefinedSerializer(), optional=True),
+]
+

kagglesdk/test/test_client.py

@@ -0,0 +1,45 @@
+from kagglesdk import kaggle_env
+from kagglesdk import KaggleClient, KaggleEnv
+
+# python -m unittest tests.test_authenticate
+
+import os
+import unittest
+
+
+class TestClient(unittest.TestCase):
+
+  def setUp(self):
+    print("setup             class:%s" % self)
+
+  def tearDown(self):
+    print("teardown          class:TestStuff")
+
+  # Environment
+
+  def test_kaggle_environment(self):
+    os.environ['KAGGLE_API_ENVIRONMENT'] = 'PROD'
+
+    env = kaggle_env.get_env()
+    self.assertEqual(env, KaggleEnv.PROD)
+
+    endpoint = kaggle_env.get_endpoint(env)
+    self.assertEqual(endpoint, 'https://www.kaggle.com')
+
+  # Client
+
+  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)
+
+
+if __name__ == '__main__':
+  unittest.main()

kagglesdk/users/types/users_enums.py

@@ -0,0 +1,22 @@
+import enum
+
+class UserAchievementTier(enum.Enum):
+  NOVICE = 0
+  CONTRIBUTOR = 1
+  EXPERT = 2
+  MASTER = 3
+  GRANDMASTER = 4
+  STAFF = 5
+  """Kaggle admins"""
+  ORGANIZATION = 11
+  """Organizations"""
+  RECALC = 21
+  """Flag user for tier recalculation"""
+
+class CollaboratorType(enum.Enum):
+  COLLABORATOR_TYPE_UNSPECIFIED = 0
+  READER = 1
+  WRITER = 2
+  OWNER = 3
+  ADMIN = 4
+