handle 429

app.py

@@ -16,38 +16,7 @@ import requests
 from lilith_agent.app import build_react_agent
 from lilith_agent.config import Config
 from lilith_agent.runner import run_agent_on_questions
-
-
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-
-class ScoringApiClient:
-    """Tiny client for the GAIA scoring Space (questions + file download)."""
-
-    def __init__(self, api_url: str = DEFAULT_API_URL) -> None:
-        self.api_url = api_url.rstrip("/")
-
-    def get_questions(self) -> list[dict]:
-        r = requests.get(f"{self.api_url}/questions", timeout=30)
-        r.raise_for_status()
-        return r.json()
-
-    def download_file(self, task_id: str, dest_dir: str | Path) -> Path | None:
-        dest_dir = Path(dest_dir)
-        dest_dir.mkdir(parents=True, exist_ok=True)
-        try:
-            r = requests.get(f"{self.api_url}/files/{task_id}", timeout=60)
-            r.raise_for_status()
-        except requests.RequestException:
-            return None
-
-        filename = task_id
-        cd = r.headers.get("content-disposition", "")
-        if "filename=" in cd:
-            filename = cd.split("filename=")[-1].strip().strip('"')
-        out = dest_dir / filename
-        out.write_bytes(r.content)
-        return out
+from lilith_agent.scoring_client import DEFAULT_API_URL, ScoringApiClient
 
 
 class LilithAgent:
@@ -86,6 +55,8 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         questions_data = agent.client.get_questions()
     except requests.exceptions.RequestException as e:
         return f"Error fetching questions: {e}", None
+    if agent.client.last_warning:
+        print(agent.client.last_warning)
 
     if not questions_data:
         return "Fetched questions list is empty or invalid format.", None

src/lilith_agent/scoring_client.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import requests
+
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+log = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from lilith_agent.gaia_dataset import GaiaDatasetClient
+
+
+class ScoringApiClient:
+    """Client for the GAIA scoring Space with dataset fallback on transient failures."""
+
+    def __init__(
+        self,
+        api_url: str = DEFAULT_API_URL,
+        session: requests.Session | None = None,
+        dataset_client: Any | None = None,
+    ) -> None:
+        self.api_url = api_url.rstrip("/")
+        self.session = session or requests.Session()
+        self._dataset_client = dataset_client
+        self.last_warning: str | None = None
+
+    def get_questions(self) -> list[dict]:
+        try:
+            response = self.session.get(f"{self.api_url}/questions", timeout=30)
+            response.raise_for_status()
+            self.last_warning = None
+            return response.json()
+        except requests.RequestException as exc:
+            fallback = self._fallback_dataset_client_for(exc, action="fetch questions")
+            if fallback is None:
+                raise
+            return fallback.get_questions()
+
+    def download_file(self, task_id: str, dest_dir: str | Path) -> Path | None:
+        dest_dir = Path(dest_dir)
+        dest_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            response = self.session.get(f"{self.api_url}/files/{task_id}", timeout=60)
+            response.raise_for_status()
+        except requests.RequestException as exc:
+            fallback = self._fallback_dataset_client_for(exc, action=f"download file for {task_id}")
+            if fallback is None:
+                return None
+            return fallback.download_file(task_id, dest_dir)
+
+        filename = task_id
+        cd = response.headers.get("content-disposition", "")
+        if "filename=" in cd:
+            filename = cd.split("filename=")[-1].strip().strip('"')
+        out = dest_dir / filename
+        out.write_bytes(response.content)
+        self.last_warning = None
+        return out
+
+    def _fallback_dataset_client_for(
+        self,
+        exc: requests.RequestException,
+        *,
+        action: str,
+    ) -> Any | None:
+        if not self._should_use_dataset_fallback(exc):
+            return None
+        try:
+            dataset_client = self._get_dataset_client()
+        except Exception:
+            return None
+
+        status_code = getattr(getattr(exc, "response", None), "status_code", None)
+        detail = f"status={status_code}" if status_code is not None else exc.__class__.__name__
+        self.last_warning = (
+            f"Scoring API unavailable while trying to {action} ({detail}); "
+            f"falling back to GAIA dataset."
+        )
+        log.warning(self.last_warning)
+        return dataset_client
+
+    def _get_dataset_client(self) -> Any:
+        if self._dataset_client is None:
+            from lilith_agent.gaia_dataset import GaiaDatasetClient
+
+            token = os.getenv("HF_TOKEN") or os.getenv("GAIA_HUGGINGFACE_API_KEY")
+            self._dataset_client = GaiaDatasetClient(
+                config=os.getenv("GAIA_DATASET_CONFIG", "2023_all"),
+                split=os.getenv("GAIA_DATASET_SPLIT", "test"),
+                level=None,
+                token=token,
+            )
+        return self._dataset_client
+
+    @staticmethod
+    def _should_use_dataset_fallback(exc: requests.RequestException) -> bool:
+        if isinstance(exc, (requests.Timeout, requests.ConnectionError)):
+            return True
+        status_code = getattr(getattr(exc, "response", None), "status_code", None)
+        return status_code in {429, 502, 503, 504}

tests/test_checkpointing.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+import tempfile
 import types
 import unittest
 from pathlib import Path
@@ -11,8 +12,6 @@ from lilith_agent.checkpointing import build_checkpointer
 
 class CheckpointingTests(unittest.TestCase):
     def test_build_checkpointer_uses_sqlite_when_available(self) -> None:
