Update proto and release 0.1.18

kagglesdk/__init__.py

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

kagglesdk/agents/types/agent_exam_service.py

@@ -1007,6 +1007,7 @@ class ApiGetAgentExamInsightsResponse(KaggleObject):
     pct_completed (float)
     score_distribution (ScoreDistributionBin)
     agents_submitted (int)
+    completed_submissions (int)
   """
 
   def __init__(self):
@@ -1015,6 +1016,7 @@ def __init__(self):
     self._pct_completed = 0.0
     self._score_distribution = []
     self._agents_submitted = 0
+    self._completed_submissions = 0
     self._freeze()
 
   @property
@@ -1084,6 +1086,19 @@ def agents_submitted(self, agents_submitted: int):
       raise TypeError('agents_submitted must be of type int')
     self._agents_submitted = agents_submitted
 
+  @property
+  def completed_submissions(self) -> int:
+    return self._completed_submissions
+
+  @completed_submissions.setter
+  def completed_submissions(self, completed_submissions: int):
+    if completed_submissions is None:
+      del self.completed_submissions
+      return
+    if not isinstance(completed_submissions, int):
+      raise TypeError('completed_submissions must be of type int')
+    self._completed_submissions = completed_submissions
+
   @property
   def agentsRegistered(self):
     return self.agents_registered
@@ -1104,6 +1119,10 @@ def scoreDistribution(self):
   def agentsSubmitted(self):
     return self.agents_submitted
 
+  @property
+  def completedSubmissions(self):
+    return self.completed_submissions
+
 
 class ApiGetAgentExamSubmissionRequest(KaggleObject):
   r"""
@@ -1501,6 +1520,7 @@ def count(self, count: int):
   FieldMetadata("pctCompleted", "pct_completed", "_pct_completed", float, 0.0, PredefinedSerializer()),
   FieldMetadata("scoreDistribution", "score_distribution", "_score_distribution", ScoreDistributionBin, [], ListSerializer(KaggleObjectSerializer())),
   FieldMetadata("agentsSubmitted", "agents_submitted", "_agents_submitted", int, 0, PredefinedSerializer()),
