everestapi 0.3.2__tar.gz → 0.3.6__tar.gz

{everestapi-0.3.2/src/everestapi.egg-info → everestapi-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: everestapi
-Version: 0.3.2
+Version: 0.3.6
 Summary: Python SDK for the Everesteer prediction tournament platform
 Author-email: Everesteer <support@everesteer.ai>
 License-Expression: MIT

{everestapi-0.3.2 → everestapi-0.3.6}/src/everestapi/__init__.py

@@ -1,6 +1,6 @@
 """EverestAPI — Python SDK for the Everesteer prediction tournament platform."""
 
-__version__ = "0.3.2"
+__version__ = "0.3.6"
 
 from everestapi.client import EverestAPI, EverestError
 from everestapi.types import (

{everestapi-0.3.2 → everestapi-0.3.6}/src/everestapi/client.py

@@ -405,29 +405,40 @@ class EverestAPI:
                 data = f.read()
             fname = str(predictions).rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
 
-        files = {"file": (fname, data, "application/octet-stream")}
+        pkl_data = None
+        pkl_fname = "model.pkl"
         if model_pkl is not None:
             if isinstance(model_pkl, bytes | bytearray):
                 pkl_data = bytes(model_pkl)
-                pkl_fname = "model.pkl"
             else:  # path
                 with open(model_pkl, "rb") as f:
                     pkl_data = f.read()
                 pkl_fname = str(model_pkl).rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
-            files["model_pkl"] = (pkl_fname, pkl_data, "application/octet-stream")
 
-        resp = self._client.post(
-            "/api/v1/diagnostics/upload",
-            files=files,
-            data={"model_id": model_id, "tournament": tournament, "target": target},
+        # EVE-1159: prefer the presigned direct-to-CDN path — it uploads the file
+        # straight to S3 through a DNS-only CloudFront host, bypassing the
+        # Cloudflare proxy edge that drops large POSTs. Falls back to the multipart
+        # endpoint when the server/env doesn't offer it (old server, or the CDN
+        # isn't configured), so behaviour is unchanged everywhere else.
+        accepted = self._diagnostics_presigned_accept(
+            model_id, data, fname, pkl_data, pkl_fname, tournament, target
         )
-        if resp.status_code >= 400:
-            try:
-                detail = resp.json()
-            except Exception:
-                detail = resp.text
-            raise EverestError(resp.status_code, detail)
-        accepted = resp.json()
+        if accepted is None:
+            files = {"file": (fname, data, "application/octet-stream")}
+            if pkl_data is not None:
+                files["model_pkl"] = (pkl_fname, pkl_data, "application/octet-stream")
+            resp = self._client.post(
+                "/api/v1/diagnostics/upload",
+                files=files,
+                data={"model_id": model_id, "tournament": tournament, "target": target},
+            )
+            if resp.status_code >= 400:
+                try:
+                    detail = resp.json()
+                except Exception:
+                    detail = resp.text
+                raise EverestError(resp.status_code, detail)
+            accepted = resp.json()
         if not wait:
             return accepted
         deadline = time.time() + timeout
@@ -440,6 +451,65 @@ class EverestAPI:
             time.sleep(poll_interval)
         raise EverestError(504, "diagnostics run timed out")
 
+    def _diagnostics_presigned_accept(
+        self,
+        model_id: str,
+        data: bytes,
+        fname: str,
+        pkl_data: bytes | None,
+        pkl_fname: str,
+        tournament: str,
+        target: str,
+    ) -> dict | None:
+        """EVE-1159: attempt the presigned direct-to-CDN upload.
+
+        Returns the accept dict on success, or ``None`` when the server/env
+        doesn't offer it (endpoint 404, or ``available: false``) so the caller
+        falls back to the multipart endpoint. Raises :class:`EverestError` on a
+        real failure (bad file, storage error) so it is NOT silently retried.
+        """
+        body: dict = {
+            "model_id": model_id,
+            "filename": fname,
+            "tournament": tournament,
+            "target": target,
+        }
+        if pkl_data is not None:
+            body["model_pkl_filename"] = pkl_fname
+        try:
+            presign = self._request("POST", "/api/v1/diagnostics/upload/presign", json=body)
+        except EverestError as e:
+            if e.status_code == 404:
+                return None  # server predates the presigned path
+            raise
+        if not presign.get("available"):
+            return None  # upload CDN not configured in this env
+        self._s3_post(presign["predictions"], fname, data)
+        if pkl_data is not None and presign.get("model_pkl"):
+            self._s3_post(presign["model_pkl"], pkl_fname, pkl_data)
+        complete: dict = {
+            "upload_id": presign["upload_id"],
+            "model_id": model_id,
+            "filename": fname,
+            "tournament": tournament,
+            "target": target,
+        }
+        return self._request("POST", "/api/v1/diagnostics/upload/complete", json=complete)
+
+    @staticmethod
+    def _s3_post(post: dict, fname: str, data: bytes) -> None:
+        """POST one object straight to S3 via the presigned CloudFront form. The
+        file field MUST come last per the S3 POST policy — httpx sends the ``data``
+        form fields before the ``files`` part, so this ordering is correct."""
+        resp = httpx.post(
+            post["url"],
+            data=post["fields"],
+            files={"file": (fname, data, "application/octet-stream")},
+            timeout=300.0,
+        )
+        if resp.status_code not in (200, 201, 204):
+            raise EverestError(resp.status_code, f"direct upload failed: {resp.text[:300]}")
+
     def get_diagnostics_run(self, upload_id: str) -> dict:
         """GET /api/v1/diagnostics/runs/{upload_id} — status + metrics for one run."""
         return self._request("GET", f"/api/v1/diagnostics/runs/{upload_id}")
@@ -662,9 +732,10 @@ class EverestAPI:
         The download route is version-scoped
         (``/api/v1/data/download/{version}/{universe}/{split}``). Pass
         ``version="latest"`` (the default) to resolve the current version from
-        ``/api/v1/data/versions`` automatically, or an explicit version
-        (e.g. ``"bregen"``) to pin it. A stale pinned version self-heals: on a
-        404 the current version is resolved and the download retried once.
+        ``/api/v1/data/versions`` automatically, or an explicit version string
+        (as returned by :meth:`list_versions`) to pin it. A stale pinned
+        version self-heals: on a 404 the current version is resolved and the
+        download retried once.
 
         Splits: ``train`` / ``validation`` (features + targets), ``live``
         (features only, no targets). In hackathon mode, ``train`` is the LABELED
@@ -677,8 +748,8 @@ class EverestAPI:
         404s for hackathon keys.
 
         Futures is served by the futures endpoint (``version`` is a no-op):
-        it returns the real bregen tree to full-scope keys and the hackathon
-        tree (labeled ``train`` + blank-target ``validation``) to
+        it returns the current production dataset to full-scope keys and the
+        hackathon tree (labeled ``train`` + blank-target ``validation``) to
         hackathon-scoped keys.
 
         Value semantics: observed feature values are cross-sectional
@@ -895,12 +966,18 @@ class EverestAPI:
 
     # -- data discovery ---------------------------------------------------
 
-    def get_dataset_schema(self, version: str = "bregen", verbose: bool = False) -> dict:
+    def get_dataset_schema(self, version: str = "latest", verbose: bool = False) -> dict:
         """Get the dataset schema for a version.
 
+        ``version="latest"`` (the default) resolves the current version from
+        ``/api/v1/data/versions`` automatically, or pass an explicit version
+        string (as returned by :meth:`list_versions`) to pin it.
+
         Default is a compact summary (feature-set counts, target list, which splits
         are labeled, the CV embargo, distinct feature count, active version). Pass
         ``verbose=True`` for the full per-feature listing."""
+        if version in (None, "latest", "current"):
+            version = self._current_dataset_version("futures") or "v0"
         path = f"/api/v1/data/{version}/schema"
         if verbose:
             path += "?verbose=true"

{everestapi-0.3.2 → everestapi-0.3.6}/src/everestapi/mcp/server.py

@@ -298,8 +298,8 @@ TOOLS = [
             "properties": {
                 "version": {
                     "type": "string",
-                    "description": "Dataset version (default: bregen)",
-                    "default": "bregen",
+                    "description": "Dataset version (default: latest, resolved from /api/v1/data/versions)",
+                    "default": "latest",
                 },
             },
             "required": [],
@@ -340,7 +340,7 @@ TOOLS = [
     },
     {
         "name": "train",
-        "description": "Train a model on Everesteer data (no data upload — the platform uses the same obfuscated dataset you download). The PLATFORM loads data, runs exped-purged/embargoed cross-validation, computes canonical tournament metrics (a weighted combination of CORR and AIMC, AIMC-dominant, with per-model weights read from the API; AIMC before round close is a PRE-SUBMISSION ESTIMATE vs a static consensus proxy — real AIMC is scored vs the live stake-weighted crowd at round close), pickles the final model, and returns DOWNLOADABLE artifacts (model .pkl + validation/live prediction files) plus the metrics. Supply a built-in `model` preset (lightgbm/xgboost/ridge/mlp/random_forest), or `model='custom'` with a `custom_model_fn` (and optional `custom_feature_fn`) to run your own code — it executes inside an isolated, network-denied sandbox with no filesystem access and never sees held-out targets; a script rejected by the static safety scanner returns 400. `train` does NOT submit predictions or host a model on your behalf — use submit_futures_predictions/submit_predictions_file to submit and upload_model to host the .pkl. Poll with get_job_status() — the completed result carries the metrics + a predictions download URL; fetch the model file separately via get_model_download_url(). Call get_compute_credits for the live per-hour GPU rate card and your balance.",
+        "description": "Train a model REMOTELY on Everesteer's hosted compute — nothing executes on your machine. The call returns immediately with a job id and may run for up to 45 minutes. Poll get_job_status and get_job_log every 10–15 seconds for a reconnect-safe estimated percentage, stage, and fold-level messages. The platform loads its obfuscated data, runs purged CV, computes canonical metrics, and returns downloadable model/prediction artifacts; it does not submit or host the model for you. Custom code runs in an isolated network-denied sandbox without filesystem access or held-out targets. Call get_compute_credits for the live rate card and balance.",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -404,7 +404,7 @@ TOOLS = [
     },
     {
         "name": "get_job_status",
-        "description": "Check status of a compute job. Returns status, cost, output files when complete.",
+        "description": "Check status plus reconnect-safe estimated percentage, stage, message, and update time. Poll every 10–15 seconds while running; use get_job_log for the full fold-level trail.",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -416,6 +416,17 @@ TOOLS = [
             "required": ["job_id"],
         },
     },
+    {
+        "name": "get_job_log",
+        "description": "Return the estimated progress summary and lifecycle/per-fold event trail for one training job. Poll every 10–15 seconds while running. Percentages are workflow estimates, not an ETA.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "job_id": {"type": "string", "description": "Job ID returned by train"},
+            },
+            "required": ["job_id"],
+        },
+    },
     {
         "name": "get_model_download_url",
         "description": "Get a presigned download URL for a trained model from a completed job. URL valid for 1 hour. Only you can download your own models.",
@@ -430,6 +441,38 @@ TOOLS = [
             "required": ["job_id"],
         },
     },
+    {
+        "name": "get_job_predictions_url",
+        "description": "Get a presigned download URL for the prediction files (validation + live parquet) produced by a completed train job. URL valid for ~1 hour. Only you can download your own job's predictions. Fetch the model .pkl separately with get_model_download_url.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "job_id": {
+                    "type": "string",
+                    "description": "Job ID from a train job",
+                },
+            },
+            "required": ["job_id"],
+        },
+    },
+    {
+        "name": "list_compute_jobs",
+        "description": "List your compute training jobs, newest first. Rows carry status, GPU, cost and the provider job id but exclude the large config/output payloads — use get_job_status for one job's full record. Optionally filter by status.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "limit": {
+                    "type": "integer",
+                    "description": "Max rows (default 50, capped at 200)",
+                },
+                "status": {
+                    "type": "string",
+                    "description": "Filter to one status",
+                    "enum": ["pending", "running", "completed", "failed", "timeout", "cancelled"],
+                },
+            },
+        },
+    },
     {
         "name": "get_compute_credits",
         "description": "Check your compute credit balance and usage. Purchase credits with USDC before using GPU resources.",
@@ -994,7 +1037,10 @@ READ_ONLY_TOOLS = frozenset(
         "download_dataset",
         "download_benchmark",
         "get_job_status",
+        "get_job_log",
+        "list_compute_jobs",
         "get_model_download_url",
+        "get_job_predictions_url",
         "get_compute_credits",
         "get_rounds",
         "get_current_round",
@@ -1077,10 +1123,19 @@ TOOLSETS: dict[str, set[str]] = {
         # EVE-970: hosted training is a first-class flow now that every account
         # carries a compute grant — advertise train + get_compute_credits by
         # default so agents discover the hosted-training entry point without
-        # setting EIQ_MCP_TOOLSETS. get_job_status stays in "compute" (hidden
-        # tools remain callable by name). Mirrors the platform MCP server.
+        # setting EIQ_MCP_TOOLSETS. EVE-1145 (platform parity): the whole
+        # job-lifecycle group is core too. train's description tells the caller
+        # to poll get_job_status()/get_job_log() and fetch artifacts via
+        # get_model_download_url()/get_job_predictions_url() — hiding those in a
+        # non-default group made hosted training an unfinishable dead end for an
+        # agent that only sees the default toolset. Mirrors the platform MCP server.
         "train",
         "get_compute_credits",
+        "get_job_status",
+        "get_job_log",
+        "list_compute_jobs",
+        "get_model_download_url",
+        "get_job_predictions_url",
     },
     "data": {
         "get_universe",
@@ -1093,7 +1148,6 @@ TOOLSETS: dict[str, set[str]] = {
         "get_benchmarks",
         "download_benchmark",
         "get_models",
-        "get_model_download_url",
         "get_model_per_exped_breakdown",
     },
     "submit": {"submit_predictions", "upload_model", "get_upload_status"},
@@ -1102,9 +1156,10 @@ TOOLSETS: dict[str, set[str]] = {
         # "core" (EVE-967) — every name still lives in exactly one group.
         "run_validation_diagnostics",
     },
-    "compute": {
-        "get_job_status",
-    },
+    # EVE-1145: the job-lifecycle tools (get_job_status/get_job_log/
+    # list_compute_jobs/get_model_download_url/get_job_predictions_url) were
+    # promoted to "core". Kept as a stable, addressable EIQ_MCP_TOOLSETS name.
+    "compute": set(),
     "staking": {
         "stake_on_model",
         "unstake_from_model",
@@ -1221,6 +1276,33 @@ def _validate_predictions_file(path: str) -> None:
         )
 
 
+def _client_env() -> dict:
+    """Self-report the running interpreter + the command that upgrades IT.
+
+    The MCP runs from a dedicated venv (~/.eiq-agent) that a bare `pip install`
+    in the user's shell does NOT target — so an agent told to "update everestapi"
+    upgrades the wrong Python and leaves this one stale (EVE-1163). Build the
+    upgrade command from sys.executable so the handed-back command always hits
+    the venv the MCP actually runs from.
+    """
+    try:
+        from importlib.metadata import version
+
+        ver = version("everestapi")
+    except Exception:  # metadata is always present in a real install
+        ver = "unknown"
+    return {
+        "everestapi_version": ver,
+        "python": sys.executable,
+        "upgrade_command": f'"{sys.executable}" -m pip install -U "everestapi[mcp]"',
+        "note": (
+            "This MCP runs from the interpreter above. A bare `pip install` in "
+            "your shell may target a different Python and leave this one stale — "
+            "use upgrade_command (or re-run the everesteer installer)."
+        ),
+    }
+
+
 def _dispatch(name: str, arguments: dict) -> str:
     """Call the appropriate SDK method and return JSON string."""
     name = name.removeprefix(TOOL_NAMESPACE)
@@ -1263,7 +1345,7 @@ def _dispatch(name: str, arguments: dict) -> str:
     elif name == "get_leaderboard":
         result = client.get_leaderboard(period=arguments.get("period", "30d"))
     elif name == "get_dataset_schema":
-        result = client.get_dataset_schema(version=arguments.get("version", "bregen"))
+        result = client.get_dataset_schema(version=arguments.get("version", "latest"))
     elif name == "download_dataset":
         path = client.download_dataset(
             universe=arguments.get("universe", "futures"),
@@ -1282,8 +1364,17 @@ def _dispatch(name: str, arguments: dict) -> str:
         result = client.train(**arguments)
     elif name == "get_job_status":
         result = client.get_job_status(job_id=arguments["job_id"])
+    elif name == "get_job_log":
+        result = client.get_job_log(job_id=arguments["job_id"])
     elif name == "get_model_download_url":
         result = client.get_model_download_url(job_id=arguments["job_id"])
+    elif name == "get_job_predictions_url":
+        result = client.get_job_predictions_url(job_id=arguments["job_id"])
+    elif name == "list_compute_jobs":
+        result = client.list_compute_jobs(
+            limit=arguments.get("limit", 50),
+            status=arguments.get("status"),
+        )
     elif name == "get_compute_credits":
         result = client.get_compute_credits()
     elif name == "get_rounds":
@@ -1297,6 +1388,10 @@ def _dispatch(name: str, arguments: dict) -> str:
         )
     elif name == "get_started":
         result = client.get_started()
+        # EVE-1163: tell a self-updating agent exactly which interpreter to
+        # upgrade, so it can't miss the isolated ~/.eiq-agent venv.
+        if isinstance(result, dict):
+            result["client_env"] = _client_env()
     elif name == "get_status":
         # GET-proxy, same fallback shape as get_started — works on an older
         # standalone everestapi build without the get_status() method.
@@ -1618,7 +1713,8 @@ _MCP_INSTRUCTIONS = (
     "get_diagnostics_leaderboard; after submissions close, set_final_selection picks up to "
     "2 models as final entries during the grace window (default: best 2 public). "
     "Round/universe/feature/benchmark reads return empty diagnostics-mode payloads, not "
-    "live data.\n\n"
+    "live data. Working example scripts (train/predict/submit) live at "
+    "https://github.com/everestquant/example-scripts.\n\n"
     "Tournament mode (a full-scope key): submit daily futures predictions; payout is a "
     "weighted combination of CORR and AIMC (AIMC-dominant, per-model weights read from the "
     "API). The default tournament is 'futures' (equities is unlaunched).\n\n"
@@ -1649,9 +1745,12 @@ _NEXT_ACTIONS: dict[str, list[str]] = {
     "download_dataset": ["create_model", "submit_futures_predictions"],
     "download_benchmark": ["submit_futures_predictions"],
     "get_benchmarks": ["download_benchmark"],
-    "train": ["get_job_status"],
-    "get_job_status": ["get_model_download_url"],  # conditional
+    "train": ["get_job_status", "get_job_log"],
+    "get_job_status": ["get_model_download_url", "get_job_predictions_url"],  # conditional
+    "get_job_log": ["get_job_status", "train"],
+    "list_compute_jobs": ["get_job_status", "get_job_log"],
     "get_model_download_url": ["upload_model", "create_model"],
+    "get_job_predictions_url": ["submit_futures_predictions", "create_model"],
     "create_model": ["submit_futures_predictions", "upload_model"],
     "upload_model": ["get_upload_status"],
     "get_upload_status": ["submit_futures_predictions"],  # conditional
@@ -1714,6 +1813,8 @@ _NARRATION: dict[str, str] = {
     "train": "Training job queued — returns downloadable artifacts + metrics, not a submission.",
     "get_job_status": "Training job status: {status}.",
     "get_model_download_url": "Generated a download URL for the trained model (valid ~1h).",
+    "get_job_predictions_url": "Generated a download URL for the job's predictions (valid ~1h).",
+    "list_compute_jobs": "Returned your compute jobs.",
     "upload_model": "Model artifact uploaded; validation runs asynchronously.",
     "get_upload_status": "Model upload status: {status}.",
     "get_scores": "Returned the score history for model '{model_id}'.",
@@ -1771,8 +1872,8 @@ def _next_actions_for(name: str, arguments: dict, data: dict) -> list[str]:
         if status in ("completed", "done", "succeeded", "success"):
             return ["get_model_download_url", "create_model"]
         if status in ("failed", "error"):
-            return ["train"]
-        return ["get_job_status"]  # still running — keep polling
+            return ["get_job_log", "train"]
+        return ["get_job_status", "get_job_log"]
     if name == "get_upload_status":
         if status in ("validated", "done", "success", "ready", "active"):
             return ["submit_futures_predictions", "get_scores"]

{everestapi-0.3.2 → everestapi-0.3.6/src/everestapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: everestapi
-Version: 0.3.2
+Version: 0.3.6
 Summary: Python SDK for the Everesteer prediction tournament platform
 Author-email: Everesteer <support@everesteer.ai>
 License-Expression: MIT

{everestapi-0.3.2 → everestapi-0.3.6}/src/everestapi.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/everestapi/mcp/__main__.py
 src/everestapi/mcp/server.py
 tests/test_cli.py
 tests/test_client.py
+tests/test_client_env.py
 tests/test_diagnostics.py
 tests/test_eve1087_cpu_tier.py
 tests/test_eve953_mcp_progress.py

{everestapi-0.3.2 → everestapi-0.3.6}/tests/test_client.py

@@ -130,7 +130,7 @@ def test_download_dataset_futures_uses_futures_endpoint(httpx_mock, api, tmp_pat
         universe="futures",
         split="validation",
         output_path=str(tmp_path / "f.parquet"),
-        version="bregen",
+        version="some-version",
     )
     assert out == str(tmp_path / "f.parquet")
     paths = [r.url.path for r in httpx_mock.get_requests()]

everestapi-0.3.6/tests/test_client_env.py

@@ -0,0 +1,12 @@
+import sys
+
+from everestapi.mcp.server import _client_env
+
+
+def test_client_env_targets_this_interpreter():
+    """The upgrade command must point at the running venv, not bare `pip`."""
+    env = _client_env()
+    assert env["python"] == sys.executable
+    assert sys.executable in env["upgrade_command"]
+    assert "everestapi[mcp]" in env["upgrade_command"]
+    assert env["everestapi_version"]  # resolved, non-empty

{everestapi-0.3.2 → everestapi-0.3.6}/tests/test_diagnostics.py

@@ -41,7 +41,21 @@ def preds_file(tmp_path):
     return str(p)
 
 
+# EVE-1159: submit_validation_diagnostics now tries the presigned direct-to-CDN
+# path first. These helpers drive the two branches: fall back to multipart when
+# the CDN is unavailable, or take the presigned path when it is.
+_PRESIGN_URL = "http://test/api/v1/diagnostics/upload/presign"
+_COMPLETE_URL = "http://test/api/v1/diagnostics/upload/complete"
+_UPLOAD_URL = "http://test/api/v1/diagnostics/upload"
+
+
+def _presign_unavailable(httpx_mock):
+    """Make /presign report the CDN is off so the client falls back to multipart."""
+    httpx_mock.add_response(method="POST", url=_PRESIGN_URL, json={"available": False})
+
+
 def test_submit_no_wait_returns_accept(api, httpx_mock, preds_file):
+    _presign_unavailable(httpx_mock)  # → multipart fallback
     httpx_mock.add_response(
         method="POST",
         url="http://test/api/v1/diagnostics/upload",
@@ -53,7 +67,7 @@ def test_submit_no_wait_returns_accept(api, httpx_mock, preds_file):
     assert result["status"] == "pending"
 
     # Multipart body carries the file part plus the three form fields.
-    body = httpx_mock.get_request().content.decode("latin-1")
+    body = httpx_mock.get_request(url=_UPLOAD_URL).content.decode("latin-1")
     assert 'name="file"' in body
     assert 'name="model_id"' in body
     assert "m1" in body
@@ -62,6 +76,7 @@ def test_submit_no_wait_returns_accept(api, httpx_mock, preds_file):
 
 
 def test_submit_wait_polls_until_done(api, httpx_mock, preds_file):
+    _presign_unavailable(httpx_mock)
     httpx_mock.add_response(
         method="POST",
         url="http://test/api/v1/diagnostics/upload",
@@ -86,6 +101,7 @@ def test_submit_wait_polls_until_done(api, httpx_mock, preds_file):
 
 
 def test_submit_wait_raises_on_failed(api, httpx_mock, preds_file):
+    _presign_unavailable(httpx_mock)
     httpx_mock.add_response(
         method="POST",
         url="http://test/api/v1/diagnostics/upload",
@@ -106,6 +122,7 @@ def test_submit_wait_raises_on_failed(api, httpx_mock, preds_file):
 
 
 def test_submit_wait_raises_on_timeout(api, httpx_mock, preds_file):
+    _presign_unavailable(httpx_mock)
     httpx_mock.add_response(
         method="POST",
         url="http://test/api/v1/diagnostics/upload",
@@ -171,6 +188,7 @@ def test_format_tables_render_dashes_for_none():
 
 
 def test_submit_with_model_pkl_bytes_adds_part(api, httpx_mock, preds_file):
+    _presign_unavailable(httpx_mock)
     httpx_mock.add_response(
         method="POST",
         url="http://test/api/v1/diagnostics/upload",
@@ -180,7 +198,7 @@ def test_submit_with_model_pkl_bytes_adds_part(api, httpx_mock, preds_file):
     api.submit_validation_diagnostics(
         model_id="m1", predictions=preds_file, model_pkl=b"\x80\x05fakepkl."
     )
-    body = httpx_mock.get_request().content.decode("latin-1")
+    body = httpx_mock.get_request(url=_UPLOAD_URL).content.decode("latin-1")
     assert 'name="model_pkl"' in body
     assert 'filename="model.pkl"' in body
 
@@ -188,6 +206,7 @@ def test_submit_with_model_pkl_bytes_adds_part(api, httpx_mock, preds_file):
 def test_submit_with_model_pkl_path_adds_part(api, httpx_mock, preds_file, tmp_path):
     pkl = tmp_path / "my-model.pkl"
     pkl.write_bytes(b"\x80\x05fakepkl.")
+    _presign_unavailable(httpx_mock)
     httpx_mock.add_response(
         method="POST",
         url="http://test/api/v1/diagnostics/upload",
@@ -195,12 +214,13 @@ def test_submit_with_model_pkl_path_adds_part(api, httpx_mock, preds_file, tmp_p
         json={"upload_id": "u3", "status": "pending"},
     )
     api.submit_validation_diagnostics(model_id="m1", predictions=preds_file, model_pkl=str(pkl))
-    body = httpx_mock.get_request().content.decode("latin-1")
+    body = httpx_mock.get_request(url=_UPLOAD_URL).content.decode("latin-1")
     assert 'name="model_pkl"' in body
     assert 'filename="my-model.pkl"' in body
 
 
 def test_submit_without_model_pkl_omits_part(api, httpx_mock, preds_file):
+    _presign_unavailable(httpx_mock)
     httpx_mock.add_response(
         method="POST",
         url="http://test/api/v1/diagnostics/upload",
@@ -208,10 +228,89 @@ def test_submit_without_model_pkl_omits_part(api, httpx_mock, preds_file):
         json={"upload_id": "u4", "status": "pending"},
     )
     api.submit_validation_diagnostics(model_id="m1", predictions=preds_file)
-    body = httpx_mock.get_request().content.decode("latin-1")
+    body = httpx_mock.get_request(url=_UPLOAD_URL).content.decode("latin-1")
     assert 'name="model_pkl"' not in body
 
 
+# EVE-1159: the presigned direct-to-CDN path (the new default when available).
+def test_submit_presigned_path_uploads_to_cdn_then_completes(api, httpx_mock, preds_file):
+    httpx_mock.add_response(
+        method="POST",
+        url=_PRESIGN_URL,
+        json={
+            "available": True,
+            "upload_id": "up9",
+            "model_id": "m1",
+            "cdn_base": "http://cdn.test",
+            "predictions": {
+                "url": "http://cdn.test/",
+                "fields": {"key": "Hackathon/a/m/up9.csv", "policy": "p", "x-amz-signature": "s"},
+                "key": "Hackathon/a/m/up9.csv",
+            },
+            "model_pkl": None,
+            "expires_in": 900,
+        },
+    )
+    # The direct-to-S3 POST goes to the CDN host (204 = S3 success).
+    httpx_mock.add_response(method="POST", url="http://cdn.test/", status_code=204)
+    httpx_mock.add_response(
+        method="POST",
+        url=_COMPLETE_URL,
+        status_code=202,
+        json={"upload_id": "up9", "status": "pending", "poll_url": "/api/v1/diagnostics/runs/up9"},
+    )
+    result = api.submit_validation_diagnostics(model_id="m1", predictions=preds_file)
+    assert result["upload_id"] == "up9"
+    # The big file went to the CDN, never multipart to the API.
+    cdn_body = httpx_mock.get_request(url="http://cdn.test/").content.decode("latin-1")
+    assert 'name="file"' in cdn_body
+    assert 'name="key"' in cdn_body  # presigned form field present
+    # complete carried the upload_id, not the file bytes.
+    import json as _json
+
+    complete_body = _json.loads(httpx_mock.get_request(url=_COMPLETE_URL).content)
+    assert complete_body["upload_id"] == "up9"
+
+
+def test_submit_presigned_uploads_pkl_when_present(api, httpx_mock, preds_file):
+    httpx_mock.add_response(
+        method="POST",
+        url=_PRESIGN_URL,
+        json={
+            "available": True,
+            "upload_id": "up10",
+            "model_id": "m1",
+            "cdn_base": "http://cdn.test",
+            "predictions": {
+                "url": "http://cdn.test/",
+                "fields": {"key": "Hackathon/a/m/up10.csv"},
+                "key": "Hackathon/a/m/up10.csv",
+            },
+            "model_pkl": {
+                "url": "http://cdn.test/",
+                "fields": {"key": "uploads/a/m/up10.pkl"},
+                "key": "uploads/a/m/up10.pkl",
+            },
+            "expires_in": 900,
+        },
+    )
+    # Two CDN POSTs: predictions + pkl.
+    httpx_mock.add_response(method="POST", url="http://cdn.test/", status_code=204)
+    httpx_mock.add_response(method="POST", url="http://cdn.test/", status_code=204)
+    httpx_mock.add_response(
+        method="POST",
+        url=_COMPLETE_URL,
+        status_code=202,
+        json={"upload_id": "up10", "status": "pending"},
+    )
+    result = api.submit_validation_diagnostics(
+        model_id="m1", predictions=preds_file, model_pkl=b"\x80\x05fakepkl."
+    )
+    assert result["upload_id"] == "up10"
+    cdn_posts = [r for r in httpx_mock.get_requests() if str(r.url) == "http://cdn.test/"]
+    assert len(cdn_posts) == 2
+
+
 def test_leaderboard_window_and_offset_params(api, httpx_mock):
     httpx_mock.add_response(
         method="GET",

{everestapi-0.3.2 → everestapi-0.3.6}/tests/test_eve1087_cpu_tier.py

@@ -17,4 +17,4 @@ def test_train_gpu_enum_includes_cpu():
 
 
 def test_version_bumped():
-    assert everestapi.__version__ == "0.3.2"
+    assert everestapi.__version__ == "0.3.6"

{everestapi-0.3.2 → everestapi-0.3.6}/tests/test_eve959_toolsets.py

@@ -32,6 +32,23 @@ def test_toolset_coverage_both_directions():
     assert len(grouped) == len(grouped_set), "a tool name appears in more than one toolset"
 
 
+def test_job_lifecycle_tools_are_core():
+    """Regression: the hosted-train lifecycle tools must be discoverable in the
+    DEFAULT toolset. train's own description points the caller at get_job_status/
+    get_job_log/get_model_download_url/get_job_predictions_url, so hiding them in
+    a non-default group made hosted training an unfinishable dead end — the very
+    gap that the everestapi package lagged eiq-platform (EVE-1145) on."""
+    core = S.TOOLSETS["core"]
+    for name in (
+        "get_job_status",
+        "get_job_log",
+        "list_compute_jobs",
+        "get_model_download_url",
+        "get_job_predictions_url",
+    ):
+        assert name in core, f"{name} must be in core (default toolset) to finish a train job"
+
+
 def test_default_advertises_core_only(monkeypatch):
     monkeypatch.delenv("EIQ_MCP_TOOLSETS", raising=False)
     assert S._enabled_tool_names() == set(S.TOOLSETS["core"])

{everestapi-0.3.2 → everestapi-0.3.6}/tests/test_mcp_and_models.py

@@ -79,16 +79,16 @@ def test_get_models(httpx_mock, api):
 # via the futures endpoint, EVE-931 — see test_client.py).
 def test_download_dataset_uses_versioned_route(httpx_mock, api, tmp_path):
     httpx_mock.add_response(
-        url="http://test/api/v1/data/download/bregen/equities/train",
+        url="http://test/api/v1/data/download/test-version/equities/train",
         content=b"PAR1data",
     )
     out = api.download_dataset(
         universe="equities",
         split="train",
-        version="bregen",
+        version="test-version",
         output_path=str(tmp_path / "t.parquet"),
     )
-    assert httpx_mock.get_request().url.path == "/api/v1/data/download/bregen/equities/train"
+    assert httpx_mock.get_request().url.path == "/api/v1/data/download/test-version/equities/train"
     with open(out, "rb") as f:
         assert f.read() == b"PAR1data"
 
@@ -96,10 +96,10 @@ def test_download_dataset_uses_versioned_route(httpx_mock, api, tmp_path):
 def test_download_dataset_latest_resolves_version(httpx_mock, api, tmp_path):
     httpx_mock.add_response(
         url="http://test/api/v1/data/versions",
-        json={"versions": [{"version": "bregen", "universes": ["equities"]}]},
+        json={"versions": [{"version": "test-version", "universes": ["equities"]}]},
     )
     httpx_mock.add_response(
-        url="http://test/api/v1/data/download/bregen/equities/live",
+        url="http://test/api/v1/data/download/test-version/equities/live",
         content=b"PAR1live",
     )
     out = api.download_dataset(
@@ -159,6 +159,14 @@ def test_mcp_tools_include_get_started():
     assert "get_started" in names
 
 
+def test_mcp_instructions_point_at_example_scripts():
+    # The on-connect banner directs agents to the example-scripts repo (mirrors
+    # the eiq-platform hosted server + get_started payload).
+    from everestapi.mcp import server
+
+    assert "https://github.com/everestquant/example-scripts" in server._MCP_INSTRUCTIONS
+
+
 def test_mcp_dispatch_get_started_uses_client(monkeypatch):
     from everestapi.mcp import server
 
@@ -168,7 +176,10 @@ def test_mcp_dispatch_get_started_uses_client(monkeypatch):
 
     monkeypatch.setattr(server, "_client", FakeClient())
     out = json.loads(server._dispatch("get_started", {}))
-    assert out == {"mode": "diagnostics_hackathon"}
+    assert out["mode"] == "diagnostics_hackathon"
+    # EVE-1163: dispatch augments the client payload with the running-interpreter
+    # env so a self-updating agent upgrades the venv the MCP actually runs from.
+    assert "client_env" in out
 
 
 def test_mcp_tools_include_get_status():
@@ -327,7 +338,7 @@ def test_enrich_next_actions_are_result_conditional():
     _, running = server._enrich_result(
         "get_job_status", {"job_id": "j"}, json.dumps({"status": "running"})
     )
-    assert running["next_actions"] == ["get_job_status"]
+    assert running["next_actions"] == ["get_job_status", "get_job_log"]
     _, done = server._enrich_result(
         "get_job_status", {"job_id": "j"}, json.dumps({"status": "completed"})
     )