-        tmp_path = Path(self._testMethodName)
-
         class FakeSqliteSaver:
             def __init__(self, conn) -> None:
                 self.conn = conn
@@ -22,15 +21,15 @@ class CheckpointingTests(unittest.TestCase):
                 return types.SimpleNamespace(SqliteSaver=FakeSqliteSaver)
             raise AssertionError(f"unexpected import: {name}")
 
-        with patch.object(importlib, "import_module", side_effect=fake_import_module):
-            saver = build_checkpointer(tmp_path)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmp_path = Path(tmpdir)
+            with patch.object(importlib, "import_module", side_effect=fake_import_module):
+                saver = build_checkpointer(tmp_path)
 
-        self.assertIsInstance(saver, FakeSqliteSaver)
-        self.assertTrue((tmp_path / "threads.sqlite").exists())
+            self.assertIsInstance(saver, FakeSqliteSaver)
+            self.assertTrue((tmp_path / "threads.sqlite").exists())
 
     def test_build_checkpointer_falls_back_to_in_memory_when_sqlite_package_missing(self) -> None:
-        tmp_path = Path(self._testMethodName)
-
         class FakeInMemorySaver:
             pass
 
@@ -41,12 +40,14 @@ class CheckpointingTests(unittest.TestCase):
                 return types.SimpleNamespace(InMemorySaver=FakeInMemorySaver)
             raise AssertionError(f"unexpected import: {name}")
 
-        with patch.object(importlib, "import_module", side_effect=fake_import_module):
-            with self.assertLogs("lilith_agent.checkpointing", level="WARNING") as captured:
-                saver = build_checkpointer(tmp_path)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmp_path = Path(tmpdir)
+            with patch.object(importlib, "import_module", side_effect=fake_import_module):
+                with self.assertLogs("lilith_agent.checkpointing", level="WARNING") as captured:
+                    saver = build_checkpointer(tmp_path)
 
-        self.assertIsInstance(saver, FakeInMemorySaver)
-        self.assertIn("langgraph-checkpoint-sqlite missing", "\n".join(captured.output))
+            self.assertIsInstance(saver, FakeInMemorySaver)
+            self.assertIn("langgraph-checkpoint-sqlite missing", "\n".join(captured.output))
 
     def test_requirements_include_langgraph_checkpoint_sqlite(self) -> None:
         requirements = Path("requirements.txt").read_text().splitlines()

tests/test_scoring_client.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import requests
+
+from lilith_agent.scoring_client import ScoringApiClient
+
+
+class ScoringApiClientTests(unittest.TestCase):
+    def test_get_questions_returns_api_payload_on_success(self) -> None:
+        response = Mock()
+        response.json.return_value = [{"task_id": "t1", "question": "Q"}]
+        response.raise_for_status.return_value = None
+
+        session = Mock()
+        session.get.return_value = response
+
+        client = ScoringApiClient(api_url="https://example.com", session=session)
+
+        payload = client.get_questions()
+
+        self.assertEqual(payload, [{"task_id": "t1", "question": "Q"}])
+        self.assertIsNone(client.last_warning)
+        session.get.assert_called_once_with("https://example.com/questions", timeout=30)
+
+    def test_get_questions_falls_back_to_dataset_on_429(self) -> None:
+        response = Mock(status_code=429, headers={})
+        error = requests.HTTPError("Too Many Requests", response=response)
+        response.raise_for_status.side_effect = error
+
+        session = Mock()
+        session.get.return_value = response
+        dataset_client = Mock()
+        dataset_client.get_questions.return_value = [{"task_id": "fallback", "question": "Q2"}]
+
+        client = ScoringApiClient(
+            api_url="https://example.com",
+            session=session,
+            dataset_client=dataset_client,
+        )
+
+        payload = client.get_questions()
+
+        self.assertEqual(payload, [{"task_id": "fallback", "question": "Q2"}])
+        self.assertIn("429", client.last_warning or "")
+        dataset_client.get_questions.assert_called_once_with()
+
+    def test_download_file_falls_back_to_dataset_on_429(self) -> None:
+        response = Mock(status_code=429, headers={})
+        error = requests.HTTPError("Too Many Requests", response=response)
+        response.raise_for_status.side_effect = error
+
+        session = Mock()
+        session.get.return_value = response
+        dataset_client = Mock()
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            fallback_path = Path(tmpdir) / "from-dataset.txt"
+            fallback_path.write_text("ok")
+            dataset_client.download_file.return_value = fallback_path
+
+            client = ScoringApiClient(
+                api_url="https://example.com",
+                session=session,
+                dataset_client=dataset_client,
+            )
+
+            payload = client.download_file("task-123", tmpdir)
+
+        self.assertEqual(payload, fallback_path)
+        self.assertIn("429", client.last_warning or "")
+        dataset_client.download_file.assert_called_once_with("task-123", Path(tmpdir))
+
+    def test_default_dataset_client_is_built_lazily(self) -> None:
+        session = Mock()
+        response = Mock(status_code=429, headers={})
+        error = requests.HTTPError("Too Many Requests", response=response)
+        response.raise_for_status.side_effect = error
+        session.get.return_value = response
+
+        dataset_instance = Mock()
+        dataset_instance.get_questions.return_value = []
+
+        with patch.object(ScoringApiClient, "_get_dataset_client", return_value=dataset_instance) as getter:
+            client = ScoringApiClient(api_url="https://example.com", session=session)
+            client.get_questions()
+
+        getter.assert_called_once_with()
+
+
+if __name__ == "__main__":
+    unittest.main()