feat(cli): add competitions data push command

Wrap kagglesdk 0.1.32's new create_competition_data RPC behind
`kaggle competitions data push <competition> -p folder -m "notes"
[--rerun] [-r {skip,zip,tar}]`. Walks the folder, uploads each file
via the existing ResumableUploadContext + blob plumbing (using
ApiBlobType.INBOX — see TODO; may need adjustment based on backend
feedback), then sends a single CreateCompetitionData request
bundling the resulting tokens. Each push replaces the prior
version's file set in full.

Bumps the kagglesdk floor to 0.1.32.

Author: bovard

docs/competition_creation.md

@@ -7,8 +7,9 @@ public competition-creation API endpoints (kagglesdk 0.1.31+):
 - [`kaggle competitions create`](#kaggle-competitions-create)
 - [`kaggle competitions pages create`](#kaggle-competitions-pages-create)
 - [`kaggle competitions launch`](#kaggle-competitions-launch)
+- [`kaggle competitions data push`](#kaggle-competitions-data-push)
 
-All four commands require an authenticated session
+All of these commands require an authenticated session
 (`kaggle config set username/password` or an API token).
 
 A typical end-to-end host workflow looks like:
@@ -27,11 +28,14 @@ kaggle competitions create -p ./my-comp
 kaggle competitions pages create my-comp-slug --name description -f ./description.md --publish
 kaggle competitions pages create my-comp-slug --name rules -f ./rules.md --publish
 
-# 5. Launch the competition (now, or schedule a future UTC time).
+# 5. Push the competition data (train.csv, test.csv, sample_submission.csv, ...).
+kaggle competitions data push my-comp-slug -p ./data -m "Initial release"
+
+# 6. Launch the competition (now, or schedule a future UTC time).
 kaggle competitions launch my-comp-slug --at 2027-01-01T00:00:00Z
 ```
 
-The four commands are independent — for example, you can call `pages create`
+These commands are independent — for example, you can call `pages create`
 on a competition that already exists, or use `launch` on a competition created
 via the host wizard.
 
@@ -245,3 +249,54 @@ kaggle competitions launch my-comp --at 2027-01-01T00:00:00Z
 
 A competition can only be launched once. Subsequent calls will be rejected by
 the backend.
+
+---
+
+## `kaggle competitions data push`
+
+Pushes (versions) the data files for a competition you host. Walks the
+supplied folder, uploads each file via the standard blob-upload pipeline, and
+then sends a single request bundling the uploaded tokens. Each push **replaces
+the prior version's file set in full** — there is no per-file "keep from
+previous" mode in v1, so list every file you want in the new version.
+
+**Usage:**
+
+```bash
+kaggle competitions data push <competition> -p <folder> -m "<version notes>" \
+    [--rerun] [-r {skip,zip,tar}]
+```
+
+**Arguments:**
+
+- `<competition>`: The competition slug.
+
+**Options:**
+
+- `-p, --path <folder>` (required): Folder containing the files to push.
+- `-m, --message "<notes>"` (required): Notes describing this version
+  (e.g. `"Added test set"`).
+- `--rerun` (optional): Push to the RERUN databundle — the private host-only
+  data swapped in during rerun scoring. Requires the
+  `CompetitionPrivateDatabundle` feature flag server-side. Without this flag,
+  the push targets the PUBLIC databundle (what participants download).
+- `-r, --dir-mode {skip,zip,tar}` (optional): How to handle sub-directories.
+  `skip` (default) ignores them; `zip` / `tar` archives each subfolder into a
+  single upload.
+
+**Examples:**
+
+```bash
+# Push the initial public data.
+kaggle competitions data push my-comp -p ./data -m "Initial release"
+
+# New version with a bug-fix.
+kaggle competitions data push my-comp -p ./data -m "Fix label encoding in train.csv"
+
+# Push private rerun-scoring data (requires feature flag).
+kaggle competitions data push my-comp -p ./rerun-data \
+    -m "Held-out test set" --rerun
+```
+
+The command prints the public URL plus the new `databundle_id` and
+`databundle_version_id` on success.

pyproject.toml

@@ -24,7 +24,7 @@ keywords = ["Kaggle", "API"]
 requires-python = ">= 3.11"
 dependencies = [
     "bleach",
-    "kagglesdk >= 0.1.31, < 1.0", # sync with kagglehub
+    "kagglesdk >= 0.1.32, < 1.0", # sync with kagglehub
     "python-slugify",
     "requests",
     "python-dateutil",

src/kaggle/api/kaggle_api_extended.py

@@ -99,6 +99,9 @@
     ApiListCompetitionPagesRequest,
     ApiListCompetitionPagesResponse,
     ApiCreateCompetitionPageRequest,
+    ApiCreateCompetitionDataRequest,
+    ApiCreateCompetitionDataResponse,
+    ApiCompetitionDataFile,
     ApiCompetitionPage,
     ApiCreateCompetitionRequest,
     ApiCreateCompetitionResponse,
@@ -133,6 +136,7 @@
 )
 from kagglesdk.competitions.types.competition_enums import (
     CompetitionListTab,
+    CompetitionDatabundleType,
     CompetitionPrivacy,
     HostSegment,
     CompetitionSortBy,
@@ -2430,6 +2434,101 @@ def competition_create_page_cli(
         status = "published" if page.is_published else "staged (unpublished)"
         print(f'Page "{page.name}" created on competition "{competition_name}" — {status}.')
 
+    def competition_data_push(
+        self,
+        competition_name: str,
+        folder: str,
+        version_notes: str,
+        rerun: bool = False,
+        quiet: bool = False,
+        dir_mode: str = "skip",
+    ) -> ApiCreateCompetitionDataResponse:
+        """Push (version) the data files for a competition you host.
+
+        Walks ``folder``, uploads each file via the blob-upload pipeline, and
+        sends a CreateCompetitionData request bundling the resulting tokens.
+        Each push replaces the prior version's file set in full.
+
+        Args:
+            competition_name (str): The competition name (slug).
+            folder (str): Folder containing the files to push.
+            version_notes (str): Notes describing this version (required).
+            rerun (bool): If True, push to the RERUN databundle (private
+                host-only data swapped in during rerun scoring). Requires the
+                CompetitionPrivateDatabundle feature flag server-side.
+            quiet (bool): Suppress per-file upload progress lines.
+            dir_mode (str): What to do with sub-directories: "skip" (default),
+                "zip", or "tar".
+
+        Returns:
+            ApiCreateCompetitionDataResponse: url, databundle_id,
+            databundle_version_id of the new version.
+        """
+        if not os.path.isdir(folder):
+            raise ValueError("Invalid folder: " + folder)
+        if not version_notes or not version_notes.strip():
+            raise ValueError("--message/-m version notes are required")
+
+        files: List[ApiCompetitionDataFile] = []
+        # TODO: confirm with backend whether competition data should use
+        # ApiBlobType.INBOX (used here as the closest catch-all) or whether a
+        # dedicated COMPETITION_DATA blob type needs adding.
+        with ResumableUploadContext() as upload_context:
+            for file_name in sorted(os.listdir(folder)):
+                upload_file = self._upload_file_or_folder(
+                    folder, file_name, ApiBlobType.INBOX, upload_context, dir_mode, quiet
+                )
+                if upload_file is not None:
+                    f = ApiCompetitionDataFile()
+                    f.name = upload_file.name
+                    f.token = upload_file.token
+                    files.append(f)
+
+        if not files:
+            raise ValueError(f"No files found in {folder} to upload")
+
+        with self.build_kaggle_client() as kaggle:
+            request = ApiCreateCompetitionDataRequest()
+            request.competition_name = competition_name
+            request.version_notes = version_notes
+            request.files = files
+            if rerun:
+                request.competition_databundle_type = CompetitionDatabundleType.COMPETITION_DATABUNDLE_TYPE_RERUN
+            return kaggle.competitions.competition_api_client.create_competition_data(request)
+
+    def competition_data_push_cli(
+        self,
+        competition=None,
+        competition_opt=None,
+        folder=None,
+        version_notes=None,
+        rerun=False,
+        quiet=False,
+        dir_mode="skip",
+    ):
+        """CLI wrapper for competition_data_push."""
+        competition_name = competition or competition_opt
+        if competition_name is None:
+            competition_name = self.get_config_value(self.CONFIG_NAME_COMPETITION)
+            if competition_name is not None and not quiet:
+                print("Using competition: " + competition_name)
+        if competition_name is None:
+            raise ValueError("No competition specified")
+        if not folder:
+            raise ValueError("-p/--path folder is required")
+        if not version_notes:
+            raise ValueError("-m/--message version notes are required")
+
+        response = self.competition_data_push(
+            competition_name=competition_name,
+            folder=folder,
+            version_notes=version_notes,
+            rerun=rerun,
+            quiet=quiet,
+            dir_mode=dir_mode,
+        )
+        print(f'New data version pushed for "{competition_name}": {response.url}')
+
     def competition_launch(self, competition_name: str, future_time: Optional[datetime] = None) -> None:
         """Launch a competition you host, optionally at a future UTC time.
 

src/kaggle/cli.py

@@ -467,6 +467,63 @@ def parse_competitions(subparsers) -> None:
     parser_competitions_pages_create._action_groups.append(parser_competitions_pages_create_optional)
     parser_competitions_pages_create.set_defaults(func=api.competition_create_page_cli)
 
+    # Competitions data (group: push)
+    parser_competitions_data = subparsers_competitions.add_parser(
+        "data",
+        formatter_class=argparse.RawTextHelpFormatter,
+        help=Help.command_competitions_data,
+    )
+    subparsers_competitions_data = parser_competitions_data.add_subparsers(title="commands", dest="command")
+    subparsers_competitions_data.required = True
+    subparsers_competitions_data.choices = Help.entity_data_choices
+
+    # Competitions data push
+    parser_competitions_data_push = subparsers_competitions_data.add_parser(
+        "push",
+        formatter_class=argparse.RawTextHelpFormatter,
+        help=Help.command_competitions_data_push,
+    )
+    parser_competitions_data_push_optional = parser_competitions_data_push._action_groups.pop()
+    parser_competitions_data_push_optional.add_argument(
+        "competition", nargs="?", default=None, help=Help.param_competition
+    )
+    parser_competitions_data_push_optional.add_argument(
+        "-c", "--competition", dest="competition_opt", required=False, help=argparse.SUPPRESS
+    )
+    parser_competitions_data_push_optional.add_argument(
+        "-p",
+        "--path",
+        dest="folder",
+        required=True,
+        help="Folder containing the files to push.",
+    )
+    parser_competitions_data_push_optional.add_argument(
+        "-m",
+        "--message",
+        dest="version_notes",
+        required=True,
+        help='Notes describing this version (e.g. "Added test set").',
+    )
+    parser_competitions_data_push_optional.add_argument(
+        "--rerun",
+        dest="rerun",
+        action="store_true",
+        help="Push to the RERUN databundle (private host-only data used during rerun scoring).",
+    )
+    parser_competitions_data_push_optional.add_argument(
+        "-r",
+        "--dir-mode",
+        dest="dir_mode",
+        choices=["skip", "zip", "tar"],
+        default="skip",
+        help='How to handle sub-directories: "skip" (default), "zip", or "tar".',
+    )
+    parser_competitions_data_push_optional.add_argument(
+        "-q", "--quiet", dest="quiet", action="store_true", help=Help.param_quiet
+    )
+    parser_competitions_data_push._action_groups.append(parser_competitions_data_push_optional)
+    parser_competitions_data_push.set_defaults(func=api.competition_data_push_cli)
+
     # Competitions launch (publish now, or schedule for a future UTC time)
     parser_competitions_launch = subparsers_competitions.add_parser(
         "launch", formatter_class=argparse.RawTextHelpFormatter, help=Help.command_competitions_launch
@@ -2026,6 +2083,7 @@ class Help(object):
         "replay",
         "logs",
         "pages",
+        "data",
         "launch",
         "init",
         "create",
@@ -2091,6 +2149,7 @@ class Help(object):
     forums_topics_choices = ["list", "show"]
     entity_topics_choices = ["list", "show"]
     entity_pages_choices = ["list", "create"]
+    entity_data_choices = ["push"]
     config_choices = ["view", "set", "unset"]
     auth_choices = ["login", "print-access-token", "revoke"]
 
@@ -2164,6 +2223,8 @@ class Help(object):
     command_competitions_episode_logs = "Download agent logs for a simulation episode"
     command_competitions_pages = "List pages for a competition"
     command_competitions_pages_create = "Create a new page on a competition you host"
+    command_competitions_data = "Manage a competition's data files"
+    command_competitions_data_push = "Push (version) the data files for a competition you host"
     command_competitions_launch = "Launch a competition you host, optionally at a future UTC time"
     command_competitions_init = "Initialize folder with a competition-metadata.json template"
     command_competitions_create = "Create a new competition from competition-metadata.json"