[ENH] V1 -> V2 Migration : Runs

openml/_api/config.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class RetryPolicy(str, Enum):
+    HUMAN = "human"
+    ROBOT = "robot"
+
+
+@dataclass
+class APIConfig:
+    server: str
+    base_url: str
+    api_key: str
+    timeout: int = 10  # seconds
+
+
+@dataclass
+class APISettings:
+    v1: APIConfig
+    v2: APIConfig
+
+
+@dataclass
+class ConnectionConfig:
+    retries: int = 3
+    retry_policy: RetryPolicy = RetryPolicy.HUMAN
+
+
+@dataclass
+class CacheConfig:
+    dir: str = "~/.openml/cache"
+    ttl: int = 60 * 60 * 24 * 7  # one week
+
+
+@dataclass
+class Settings:
+    api: APISettings
+    connection: ConnectionConfig
+    cache: CacheConfig
+
+
+settings = Settings(
+    api=APISettings(
+        v1=APIConfig(
+            server="https://test.openml.org/",
+            base_url="api/v1/xml/",
+            api_key="normaluser",
+        ),
+        v2=APIConfig(
+            server="http://127.0.0.1:8001/",
+            base_url="",
+            api_key="...",
+        ),
+    ),
+    connection=ConnectionConfig(),
+    cache=CacheConfig(),
+)

openml/_api/resources/base/resources.py

@@ -8,7 +8,11 @@
 from .base import ResourceAPI
 
 if TYPE_CHECKING:
+    import pandas as pd
+
     from openml.evaluations import OpenMLEvaluation
+    from openml.runs.run import OpenMLRun
+    from openml.tasks.task import TaskType
 
 
 class DatasetAPI(ResourceAPI):
@@ -75,6 +79,30 @@ 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: ...
+
 
 class SetupAPI(ResourceAPI):
     """Abstract API interface for setup resources."""

openml/_api/resources/base/versions.py

@@ -2,6 +2,7 @@
 
 from collections.abc import Mapping
 from typing import Any, cast
+from xml.parsers.expat import ExpatError
 
 import xmltodict
 
@@ -71,7 +72,7 @@ def publish(self, path: str, files: Mapping[str, Any] | None) -> int:
             If the server returns an error during upload.
         """
         response = self._http.post(path, files=files)
-        parsed_response = xmltodict.parse(response.content)
+        parsed_response = self._parse_xml_response(response.content)
         return self._extract_id_from_upload(parsed_response)
 
     def delete(self, resource_id: int) -> bool:
@@ -106,7 +107,7 @@ def delete(self, resource_id: int) -> bool:
         path = f"{endpoint_name}/{resource_id}"
         try:
             response = self._http.delete(path)
-            result = xmltodict.parse(response.content)
+            result = self._parse_xml_response(response.content)
             return f"oml:{endpoint_name}_delete" in result
         except OpenMLServerException as e:
             self._handle_delete_exception(endpoint_name, e)
@@ -143,7 +144,7 @@ def tag(self, resource_id: int, tag: str) -> list[str]:
         data = {f"{endpoint_name}_id": resource_id, "tag": tag}
         response = self._http.post(path, data=data)
 
-        parsed_response = xmltodict.parse(response.content, force_list={"oml:tag"})
+        parsed_response = self._parse_xml_response(response.content, force_list={"oml:tag"})
         result = parsed_response[f"oml:{endpoint_name}_tag"]
         tags: list[str] = result.get("oml:tag", [])
 
@@ -180,12 +181,28 @@ def untag(self, resource_id: int, tag: str) -> list[str]:
         data = {f"{endpoint_name}_id": resource_id, "tag": tag}
         response = self._http.post(path, data=data)
 
-        parsed_response = xmltodict.parse(response.content, force_list={"oml:tag"})
+        parsed_response = self._parse_xml_response(response.content, force_list={"oml:tag"})
         result = parsed_response[f"oml:{endpoint_name}_untag"]
         tags: list[str] = result.get("oml:tag", [])
 
         return tags
 
+    def _parse_xml_response(self, payload: bytes | str, **kwargs: Any) -> Mapping[str, Any]:
+        try:
+            return cast("Mapping[str, Any]", xmltodict.parse(payload, **kwargs))
+        except ExpatError:
+            payload_text = (
+                payload.decode("utf-8", errors="ignore") if isinstance(payload, bytes) else payload
+            )
+            xml_start = payload_text.find("<?xml")
+            if xml_start == -1:
+                xml_start = payload_text.find("<oml:")
+            if xml_start == -1:
+                raise
+
+            xml_text = payload_text[xml_start:]
+            return cast("Mapping[str, Any]", xmltodict.parse(xml_text, **kwargs))
+
     def _get_endpoint_name(self) -> str:
         if self.resource_type == ResourceType.DATASET:
             return "data"
@@ -220,18 +237,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):