Bump kagglesdk floor and inline shipped hackathon APIs

Per review: the right fix for "kagglesdk doesn't have these yet" is to
bump the floor, not work around it. Bumped to >= 0.1.23 (latest) and
dropped the lazy-import + getattr plumbing for the two endpoints that
ship there, so `hackathon_get_overview` and `hackathon_list_writeups`
now use top-of-file imports and the tests stub the SDK client directly
instead of mocking helper indirection.

The CSV-export and resolve-links endpoints still aren't in any released
kagglesdk, so those wrappers keep a small lazy import (with a TODO) and
the test fixture stubs those two modules in `sys.modules`.

Co-authored-by: kaggle-agent <kaggle-agent@users.noreply.github.com>

Author: paultimothymooney

pyproject.toml

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

src/kaggle/api/kaggle_api_extended.py

@@ -97,6 +97,8 @@
     ApiListCompetitionTopicsResponse,
     ApiListTopicMessagesRequest,
     ApiListTopicMessagesResponse,
+    ApiGetHackathonOverviewRequest,
+    ApiListHackathonWriteUpsRequest,
 )
 from kagglesdk.discussions.types.discussions_api_service import (
     ApiDiscussionComment,
@@ -2652,81 +2654,17 @@ def entity_topic_show_cli(
     hackathon_overview_page_fields = ["name"]
     hackathon_writeup_link_fields = ["url", "type", "title"]
 
-    def _require_sdk_method(self, client, method_name: str, hint: str):
-        """Return ``client.method_name`` or raise a clear error.
-
-        The hackathon endpoints landed in kagglesdk after this CLI release
-        was cut, so older SDK installs may not have them yet.
-        """
-        method = getattr(client, method_name, None)
-        if method is None:
-            raise ValueError(
-                f"This command requires a newer kagglesdk that exposes " f"`{hint}`. Please upgrade kagglesdk."
-            )
-        return method
-
-    def _build_hackathon_overview_request(self, competition: str):
-        try:
-            from kagglesdk.competitions.types.competition_api_service import (  # type: ignore
-                ApiGetHackathonOverviewRequest,
-            )
-        except ImportError as exc:
-            raise ValueError("kagglesdk is missing ApiGetHackathonOverviewRequest; please upgrade kagglesdk.") from exc
-        request = ApiGetHackathonOverviewRequest()
-        request.competition_name = competition
-        return request
-
-    def _build_list_hackathon_writeups_request(self, competition: str):
-        try:
-            from kagglesdk.competitions.types.competition_api_service import (  # type: ignore
-                ApiListHackathonWriteUpsRequest,
-            )
-        except ImportError as exc:
-            raise ValueError("kagglesdk is missing ApiListHackathonWriteUpsRequest; please upgrade kagglesdk.") from exc
-        request = ApiListHackathonWriteUpsRequest()
-        request.competition_name = competition
-        return request
-
-    def _build_export_hackathon_writeups_csv_request(self, competition: str):
-        try:
-            from kagglesdk.competitions.types.hackathon_service import (  # type: ignore
-                ExportHackathonWriteUpsCsvRequest,
-            )
-        except ImportError as exc:
-            raise ValueError(
-                "kagglesdk is missing ExportHackathonWriteUpsCsvRequest; please upgrade kagglesdk."
-            ) from exc
-        request = ExportHackathonWriteUpsCsvRequest()
-        request.competition_name = competition
-        return request
-
-    def _build_get_resolved_writeup_links_request(self, write_up_id: int):
-        try:
-            from kagglesdk.discussions.types.writeups_service import (  # type: ignore
-                GetResolvedWriteUpLinksRequest,
-            )
-        except ImportError as exc:
-            raise ValueError("kagglesdk is missing GetResolvedWriteUpLinksRequest; please upgrade kagglesdk.") from exc
-        request = GetResolvedWriteUpLinksRequest()
-        request.write_up_id = write_up_id
-        return request
-
     def hackathon_get_overview(self, competition: str):
         """Get the overview page content for a hackathon competition.
 
         Mirrors the ``get_hackathon_overview`` MCP tool.
         """
         if not competition:
             raise ValueError("No competition specified")
+        request = ApiGetHackathonOverviewRequest()
+        request.competition_name = competition
         with self.build_kaggle_client() as kaggle:
-            request = self._build_hackathon_overview_request(competition)
-            client = kaggle.competitions.competition_api_client
-            method = self._require_sdk_method(
-                client,
-                "get_hackathon_overview",
-                "CompetitionApiClient.get_hackathon_overview",
-            )
-            return method(request)
+            return kaggle.competitions.competition_api_client.get_hackathon_overview(request)
 
     def hackathon_get_overview_cli(self, competition=None, csv_display=False, quiet=False):
         """CLI wrapper for ``kaggle hackathons get <competition>``."""
@@ -2757,15 +2695,10 @@ def hackathon_list_writeups(self, competition: str):
         """
         if not competition:
             raise ValueError("No competition specified")
+        request = ApiListHackathonWriteUpsRequest()
+        request.competition_name = competition
         with self.build_kaggle_client() as kaggle:
-            request = self._build_list_hackathon_writeups_request(competition)
-            client = kaggle.competitions.competition_api_client
-            method = self._require_sdk_method(
-                client,
-                "list_hackathon_write_ups",
-                "CompetitionApiClient.list_hackathon_write_ups",
-            )
-            return method(request)
+            return kaggle.competitions.competition_api_client.list_hackathon_write_ups(request)
 
     def hackathon_list_writeups_cli(self, competition=None, csv_display=False, quiet=False):
         """CLI wrapper for ``kaggle hackathons writeups list <competition>``."""
@@ -2815,15 +2748,16 @@ def hackathon_download_writeups(self, competition: str, path: Optional[str] = No
         """
         if not competition:
             raise ValueError("No competition specified")
+        # Not yet exported by any released kagglesdk; import lazily so the
+        # rest of the module still loads. Drop this once kagglesdk ships it.
+        from kagglesdk.competitions.types.hackathon_service import (  # type: ignore
+            ExportHackathonWriteUpsCsvRequest,
+        )
+
+        request = ExportHackathonWriteUpsCsvRequest()
+        request.competition_name = competition
         with self.build_kaggle_client() as kaggle:
-            request = self._build_export_hackathon_writeups_csv_request(competition)
-            client = kaggle.competitions.hackathon_client
-            method = self._require_sdk_method(
-                client,
-                "export_hackathon_write_ups_csv",
-                "HackathonClient.export_hackathon_write_ups_csv",
-            )
-            response = method(request)
+            response = kaggle.competitions.hackathon_client.export_hackathon_write_ups_csv(request)
 
         csv_body = (
             getattr(response, "csv", None)
@@ -2869,19 +2803,21 @@ def hackathon_resolve_writeup_links(self, write_up_id: int):
         """
         if write_up_id is None:
             raise ValueError("No write_up_id specified")
+        # Not yet exported by any released kagglesdk; import lazily so the
+        # rest of the module still loads. Drop this once kagglesdk ships it.
+        from kagglesdk.discussions.types.writeups_service import (  # type: ignore
+            GetResolvedWriteUpLinksRequest,
+        )
+
+        request = GetResolvedWriteUpLinksRequest()
+        request.write_up_id = int(write_up_id)
         with self.build_kaggle_client() as kaggle:
-            request = self._build_get_resolved_writeup_links_request(int(write_up_id))
             client = getattr(kaggle.discussions, "writeups_client", None) or getattr(
                 kaggle.discussions, "write_ups_client", None
             )
             if client is None:
                 raise ValueError("kagglesdk is missing the WriteUpsClient; please upgrade kagglesdk.")
-            method = self._require_sdk_method(
-                client,
-                "get_resolved_writeup_links",
-                "WriteUpsClient.get_resolved_writeup_links",
-            )
-            return method(request)
+            return client.get_resolved_writeup_links(request)
 
     def hackathon_resolve_writeup_links_cli(self, writeup_id=None, csv_display=False, quiet=False):
         """CLI wrapper for ``kaggle hackathons writeups resolve-links <writeup_id>``."""

src/kaggle/test/test_hackathons_cli.py

@@ -1,22 +1,38 @@
 """Tests for ``kaggle hackathons`` CLI commands.
 
-The hackathon endpoints (``get_hackathon_overview``,
-``list_hackathon_write_ups``, ``export_hackathon_write_ups_csv``,
-``get_resolved_writeup_links``) may not yet exist on the installed
-``kagglesdk``. The CLI wrappers build their request objects via lazy
-imports and look up the SDK methods with ``getattr``, so the tests here
-mock ``KaggleApi.build_kaggle_client`` and the lazy ``_build_*`` request
-helpers — no SDK methods need to actually exist for the tests to run.
+The two CSV-export and resolve-links endpoints are not yet shipped by any
+released ``kagglesdk``, so those wrappers still import their request types
+lazily. The fixture pins a ``WriteUpsClient`` onto the mocked
+``kaggle.discussions`` so the resolve-links code path resolves cleanly.
 """
 
 import argparse
+import sys
+import types
 from unittest.mock import MagicMock, patch
 
 import pytest
 
 from kaggle.api.kaggle_api_extended import KaggleApi
 from kaggle import cli as kaggle_cli
 
+
+def _install_missing_sdk_modules():
+    """Inject stub modules for the two request types kagglesdk hasn't shipped yet."""
+    hackathon_mod = "kagglesdk.competitions.types.hackathon_service"
+    if not hasattr(sys.modules.get(hackathon_mod), "ExportHackathonWriteUpsCsvRequest"):
+        mod = sys.modules.get(hackathon_mod) or types.ModuleType(hackathon_mod)
+        mod.ExportHackathonWriteUpsCsvRequest = type("ExportHackathonWriteUpsCsvRequest", (), {})
+        sys.modules[hackathon_mod] = mod
+    writeups_mod = "kagglesdk.discussions.types.writeups_service"
+    if writeups_mod not in sys.modules:
+        mod = types.ModuleType(writeups_mod)
+        mod.GetResolvedWriteUpLinksRequest = type("GetResolvedWriteUpLinksRequest", (), {})
+        sys.modules[writeups_mod] = mod
+
+
+_install_missing_sdk_modules()
+
 # ---- Fixtures & helpers ----
 
 
@@ -27,28 +43,15 @@ def api():
     mock_client = MagicMock()
     a.build_kaggle_client = MagicMock()
     a.build_kaggle_client.return_value.__enter__.return_value = mock_client
-    a._mock_client = mock_client
     a._mock_competitions = mock_client.competitions.competition_api_client
     a._mock_hackathon = mock_client.competitions.hackathon_client
     # The current SDK has no WriteUpsClient — pin one onto the mock so the
     # production lookup (`getattr(...)`) finds it.
     a._mock_writeups = MagicMock()
     mock_client.discussions.writeups_client = a._mock_writeups
-    # Stub the lazy request builders so the tests don't depend on the SDK
-    # exposing the new request types.
-    a._build_hackathon_overview_request = MagicMock(side_effect=lambda c: _Req(c))
-    a._build_list_hackathon_writeups_request = MagicMock(side_effect=lambda c: _Req(c))
-    a._build_export_hackathon_writeups_csv_request = MagicMock(side_effect=lambda c: _Req(c))
-    a._build_get_resolved_writeup_links_request = MagicMock(side_effect=lambda wid: _Req(write_up_id=wid))
     return a
 
 
-class _Req:
-    def __init__(self, competition_name=None, write_up_id=None):
-        self.competition_name = competition_name
-        self.write_up_id = write_up_id
-
-
 def _make_overview_response(pages):
     r = MagicMock()
     r.pages = pages
@@ -132,13 +135,6 @@ def test_missing_competition(self, api):
         with pytest.raises(ValueError, match="No competition specified"):
             api.hackathon_get_overview_cli(None)
 
-    def test_missing_sdk_method(self, api):
-        # Strip the method off the client to force the missing-method path.
-        del api._mock_competitions.get_hackathon_overview
-        api._mock_competitions.mock_add_spec(["other_method"])
-        with pytest.raises(ValueError, match="newer kagglesdk"):
-            api.hackathon_get_overview("titanic")
-
 
 # ---- hackathons writeups list ----