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

kagglesdk/benchmarks/types/benchmark_types.py

@@ -0,0 +1,307 @@
+from datetime import datetime
+from kagglesdk.kaggle_object import *
+from typing import Optional, List
+
+class BenchmarkResult(KaggleObject):
+  r"""
+  TODO(bml): Integrate this proto with personal benchmarks trials.
+  Represents the outcome of a benchmark run. All fields are immutable.
+
+  Attributes:
+    numeric_result (NumericResult)
+    boolean_result (bool)
+    custom_additional_results (CustomResult)
+      Generic additional results. These are rendered generically on the frontend:
+    numeric_result_private (NumericResult)
+      Numeric result on the private set of the benchmark version.
+    numeric_result_public (NumericResult)
+      Numeric result on the public set of the benchmark version.
+    evaluation_date (datetime)
+      The date on which evaluation was performed.
+    task_version_id (int)
+      Convenience fields for this result (for the frontend):
+  """
+
+  def __init__(self):
+    self._numeric_result = None
+    self._boolean_result = None
+    self._custom_additional_results = []
+    self._numeric_result_private = None
+    self._numeric_result_public = None
+    self._evaluation_date = None
+    self._task_version_id = None
+    self._freeze()
+
+  @property
+  def task_version_id(self) -> int:
+    """Convenience fields for this result (for the frontend):"""
+    return self._task_version_id or 0
+
+  @task_version_id.setter
+  def task_version_id(self, task_version_id: Optional[int]):
+    if task_version_id is None:
+      del self.task_version_id
+      return
+    if not isinstance(task_version_id, int):
+      raise TypeError('task_version_id must be of type int')
+    self._task_version_id = task_version_id
+
+  @property
+  def numeric_result(self) -> Optional['NumericResult']:
+    return self._numeric_result or None
+
+  @numeric_result.setter
+  def numeric_result(self, numeric_result: Optional['NumericResult']):
+    if numeric_result is None:
+      del self.numeric_result
+      return
+    if not isinstance(numeric_result, NumericResult):
+      raise TypeError('numeric_result must be of type NumericResult')
+    del self.boolean_result
+    self._numeric_result = numeric_result
+
+  @property
+  def boolean_result(self) -> bool:
+    return self._boolean_result or False
+
+  @boolean_result.setter
+  def boolean_result(self, boolean_result: bool):
+    if boolean_result is None:
+      del self.boolean_result
+      return
+    if not isinstance(boolean_result, bool):
+      raise TypeError('boolean_result must be of type bool')
+    del self.numeric_result
+    self._boolean_result = boolean_result
+
+  @property
+  def custom_additional_results(self) -> Optional[List[Optional['CustomResult']]]:
+    """Generic additional results. These are rendered generically on the frontend:"""
+    return self._custom_additional_results
+
+  @custom_additional_results.setter
+  def custom_additional_results(self, custom_additional_results: Optional[List[Optional['CustomResult']]]):
+    if custom_additional_results is None:
+      del self.custom_additional_results
+      return
+    if not isinstance(custom_additional_results, list):
+      raise TypeError('custom_additional_results must be of type list')
+    if not all([isinstance(t, CustomResult) for t in custom_additional_results]):
+      raise TypeError('custom_additional_results must contain only items of type CustomResult')
+    self._custom_additional_results = custom_additional_results
+
+  @property
+  def numeric_result_private(self) -> Optional['NumericResult']:
+    """Numeric result on the private set of the benchmark version."""
+    return self._numeric_result_private or None
+
+  @numeric_result_private.setter
+  def numeric_result_private(self, numeric_result_private: Optional[Optional['NumericResult']]):
+    if numeric_result_private is None:
+      del self.numeric_result_private
+      return
+    if not isinstance(numeric_result_private, NumericResult):
+      raise TypeError('numeric_result_private must be of type NumericResult')
+    self._numeric_result_private = numeric_result_private
+
+  @property
+  def numeric_result_public(self) -> Optional['NumericResult']:
+    """Numeric result on the public set of the benchmark version."""
+    return self._numeric_result_public or None
+
+  @numeric_result_public.setter
+  def numeric_result_public(self, numeric_result_public: Optional[Optional['NumericResult']]):
+    if numeric_result_public is None:
+      del self.numeric_result_public
+      return
+    if not isinstance(numeric_result_public, NumericResult):
+      raise TypeError('numeric_result_public must be of type NumericResult')
+    self._numeric_result_public = numeric_result_public
+
+  @property
+  def evaluation_date(self) -> datetime:
+    """The date on which evaluation was performed."""
+    return self._evaluation_date or None
+
+  @evaluation_date.setter
+  def evaluation_date(self, evaluation_date: Optional[datetime]):
+    if evaluation_date is None:
+      del self.evaluation_date
+      return
+    if not isinstance(evaluation_date, datetime):
+      raise TypeError('evaluation_date must be of type datetime')
+    self._evaluation_date = evaluation_date
+
+
+class CustomResult(KaggleObject):
+  r"""
+  Attributes:
+    key (str)
+    value (str)
+  """
+
+  def __init__(self):
+    self._key = ""
+    self._value = ""
+    self._freeze()
+
+  @property
+  def key(self) -> str:
+    return self._key
+
+  @key.setter
+  def key(self, key: str):
+    if key is None:
+      del self.key
+      return
+    if not isinstance(key, str):
+      raise TypeError('key must be of type str')
+    self._key = key
+
+  @property
+  def value(self) -> str:
+    return self._value
+
+  @value.setter
+  def value(self, value: str):
+    if value is None:
+      del self.value
+      return
+    if not isinstance(value, str):
+      raise TypeError('value must be of type str')
+    self._value = value
+
+
+class NumericResult(KaggleObject):
+  r"""
+  Attributes:
+    value (float)
+    confidence_interval (float)
+      Note, while we call this the 'confidence interval' - the value we store
+      here is actually the 'confidence radius', it should always be displayed
+      as a +- value.
+    uneven_confidence_interval (UnevenConfidenceInterval)
+      For asymmetric confidence intervals in which the +/- values differ
+      If set, prioritized over confidence_interval
+  """
+
+  def __init__(self):
+    self._value = 0.0
+    self._confidence_interval = None
+    self._uneven_confidence_interval = None
+    self._freeze()
+
+  @property
+  def value(self) -> float:
+    return self._value
+
+  @value.setter
+  def value(self, value: float):
+    if value is None:
+      del self.value
+      return
+    if not isinstance(value, float):
+      raise TypeError('value must be of type float')
+    self._value = value
+
+  @property
+  def confidence_interval(self) -> float:
+    r"""
+    Note, while we call this the 'confidence interval' - the value we store
+    here is actually the 'confidence radius', it should always be displayed
+    as a +- value.
+    """
+    return self._confidence_interval or 0.0
+
+  @confidence_interval.setter
+  def confidence_interval(self, confidence_interval: Optional[float]):
+    if confidence_interval is None:
+      del self.confidence_interval
+      return
+    if not isinstance(confidence_interval, float):
+      raise TypeError('confidence_interval must be of type float')
+    self._confidence_interval = confidence_interval
+
+  @property
+  def uneven_confidence_interval(self) -> Optional['UnevenConfidenceInterval']:
+    r"""
+    For asymmetric confidence intervals in which the +/- values differ
+    If set, prioritized over confidence_interval
+    """
+    return self._uneven_confidence_interval or None
+
+  @uneven_confidence_interval.setter
+  def uneven_confidence_interval(self, uneven_confidence_interval: Optional[Optional['UnevenConfidenceInterval']]):
+    if uneven_confidence_interval is None:
+      del self.uneven_confidence_interval
+      return
+    if not isinstance(uneven_confidence_interval, UnevenConfidenceInterval):
+      raise TypeError('uneven_confidence_interval must be of type UnevenConfidenceInterval')
+    self._uneven_confidence_interval = uneven_confidence_interval
+
+
+class UnevenConfidenceInterval(KaggleObject):
+  r"""
+  Attributes:
+    plus (float)
+    minus (float)
+  """
+
+  def __init__(self):
+    self._plus = 0.0
+    self._minus = 0.0
+    self._freeze()
+
+  @property
+  def plus(self) -> float:
+    return self._plus
+
+  @plus.setter
+  def plus(self, plus: float):
+    if plus is None:
+      del self.plus
+      return
+    if not isinstance(plus, float):
+      raise TypeError('plus must be of type float')
+    self._plus = plus
+
+  @property
+  def minus(self) -> float:
+    return self._minus
+
+  @minus.setter
+  def minus(self, minus: float):
+    if minus is None:
+      del self.minus
+      return
+    if not isinstance(minus, float):
+      raise TypeError('minus must be of type float')
+    self._minus = minus
+
+
+BenchmarkResult._fields = [
+  FieldMetadata("numericResult", "numeric_result", "_numeric_result", NumericResult, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("booleanResult", "boolean_result", "_boolean_result", bool, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("customAdditionalResults", "custom_additional_results", "_custom_additional_results", CustomResult, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("numericResultPrivate", "numeric_result_private", "_numeric_result_private", NumericResult, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("numericResultPublic", "numeric_result_public", "_numeric_result_public", NumericResult, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("evaluationDate", "evaluation_date", "_evaluation_date", datetime, None, DateTimeSerializer(), optional=True),
+  FieldMetadata("taskVersionId", "task_version_id", "_task_version_id", int, None, PredefinedSerializer(), optional=True),
+]
+
+CustomResult._fields = [
+  FieldMetadata("key", "key", "_key", str, "", PredefinedSerializer()),
+  FieldMetadata("value", "value", "_value", str, "", PredefinedSerializer()),
+]
+
+NumericResult._fields = [
+  FieldMetadata("value", "value", "_value", float, 0.0, PredefinedSerializer()),
+  FieldMetadata("confidenceInterval", "confidence_interval", "_confidence_interval", float, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("unevenConfidenceInterval", "uneven_confidence_interval", "_uneven_confidence_interval", UnevenConfidenceInterval, None, KaggleObjectSerializer(), optional=True),
+]
+
+UnevenConfidenceInterval._fields = [
+  FieldMetadata("plus", "plus", "_plus", float, 0.0, PredefinedSerializer()),
+  FieldMetadata("minus", "minus", "_minus", float, 0.0, PredefinedSerializer()),
+]
+

kagglesdk/benchmarks/types/benchmarks_api_service.py

@@ -0,0 +1,243 @@
+from kagglesdk.benchmarks.types.benchmark_types import BenchmarkResult
+from kagglesdk.kaggle_object import *
+from typing import List, Optional
+
+class ApiBenchmarkLeaderboard(KaggleObject):
+  r"""
+  Attributes:
+    rows (ApiBenchmarkLeaderboard.LeaderboardRow)
+  """
+
+  class LeaderboardRow(KaggleObject):
+    r"""
+    Attributes:
+      model_version_name (str)
+      model_version_slug (str)
+      task_results (ApiBenchmarkLeaderboard.TaskResult)
+    """
+
+    def __init__(self):
+      self._model_version_name = ""
+      self._model_version_slug = ""
+      self._task_results = []
+      self._freeze()
+
+    @property
+    def model_version_name(self) -> str:
+      return self._model_version_name
+
+    @model_version_name.setter
+    def model_version_name(self, model_version_name: str):
+      if model_version_name is None:
+        del self.model_version_name
+        return
+      if not isinstance(model_version_name, str):
+        raise TypeError('model_version_name must be of type str')
+      self._model_version_name = model_version_name
+
+    @property
+    def model_version_slug(self) -> str:
+      return self._model_version_slug
+
+    @model_version_slug.setter
+    def model_version_slug(self, model_version_slug: str):
+      if model_version_slug is None:
+        del self.model_version_slug
+        return
+      if not isinstance(model_version_slug, str):
+        raise TypeError('model_version_slug must be of type str')
+      self._model_version_slug = model_version_slug
+
+    @property
+    def task_results(self) -> Optional[List[Optional['ApiBenchmarkLeaderboard.TaskResult']]]:
+      return self._task_results
+
+    @task_results.setter
+    def task_results(self, task_results: Optional[List[Optional['ApiBenchmarkLeaderboard.TaskResult']]]):
+      if task_results is None:
+        del self.task_results
+        return
+      if not isinstance(task_results, list):
+        raise TypeError('task_results must be of type list')
+      if not all([isinstance(t, ApiBenchmarkLeaderboard.TaskResult) for t in task_results]):
+        raise TypeError('task_results must contain only items of type ApiBenchmarkLeaderboard.TaskResult')
+      self._task_results = task_results
+
+
+  class TaskResult(KaggleObject):
+    r"""
+    Attributes:
+      benchmark_task_name (str)
+      benchmark_task_slug (str)
+      task_version (int)
+      result (BenchmarkResult)
+    """
+
+    def __init__(self):
+      self._benchmark_task_name = ""
+      self._benchmark_task_slug = ""
+      self._task_version = 0
+      self._result = None
+      self._freeze()
+
+    @property
+    def benchmark_task_name(self) -> str:
+      return self._benchmark_task_name
+
+    @benchmark_task_name.setter
+    def benchmark_task_name(self, benchmark_task_name: str):
+      if benchmark_task_name is None:
+        del self.benchmark_task_name
+        return
+      if not isinstance(benchmark_task_name, str):
+        raise TypeError('benchmark_task_name must be of type str')
+      self._benchmark_task_name = benchmark_task_name
+
+    @property
+    def benchmark_task_slug(self) -> str:
+      return self._benchmark_task_slug
+
+    @benchmark_task_slug.setter
+    def benchmark_task_slug(self, benchmark_task_slug: str):
+      if benchmark_task_slug is None:
+        del self.benchmark_task_slug
+        return
+      if not isinstance(benchmark_task_slug, str):
+        raise TypeError('benchmark_task_slug must be of type str')
+      self._benchmark_task_slug = benchmark_task_slug
+
+    @property
+    def task_version(self) -> int:
+      return self._task_version
+
+    @task_version.setter
+    def task_version(self, task_version: int):
+      if task_version is None:
+        del self.task_version
+        return
+      if not isinstance(task_version, int):
+        raise TypeError('task_version must be of type int')
+      self._task_version = task_version
+
+    @property
+    def result(self) -> Optional['BenchmarkResult']:
+      return self._result
+
+    @result.setter
+    def result(self, result: Optional['BenchmarkResult']):
+      if result is None:
+        del self.result
+        return
+      if not isinstance(result, BenchmarkResult):
+        raise TypeError('result must be of type BenchmarkResult')
+      self._result = result
+
+
+  def __init__(self):
+    self._rows = []
+    self._freeze()
+
+  @property
+  def rows(self) -> Optional[List[Optional['ApiBenchmarkLeaderboard.LeaderboardRow']]]:
+    return self._rows
+
+  @rows.setter
+  def rows(self, rows: Optional[List[Optional['ApiBenchmarkLeaderboard.LeaderboardRow']]]):
+    if rows is None:
+      del self.rows
+      return
+    if not isinstance(rows, list):
+      raise TypeError('rows must be of type list')
+    if not all([isinstance(t, ApiBenchmarkLeaderboard.LeaderboardRow) for t in rows]):
+      raise TypeError('rows must contain only items of type ApiBenchmarkLeaderboard.LeaderboardRow')
+    self._rows = rows
+
+
+class ApiGetBenchmarkLeaderboardRequest(KaggleObject):
+  r"""
+  Attributes:
+    owner_slug (str)
+    benchmark_slug (str)
+    version_number (int)
+  """
+
+  def __init__(self):
+    self._owner_slug = ""
+    self._benchmark_slug = ""
+    self._version_number = 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 benchmark_slug(self) -> str:
+    return self._benchmark_slug
+
+  @benchmark_slug.setter
+  def benchmark_slug(self, benchmark_slug: str):
+    if benchmark_slug is None:
+      del self.benchmark_slug
+      return
+    if not isinstance(benchmark_slug, str):
+      raise TypeError('benchmark_slug must be of type str')
+    self._benchmark_slug = benchmark_slug
+
+  @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
+
+  def endpoint(self):
+    if self.version_number:
+      path = '/api/v1/benchmarks/{owner_slug}/{benchmark_slug}/versions/{version_number}/leaderboard'
+    else:
+      path = '/api/v1/benchmarks/{owner_slug}/{benchmark_slug}/leaderboard'
+    return path.format_map(self.to_field_map(self))
+
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/benchmarks/{owner_slug}/{benchmark_slug}/leaderboard'
+
+
+ApiBenchmarkLeaderboard.LeaderboardRow._fields = [
+  FieldMetadata("modelVersionName", "model_version_name", "_model_version_name", str, "", PredefinedSerializer()),
+  FieldMetadata("modelVersionSlug", "model_version_slug", "_model_version_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("taskResults", "task_results", "_task_results", ApiBenchmarkLeaderboard.TaskResult, [], ListSerializer(KaggleObjectSerializer())),
+]
+
+ApiBenchmarkLeaderboard.TaskResult._fields = [
+  FieldMetadata("benchmarkTaskName", "benchmark_task_name", "_benchmark_task_name", str, "", PredefinedSerializer()),
+  FieldMetadata("benchmarkTaskSlug", "benchmark_task_slug", "_benchmark_task_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("taskVersion", "task_version", "_task_version", int, 0, PredefinedSerializer()),
+  FieldMetadata("result", "result", "_result", BenchmarkResult, None, KaggleObjectSerializer()),
+]
+
+ApiBenchmarkLeaderboard._fields = [
+  FieldMetadata("rows", "rows", "_rows", ApiBenchmarkLeaderboard.LeaderboardRow, [], ListSerializer(KaggleObjectSerializer())),
+]
+
+ApiGetBenchmarkLeaderboardRequest._fields = [
+  FieldMetadata("ownerSlug", "owner_slug", "_owner_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("benchmarkSlug", "benchmark_slug", "_benchmark_slug", str, "", PredefinedSerializer()),
+  FieldMetadata("versionNumber", "version_number", "_version_number", int, None, PredefinedSerializer(), optional=True),
+]
+

kagglesdk/blobs/services/blob_api_service.py

@@ -22,4 +22,4 @@ class BlobApiClient(object):
     if request is None:
       request = ApiStartBlobUploadRequest()
 
-    return self._client.call("blobs.BlobApiService", "ApiStartBlobUpload", request, ApiStartBlobUploadResponse)
+    return self._client.call("blobs.BlobApiService", "StartBlobUpload", request, ApiStartBlobUploadResponse)

kagglesdk/blobs/types/blob_api_service.py

@@ -65,7 +65,7 @@ class ApiStartBlobUploadRequest(KaggleObject):
     return self._content_type or ""
 
   @content_type.setter
-  def content_type(self, content_type: str):
+  def content_type(self, content_type: Optional[str]):
     if content_type is None:
       del self.content_type
       return
@@ -93,7 +93,7 @@ class ApiStartBlobUploadRequest(KaggleObject):
     return self._last_modified_epoch_seconds or 0
 
   @last_modified_epoch_seconds.setter
-  def last_modified_epoch_seconds(self, last_modified_epoch_seconds: int):
+  def last_modified_epoch_seconds(self, last_modified_epoch_seconds: Optional[int]):
     if last_modified_epoch_seconds is None:
       del self.last_modified_epoch_seconds
       return

kagglesdk/common/services/operations_service.py

@@ -0,0 +1,46 @@
+from kagglesdk.common.types.operations import Operation
+from kagglesdk.common.types.operations_service import GetOperationRequest
+from kagglesdk.kaggle_http_client import KaggleHttpClient
+
+class OperationsClient(object):
+  r"""
+  Manages long-running operations with an API service.
+
+  When an API method normally takes long time to complete, it can be designed
+  to return [Operation][google.longrunning.Operation] to the client, and the
+  client can use this interface to receive the real response asynchronously by
+  polling the operation resource, or pass the operation resource to another API
+  (such as Pub/Sub API) to receive the response.  Any API service that returns
+  long-running operations should implement the `Operations` interface so
+  developers can have a consistent client experience.
+  """
+
+  def __init__(self, client: KaggleHttpClient):
+    self._client = client
+
+  def get_operation(self, request: GetOperationRequest = None, name: str = None) -> Operation:
+    r"""
+    Gets the latest state of a long-running operation.  Clients can use this
+    method to poll the operation result at intervals as recommended by the API
+    service.
+
+    Args:
+      request (GetOperationRequest):
+        The request object; initialized to empty instance if not specified.
+        May not be specified if any of the flattened field params are specified.
+      name (str)
+        This corresponds to the ``name`` field on the ``request`` instance;
+        if ``request`` is provided, this should not be set.
+    """
+
+    has_flattened_args = any([name])
+    if request is not None and has_flattened_args:
+      raise ValueError('If the `request` argument is set, then none of '
+                       'the individual field arguments should be set.')
+
+    if request is None:
+      request = GetOperationRequest()
+      if name is not None:
+        request.name = name
+
+    return self._client.call("common.OperationsService", "GetOperation", request, Operation)

kagglesdk/common/types/file_download.py

@@ -80,7 +80,7 @@ class FileDownload(KaggleObject):
     return self._content_length or 0
 
   @content_length.setter
-  def content_length(self, content_length: int):
+  def content_length(self, content_length: Optional[int]):
     if content_length is None:
       del self.content_length
       return

kagglesdk/common/types/http_redirect.py

@@ -69,7 +69,7 @@ class HttpRedirect(KaggleObject):
     return self._bypass_encoding or False
 
   @bypass_encoding.setter
-  def bypass_encoding(self, bypass_encoding: bool):
+  def bypass_encoding(self, bypass_encoding: Optional[bool]):
     if bypass_encoding is None:
       del self.bypass_encoding
       return