Full kagglesdk regen and release 0.1.33

kagglesdk/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.32"
+__version__ = "0.1.33"
 
 from kagglesdk.kaggle_client import KaggleClient
 from kagglesdk.kaggle_creds import KaggleCredentials

kagglesdk/benchmarks/types/benchmark_enums.py

@@ -38,8 +38,9 @@ class BenchmarkTaskVersionSource(enum.Enum):
   """Created by the LIH 'Benchmark Sandbox: Discover What Works' flow."""
   WEB = 2
   r"""
-  Created via the kaggle.com web client (e.g. CreateBenchmarkTaskFromPrompt
-  or saving a benchmark task from a kernel session).
+  Created via a kaggle.com web RPC (e.g. CreateBenchmarkTaskFromPrompt,
+  CreateBenchmarkTaskFromDockerImage, or saving a benchmark task from a
+  kernel session).
   """
   CLI = 3
   """Created via the Kaggle CLI / public BenchmarkTasksApi handler."""

kagglesdk/benchmarks/types/benchmark_task_run_service.py

@@ -16,13 +16,18 @@ class BatchScheduleBenchmarkModelVersionResult(KaggleObject):
     benchmark_task_version_id (int)
       One of the values provided in
       BatchScheduleBenchmarkTaskRunsRequest.benchmark_task_versions
+    parent_task_version_id (int)
+      When the requested benchmark_task_version_id is a child of another task
+      version, scheduling is redirected to the parent and this field reports the
+      parent's id. Unset when the requested task version was executed directly.
   """
 
   def __init__(self):
     self._benchmark_model_version_id = 0
     self._run_scheduled = False
     self._run_skipped_reason = None
     self._benchmark_task_version_id = 0
+    self._parent_task_version_id = None
     self._freeze()
 
   @property
@@ -93,11 +98,30 @@ def run_skipped_reason(self, run_skipped_reason: Optional[str]):
       raise TypeError('run_skipped_reason must be of type str')
     self._run_skipped_reason = run_skipped_reason
 
+  @property
+  def parent_task_version_id(self) -> int:
+    r"""
+    When the requested benchmark_task_version_id is a child of another task
+    version, scheduling is redirected to the parent and this field reports the
+    parent's id. Unset when the requested task version was executed directly.
+    """
+    return self._parent_task_version_id or 0
+
+  @parent_task_version_id.setter
+  def parent_task_version_id(self, parent_task_version_id: Optional[int]):
+    if parent_task_version_id is None:
+      del self.parent_task_version_id
+      return
+    if not isinstance(parent_task_version_id, int):
+      raise TypeError('parent_task_version_id must be of type int')
+    self._parent_task_version_id = parent_task_version_id
+
 
 BatchScheduleBenchmarkModelVersionResult._fields = [
   FieldMetadata("benchmarkModelVersionId", "benchmark_model_version_id", "_benchmark_model_version_id", int, 0, PredefinedSerializer()),
   FieldMetadata("runScheduled", "run_scheduled", "_run_scheduled", bool, False, PredefinedSerializer()),
   FieldMetadata("runSkippedReason", "run_skipped_reason", "_run_skipped_reason", str, None, PredefinedSerializer(), optional=True),
   FieldMetadata("benchmarkTaskVersionId", "benchmark_task_version_id", "_benchmark_task_version_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("parentTaskVersionId", "parent_task_version_id", "_parent_task_version_id", int, None, PredefinedSerializer(), optional=True),
 ]
 

kagglesdk/benchmarks/types/benchmark_task_service.py

@@ -0,0 +1,138 @@
+from kagglesdk.kaggle_object import *
+
+class EnvVariable(KaggleObject):
+  r"""
+  Environment variable on a DOCKER_IMAGE BenchmarkTask's container.
+
+    - `key`: variable name (e.g. `API_BASE_URL`).
+    - `value`: literal value, OR (when `is_secret_name` is true) the name
+      of a UserSecret on the caller's account.
+    - `is_secret_name`: when true, the system resolves `value` against the
+      caller's UserSecrets at runtime and injects the resolved secret.
+
+  Attributes:
+    key (str)
+    value (str)
+    is_secret_name (bool)
+  """
+
+  def __init__(self):
+    self._key = ""
+    self._value = ""
+    self._is_secret_name = False
+    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
+
+  @property
+  def is_secret_name(self) -> bool:
+    return self._is_secret_name
+
+  @is_secret_name.setter
+  def is_secret_name(self, is_secret_name: bool):
+    if is_secret_name is None:
+      del self.is_secret_name
+      return
+    if not isinstance(is_secret_name, bool):
+      raise TypeError('is_secret_name must be of type bool')
+    self._is_secret_name = is_secret_name
+
+
+class UserSecret(KaggleObject):
+  r"""
+  UserSecret to create/update on the caller's account before running a
+  DOCKER_IMAGE BenchmarkTask.
+
+    - `name`: secret label (matched against existing UserSecrets by Label).
+    - `value`: plaintext secret value.
+    - `override_existing`: when true, replace any existing secret with the
+      same name. When false, fail with AlreadyExists on a name collision.
+
+  Attributes:
+    name (str)
+    value (str)
+    override_existing (bool)
+  """
+
+  def __init__(self):
+    self._name = ""
+    self._value = ""
+    self._override_existing = False
+    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 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
+
+  @property
+  def override_existing(self) -> bool:
+    return self._override_existing
+
+  @override_existing.setter
+  def override_existing(self, override_existing: bool):
+    if override_existing is None:
+      del self.override_existing
+      return
+    if not isinstance(override_existing, bool):
+      raise TypeError('override_existing must be of type bool')
+    self._override_existing = override_existing
+
+
+EnvVariable._fields = [
+  FieldMetadata("key", "key", "_key", str, "", PredefinedSerializer()),
+  FieldMetadata("value", "value", "_value", str, "", PredefinedSerializer()),
+  FieldMetadata("isSecretName", "is_secret_name", "_is_secret_name", bool, False, PredefinedSerializer()),
+]
+
+UserSecret._fields = [
+  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
+  FieldMetadata("value", "value", "_value", str, "", PredefinedSerializer()),
+  FieldMetadata("overrideExisting", "override_existing", "_override_existing", bool, False, PredefinedSerializer()),
+]
+