[ENH] V1 -> V2 Migration : Runs

openml/_api/clients/http.py

@@ -12,6 +12,7 @@
 from typing import Any, cast
 from urllib.parse import urlencode, urljoin, urlparse
 
+import arff
 import requests
 import xmltodict
 from requests import Response
@@ -98,16 +99,32 @@ def _get_body_filename_from_response(self, response: Response) -> str:
         if "text/xml" in content_type:
             return "body.xml"
 
+        if response.content.startswith(b"PK\x03\x04"):
+            return "body.zip"
+
+        try:
+            arff.loads(response.text)
+            return "body.arff"
+        except arff.ArffException:
+            pass
+
         return "body.txt"
 
     def _get_body_filename_from_path(self, path: Path) -> str:
-        if (path / "body.json").exists():
-            return "body.json"
+        candidates = []
+        for p in path.iterdir():
+            if p.name.startswith("body.") and len(p.suffixes) == 1:
+                candidates.append(p)
 
-        if (path / "body.xml").exists():
-            return "body.xml"
+        if not candidates:
+            raise FileNotFoundError(f"No body file found in path: {path}")
 
-        return "body.txt"
+        if len(candidates) > 1:
+            raise FileNotFoundError(
+                f"Multiple body files found in path: {path} ({[p.name for p in candidates]})"
+            )
+
+        return candidates[0].name
 
     def load(self, key: str) -> Response:
         """
@@ -132,6 +149,9 @@ def load(self, key: str) -> Response:
         """
         path = self._key_to_path(key)
 
+        if not path.exists():
+            raise FileNotFoundError(f"Cache path not found: {path}")
+
         meta_path = path / "meta.json"
         meta_raw = meta_path.read_bytes() if meta_path.exists() else "{}"
         meta = json.loads(meta_raw)
@@ -141,8 +161,6 @@ def load(self, key: str) -> Response:
         headers = json.loads(headers_raw)
 
         body_path = path / self._get_body_filename_from_path(path)
-        if not body_path.exists():
-            raise FileNotFoundError(f"Incomplete cache at {body_path}")
         body = body_path.read_bytes()
 
         response = Response()
@@ -825,3 +843,9 @@ def write_to_file(response: Response, path: Path, encoding: str) -> None:
         handler = handler or write_to_file
         handler(response, file_path, encoding)
         return file_path
+
+    def cache_path_from_url(self, url: str) -> Path:
+        full_url = urljoin(self.server, url)
+        key = self.cache.get_key(full_url, params={})
+        path = self.cache._key_to_path(key)
+        return path / self.cache._get_body_filename_from_path(path)

openml/_api/resources/base/resources.py

@@ -10,10 +10,14 @@
 from .base import ResourceAPI
 
 if TYPE_CHECKING:
+    import pandas as pd
+
     from openml.estimation_procedures import OpenMLEstimationProcedure
     from openml.evaluations import OpenMLEvaluation
     from openml.flows.flow import OpenMLFlow
+    from openml.runs.run import OpenMLRun
     from openml.setups.setup import OpenMLSetup
+    from openml.tasks.task import TaskType
 
 
 class DatasetAPI(ResourceAPI):
@@ -86,6 +90,45 @@ class RunAPI(ResourceAPI):
 
     resource_type: ResourceType = ResourceType.RUN
 
+    @abstractmethod
+    def get(
+        self,
+        run_id: int,
+        *,
+        reset_cache: bool = False,
+    ) -> OpenMLRun: ...
+
+    def list(  # type: ignore[valid-type]  # noqa: PLR0913
+        self,
+        limit: int,
+        offset: int,
+        *,
+        ids: builtins.list[int] | None = None,
+        task: builtins.list[int] | None = None,
+        setup: builtins.list[int] | None = None,
+        flow: builtins.list[int] | None = None,
+        uploader: builtins.list[int] | None = None,
+        study: int | None = None,
+        tag: str | None = None,
+        display_errors: bool = False,
+        task_type: TaskType | int | None = None,
+    ) -> pd.DataFrame: ...
+
+    @abstractmethod
+    def download_text_file(
+        self,
+        source: str,
+        *,
+        md5_checksum: str | None = None,
+    ) -> str: ...
+
+    @abstractmethod
+    def file_id_to_url(
+        self,
+        file_id: int,
+        filename: str | None = None,
+    ) -> str: ...
+
 
 class SetupAPI(ResourceAPI):
     """Abstract API interface for setup resources."""

openml/_api/resources/base/versions.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from typing import Any, cast
+from typing import Any
 
 import xmltodict
 
@@ -189,7 +189,10 @@ def untag(self, resource_id: int, tag: str) -> list[str]:
     def _get_endpoint_name(self) -> str:
         if self.resource_type == ResourceType.DATASET:
             return "data"
-        return cast("str", self.resource_type.value)
+        endpoint_name = self.resource_type.value
+        if not isinstance(endpoint_name, str):
+            raise TypeError(f"Unexpected endpoint type: {type(endpoint_name)}")
+        return endpoint_name
 
     def _extract_id_from_upload(self, parsed: Mapping[str, Any]) -> int:
         """
@@ -220,18 +223,23 @@ def _extract_id_from_upload(self, parsed: Mapping[str, Any]) -> int:
         if not isinstance(root_value, Mapping):
             raise ValueError("Unexpected XML structure")
 
-        # Look for oml:id directly in the root value
-        if "oml:id" in root_value:
-            id_value = root_value["oml:id"]
-            if isinstance(id_value, (str, int)):
-                return int(id_value)
+        # 1. Specifically look for keys ending in _id or id (e.g., oml:id, oml:run_id)
+        for k, v in root_value.items():
+            if (
+                (k.endswith(("id", "_id")) or "id" in k.lower())
+                and isinstance(v, (str, int))
+                and str(v).isdigit()
+            ):
+                return int(v)
 
-        # Fallback: check all values for numeric/string IDs
+        # 2. Fallback: check all values for numeric/string IDs, excluding xmlns or URLs
         for v in root_value.values():
             if isinstance(v, (str, int)):
-                return int(v)
+                val_str = str(v)
+                if val_str.isdigit():
+                    return int(val_str)
 
-        raise ValueError("No ID found in upload response")
+        raise ValueError(f"No ID found in upload response: {root_value}")
 
 
 class ResourceV2API(ResourceAPI):
@@ -258,4 +266,7 @@ def untag(self, resource_id: int, tag: str) -> list[str]:  # noqa: ARG002
         self._not_supported(method="untag")
 
     def _get_endpoint_name(self) -> str:
-        return cast("str", self.resource_type.value)
+        endpoint_name = self.resource_type.value
+        if not isinstance(endpoint_name, str):
+            raise TypeError(f"Unexpected endpoint type: {type(endpoint_name)}")
+        return endpoint_name