+  FieldMetadata("completedSubmissions", "completed_submissions", "_completed_submissions", int, 0, PredefinedSerializer()),
 ]
 
 ApiGetAgentExamSubmissionRequest._fields = [

kagglesdk/benchmarks/types/benchmark_tasks_api_service.py

@@ -577,29 +577,33 @@ def endpoint_path():
 class ApiListBenchmarkTaskRunsRequest(KaggleObject):
   r"""
   Attributes:
-    task_slugs (ApiBenchmarkTaskSlug)
+    task_slug (ApiBenchmarkTaskSlug)
     model_version_slugs (str)
+    page_size (int)
+    page_token (str)
+    skip (int)
   """
 
   def __init__(self):
-    self._task_slugs = []
+    self._task_slug = None
     self._model_version_slugs = []
+    self._page_size = 0
+    self._page_token = ""
+    self._skip = 0
     self._freeze()
 
   @property
-  def task_slugs(self) -> Optional[List[Optional['ApiBenchmarkTaskSlug']]]:
-    return self._task_slugs
+  def task_slug(self) -> Optional['ApiBenchmarkTaskSlug']:
+    return self._task_slug
 
-  @task_slugs.setter
-  def task_slugs(self, task_slugs: Optional[List[Optional['ApiBenchmarkTaskSlug']]]):
-    if task_slugs is None:
-      del self.task_slugs
+  @task_slug.setter
+  def task_slug(self, task_slug: Optional['ApiBenchmarkTaskSlug']):
+    if task_slug is None:
+      del self.task_slug
       return
-    if not isinstance(task_slugs, list):
-      raise TypeError('task_slugs must be of type list')
-    if not all([isinstance(t, ApiBenchmarkTaskSlug) for t in task_slugs]):
-      raise TypeError('task_slugs must contain only items of type ApiBenchmarkTaskSlug')
-    self._task_slugs = task_slugs
+    if not isinstance(task_slug, ApiBenchmarkTaskSlug):
+      raise TypeError('task_slug must be of type ApiBenchmarkTaskSlug')
+    self._task_slug = task_slug
 
   @property
   def model_version_slugs(self) -> Optional[List[str]]:
@@ -616,6 +620,45 @@ def model_version_slugs(self, model_version_slugs: Optional[List[str]]):
       raise TypeError('model_version_slugs must contain only items of type str')
     self._model_version_slugs = model_version_slugs
 
+  @property
+  def page_size(self) -> int:
+    return self._page_size
+
+  @page_size.setter
+  def page_size(self, page_size: int):
+    if page_size is None:
+      del self.page_size
+      return
+    if not isinstance(page_size, int):
+      raise TypeError('page_size must be of type int')
+    self._page_size = page_size
+
+  @property
+  def page_token(self) -> str:
+    return self._page_token
+
+  @page_token.setter
+  def page_token(self, page_token: str):
+    if page_token is None:
+      del self.page_token
+      return
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
+
+  @property
+  def skip(self) -> int:
+    return self._skip
+
+  @skip.setter
+  def skip(self, skip: int):
+    if skip is None:
+      del self.skip
+      return
+    if not isinstance(skip, int):
+      raise TypeError('skip must be of type int')
+    self._skip = skip
+
   def endpoint(self):
     path = '/api/v1/benchmarks/tasks/runs/list'
     return path.format_map(self.to_field_map(self))
@@ -625,10 +668,14 @@ class ApiListBenchmarkTaskRunsResponse(KaggleObject):
   r"""
   Attributes:
     runs (ApiBenchmarkTaskRun)
+    total_results (int)
+    next_page_token (str)
   """
 
   def __init__(self):
     self._runs = []
+    self._total_results = 0
+    self._next_page_token = ""
     self._freeze()
 
   @property
@@ -646,6 +693,40 @@ def runs(self, runs: Optional[List[Optional['ApiBenchmarkTaskRun']]]):
       raise TypeError('runs must contain only items of type ApiBenchmarkTaskRun')
     self._runs = runs
 
+  @property
+  def total_results(self) -> int:
+    return self._total_results
+
+  @total_results.setter
+  def total_results(self, total_results: int):
+    if total_results is None:
+      del self.total_results
+      return
+    if not isinstance(total_results, int):
+      raise TypeError('total_results must be of type int')
+    self._total_results = total_results
+
+  @property
+  def next_page_token(self) -> str:
+    return self._next_page_token
+
+  @next_page_token.setter
+  def next_page_token(self, next_page_token: str):
+    if next_page_token is None:
+      del self.next_page_token
+      return
+    if not isinstance(next_page_token, str):
+      raise TypeError('next_page_token must be of type str')
+    self._next_page_token = next_page_token
+
+  @property
+  def totalResults(self):
+    return self.total_results
+
+  @property
+  def nextPageToken(self):
+    return self.next_page_token
+
 
 class ApiListBenchmarkTasksRequest(KaggleObject):
   r"""
@@ -774,12 +855,17 @@ def tasks(self, tasks: Optional[List[Optional['ApiBenchmarkTask']]]):
 ]
 
 ApiListBenchmarkTaskRunsRequest._fields = [
-  FieldMetadata("taskSlugs", "task_slugs", "_task_slugs", ApiBenchmarkTaskSlug, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("taskSlug", "task_slug", "_task_slug", ApiBenchmarkTaskSlug, None, KaggleObjectSerializer()),
   FieldMetadata("modelVersionSlugs", "model_version_slugs", "_model_version_slugs", str, [], ListSerializer(PredefinedSerializer())),
+  FieldMetadata("pageSize", "page_size", "_page_size", int, 0, PredefinedSerializer()),
+  FieldMetadata("pageToken", "page_token", "_page_token", str, "", PredefinedSerializer()),
+  FieldMetadata("skip", "skip", "_skip", int, 0, PredefinedSerializer()),
 ]
 
 ApiListBenchmarkTaskRunsResponse._fields = [
   FieldMetadata("runs", "runs", "_runs", ApiBenchmarkTaskRun, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("totalResults", "total_results", "_total_results", int, 0, PredefinedSerializer()),
+  FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()),
 ]
 
 ApiListBenchmarkTasksRequest._fields = [