Update new code to match new endpoint after its code review (#706)

I *still* need to add a new test for the new API method.

Reminder: `kagglesdk` is generated.

Author: stevemessick

CHANGELOG.md

@@ -1,5 +1,10 @@
 Changelog
 ====
+### 1.7.3b2
+
+* Added the ability to submit to a code competition. Some required arguments have been made optional.
+* Added a `--timeout` option to `kaggle kernels push` to limit the run-time to the specified number of seconds.
+
 ### 1.7.3b1
 
 * Fix escaped-quote issue in HTTP requests.

kaggle/api/kaggle_api_extended.py

@@ -794,41 +794,47 @@ def competitions_list_cli(self,
     else:
       print('No competitions found')
 
-  def competition_submit_code(self, file_name, message, competition, kernel_slug=None, kernel_version=None, quiet=False):
-    """ Submit a competition.
+  def competition_submit_code(self, file_name, message, competition, kernel=None, kernel_version=None, quiet=False):
+    """ Submit to a code competition.
 
             Parameters
             ==========
-            file_name: the name of  the output file created by the kernel
+            file_name: the name of  the output file created by the kernel (not used for packages)
             message: the submission description
             competition: the competition name; if not given use the 'competition' config value
-            kernel_slug: the <owner>/<notebook> of the notebook to use for a code competition
+            kernel: the <owner>/<notebook> of the notebook to use for a code competition
             kernel_version: the version number, returned by 'kaggle kernels push ...'
             quiet: suppress verbose output (default is False)
         """
     if competition is None:
       competition = self.get_config_value(self.CONFIG_NAME_COMPETITION)
       if competition is not None and not quiet:
         print('Using competition: ' + competition)
-
     if competition is None:
       raise ValueError('No competition specified')
+
+    if kernel is None:
+      raise ValueError('No kernel specified')
     else:
-      if kernel_version is None:
-        raise ValueError('Kernel version must be specified')
       with self.build_kaggle_client() as kaggle:
+        items = kernel.split('/')
+        if len(items) != 2:
+          raise ValueError('The kernel must be specified as <owner>/<notebook>')
         submit_request = ApiCreateCodeSubmissionRequest()
         submit_request.file_name = file_name
         submit_request.competition_name = competition
-        submit_request.kernel_slug = kernel_slug
-        submit_request.kernel_version = kernel_version
-        submit_request.submission_description = message
+        submit_request._kernel_owner = items[0]
+        submit_request.kernel_slug = items[1]
+        if kernel_version:
+          submit_request.kernel_version = int(kernel_version)
+        if message:
+          submit_request.submission_description = message
         submit_response = kaggle.competitions.competition_api_client.create_code_submission(
             submit_request)
         return submit_response
 
   def competition_submit(self, file_name, message, competition, quiet=False):
-    """ Submit a competition.
+    """ Submit to a competition.
 
             Parameters
             ==========
@@ -845,6 +851,8 @@ def competition_submit(self, file_name, message, competition, quiet=False):
     if competition is None:
       raise ValueError('No competition specified')
     else:
+      if file_name is None:
+        raise ValueError('No file specified')
       with self.build_kaggle_client() as kaggle:
         request = ApiStartSubmissionUploadRequest()
         request.competition_name = competition
@@ -863,15 +871,16 @@ def competition_submit(self, file_name, message, competition, quiet=False):
         submit_request = ApiCreateSubmissionRequest()
         submit_request.competition_name = competition
         submit_request.blob_file_tokens = response.token
-        submit_request.submission_description = message
+        if message:
+          submit_request.submission_description = message
         submit_response = kaggle.competitions.competition_api_client.create_submission(
             submit_request)
         return submit_response
 
   def competition_submit_cli(self,
-                             file_name,
-                             message,
-                             competition,
+                             file_name=None,
+                             message=None,
+                             competition=None,
                              kernel=None,
                              version=None,
                              competition_opt=None,

kaggle/cli.py

@@ -234,8 +234,6 @@ def parse_competitions(subparsers):
       help=Help.command_competitions_submit)
   parser_competitions_submit_optional = parser_competitions_submit._action_groups.pop(
   )
-  parser_competitions_submit_required = parser_competitions_submit.add_argument_group(
-      'required arguments')
   parser_competitions_submit_optional.add_argument(
       'competition', nargs='?', default=None, help=Help.param_competition)
   parser_competitions_submit_optional.add_argument(
@@ -244,11 +242,11 @@ def parse_competitions(subparsers):
       dest='competition_opt',
       required=False,
       help=argparse.SUPPRESS)
-  parser_competitions_submit_required.add_argument(
+  parser_competitions_submit_optional.add_argument(
       '-f', '--file', dest='file_name', help=Help.param_upfile)
   parser_competitions_submit_optional.add_argument(
       '-k', '--kernel', dest='kernel', help=Help.param_code_kernel)
-  parser_competitions_submit_required.add_argument(
+  parser_competitions_submit_optional.add_argument(
       '-m',
       '--message',
       dest='message',

kagglesdk/competitions/services/competition_api_service.py

@@ -1,6 +1,6 @@
 from kagglesdk.common.types.file_download import FileDownload
 from kagglesdk.common.types.http_redirect import HttpRedirect
-from kagglesdk.competitions.types.competition_api_service import ApiCreateCodeSubmissionRequest, ApiCreateSubmissionRequest, ApiCreateSubmissionResponse, ApiDownloadDataFileRequest, ApiDownloadDataFilesRequest, ApiDownloadLeaderboardRequest, ApiGetLeaderboardRequest, ApiGetLeaderboardResponse, ApiGetSubmissionRequest, ApiListCompetitionsRequest, ApiListCompetitionsResponse, ApiListDataFilesRequest, ApiListDataFilesResponse, ApiListSubmissionsRequest, ApiListSubmissionsResponse, ApiStartSubmissionUploadRequest, ApiStartSubmissionUploadResponse, ApiSubmission
+from kagglesdk.competitions.types.competition_api_service import ApiCreateCodeSubmissionRequest, ApiCreateCodeSubmissionResponse, ApiCreateSubmissionRequest, ApiCreateSubmissionResponse, ApiDownloadDataFileRequest, ApiDownloadDataFilesRequest, ApiDownloadLeaderboardRequest, ApiGetLeaderboardRequest, ApiGetLeaderboardResponse, ApiGetSubmissionRequest, ApiListCompetitionsRequest, ApiListCompetitionsResponse, ApiListDataFilesRequest, ApiListDataFilesResponse, ApiListSubmissionsRequest, ApiListSubmissionsResponse, ApiStartSubmissionUploadRequest, ApiStartSubmissionUploadResponse, ApiSubmission
 from kagglesdk.kaggle_http_client import KaggleHttpClient
 
 class CompetitionApiClient(object):
@@ -80,7 +80,7 @@ def create_submission(self, request: ApiCreateSubmissionRequest = None) -> ApiCr
 
     return self._client.call("competitions.CompetitionApiService", "ApiCreateSubmission", request, ApiCreateSubmissionResponse)
 
-  def create_code_submission(self, request: ApiCreateCodeSubmissionRequest = None) -> ApiCreateSubmissionResponse:
+  def create_code_submission(self, request: ApiCreateCodeSubmissionRequest = None) -> ApiCreateCodeSubmissionResponse:
     r"""
     Args:
       request (ApiCreateCodeSubmissionRequest):
@@ -90,7 +90,7 @@ def create_code_submission(self, request: ApiCreateCodeSubmissionRequest = None)
     if request is None:
       request = ApiCreateCodeSubmissionRequest()
 
-    return self._client.call("competitions.CompetitionApiService", "ApiCreateCodeSubmission", request, ApiCreateSubmissionResponse)
+    return self._client.call("competitions.CompetitionApiService", "ApiCreateCodeSubmission", request, ApiCreateCodeSubmissionResponse)
 
   def get_submission(self, request: ApiGetSubmissionRequest = None) -> ApiSubmission:
     r"""

kagglesdk/competitions/types/competition_api_service.py

@@ -8,17 +8,19 @@ class ApiCreateCodeSubmissionRequest(KaggleObject):
   r"""
   Attributes:
     competition_name (str)
+    kernel_owner (str)
     kernel_slug (str)
-    kernel_version (str)
+    kernel_version (int)
     file_name (str)
     submission_description (str)
   """
 
   def __init__(self):
     self._competition_name = ""
+    self._kernel_owner = ""
     self._kernel_slug = ""
-    self._kernel_version = ""
-    self._file_name = ""
+    self._kernel_version = None
+    self._file_name = None
     self._submission_description = None
     self._freeze()
 
@@ -35,6 +37,19 @@ def competition_name(self, competition_name: str):
       raise TypeError('competition_name must be of type str')
     self._competition_name = competition_name
 
+  @property
+  def kernel_owner(self) -> str:
+    return self._kernel_owner
+
+  @kernel_owner.setter
+  def kernel_owner(self, kernel_owner: str):
+    if kernel_owner is None:
+      del self.kernel_owner
+      return
+    if not isinstance(kernel_owner, str):
+      raise TypeError('kernel_owner must be of type str')
+    self._kernel_owner = kernel_owner
+
   @property
   def kernel_slug(self) -> str:
     return self._kernel_slug
@@ -49,21 +64,21 @@ def kernel_slug(self, kernel_slug: str):
     self._kernel_slug = kernel_slug
 
   @property
-  def kernel_version(self) -> str:
-    return self._kernel_version
+  def kernel_version(self) -> int:
+    return self._kernel_version or 0
 
   @kernel_version.setter
-  def kernel_version(self, kernel_version: str):
+  def kernel_version(self, kernel_version: int):
     if kernel_version is None:
       del self.kernel_version
       return
-    if not isinstance(kernel_version, str):
-      raise TypeError('kernel_version must be of type str')
+    if not isinstance(kernel_version, int):
+      raise TypeError('kernel_version must be of type int')
     self._kernel_version = kernel_version
 
   @property
   def file_name(self) -> str:
-    return self._file_name
+    return self._file_name or ""
 
   @file_name.setter
   def file_name(self, file_name: str):
@@ -97,6 +112,45 @@ def method():
     return 'POST'
 
 
+class ApiCreateCodeSubmissionResponse(KaggleObject):
+  r"""
+  Attributes:
+    message (str)
+    ref (int)
+  """
+
+  def __init__(self):
+    self._message = ""
+    self._ref = 0
+    self._freeze()
+
+  @property
+  def message(self) -> str:
+    return self._message
+
+  @message.setter
+  def message(self, message: str):
+    if message is None:
+      del self.message
+      return
+    if not isinstance(message, str):
+      raise TypeError('message must be of type str')
+    self._message = message
+
+  @property
+  def ref(self) -> int:
+    return self._ref
+
+  @ref.setter
+  def ref(self, ref: int):
+    if ref is None:
+      del self.ref
+      return
+    if not isinstance(ref, int):
+      raise TypeError('ref must be of type int')
+    self._ref = ref
+
+
 class ApiCreateSubmissionRequest(KaggleObject):
   r"""
   Attributes:
@@ -170,8 +224,6 @@ class ApiCreateSubmissionResponse(KaggleObject):
   r"""
   Attributes:
     message (str)
-      TODO: Remove when we feel okay with the breaking change, this adds no
-      value.
     ref (int)
   """
 
@@ -182,10 +234,6 @@ def __init__(self):
 
   @property
   def message(self) -> str:
-    r"""
-    TODO: Remove when we feel okay with the breaking change, this adds no
-    value.
-    """
     return self._message
 
   @message.setter
@@ -1814,12 +1862,18 @@ def total_count(self, total_count: int):
 
 ApiCreateCodeSubmissionRequest._fields = [
   FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()),
+  FieldMetadata("kernelOwner", "kernel_owner", "_kernel_owner", str, "", PredefinedSerializer()),
   FieldMetadata("kernelSlug", "kernel_slug", "_kernel_slug", str, "", PredefinedSerializer()),
-  FieldMetadata("kernelVersion", "kernel_version", "_kernel_version", str, "", PredefinedSerializer()),
-  FieldMetadata("fileName", "file_name", "_file_name", str, "", PredefinedSerializer()),
+  FieldMetadata("kernelVersion", "kernel_version", "_kernel_version", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("fileName", "file_name", "_file_name", str, None, PredefinedSerializer(), optional=True),
   FieldMetadata("submissionDescription", "submission_description", "_submission_description", str, None, PredefinedSerializer(), optional=True),
 ]
 
+ApiCreateCodeSubmissionResponse._fields = [
+  FieldMetadata("message", "message", "_message", str, "", PredefinedSerializer()),
+  FieldMetadata("ref", "ref", "_ref", int, 0, PredefinedSerializer()),
+]
+
 ApiCreateSubmissionRequest._fields = [
   FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()),
   FieldMetadata("blobFileTokens", "blob_file_tokens", "_blob_file_tokens", str, "", PredefinedSerializer()),