Merge branch 'runs-migration-stacked' of https://github.com/Omswastik-11/openml-python into runs-migration-stacked

Author: Omswastik-11

openml/_api/clients/http.py

@@ -89,6 +89,26 @@ def _key_to_path(self, key: str) -> Path:
         """
         return self.path.joinpath(key)
 
+    def _get_body_filename_from_response(self, response: Response) -> str:
+        content_type = response.headers.get("Content-Type", "").lower()
+
+        if "application/json" in content_type:
+            return "body.json"
+
+        if "text/xml" in content_type:
+            return "body.xml"
+
+        return "body.txt"
+
+    def _get_body_filename_from_path(self, path: Path) -> str:
+        if (path / "body.json").exists():
+            return "body.json"
+
+        if (path / "body.xml").exists():
+            return "body.xml"
+
+        return "body.txt"
+
     def load(self, key: str) -> Response:
         """
         Load a cached HTTP response from disk.
@@ -112,31 +132,26 @@ def load(self, key: str) -> Response:
         """
         path = self._key_to_path(key)
 
-        if not path.exists():
-            raise FileNotFoundError(f"Cache entry not found: {path}")
-
         meta_path = path / "meta.json"
-        headers_path = path / "headers.json"
-        body_path = path / "body.bin"
+        meta_raw = meta_path.read_bytes() if meta_path.exists() else "{}"
+        meta = json.loads(meta_raw)
 
-        if not (meta_path.exists() and headers_path.exists() and body_path.exists()):
-            raise FileNotFoundError(f"Incomplete cache at {path}")
-
-        with meta_path.open("r", encoding="utf-8") as f:
-            meta = json.load(f)
-
-        with headers_path.open("r", encoding="utf-8") as f:
-            headers = json.load(f)
+        headers_path = path / "headers.json"
+        headers_raw = headers_path.read_bytes() if headers_path.exists() else "{}"
+        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()
-        response.status_code = meta["status_code"]
-        response.url = meta["url"]
-        response.reason = meta["reason"]
         response.headers = headers
         response._content = body
-        response.encoding = meta["encoding"]
+        response.status_code = meta.get("status_code")
+        response.url = meta.get("url")
+        response.reason = meta.get("reason")
+        response.encoding = meta.get("encoding")
 
         return response
 
@@ -160,7 +175,9 @@ def save(self, key: str, response: Response) -> None:
         path = self._key_to_path(key)
         path.mkdir(parents=True, exist_ok=True)
 
-        (path / "body.bin").write_bytes(response.content)
+        body_filename = self._get_body_filename_from_response(response)
+        with (path / body_filename).open("wb") as f:
+            f.write(response.content)
 
         with (path / "headers.json").open("w", encoding="utf-8") as f:
             json.dump(dict(response.headers), f)

openml/_api/resources/base/resources.py

@@ -2,6 +2,7 @@
 
 import builtins
 from abc import abstractmethod
+from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any
 
 from openml.enums import ResourceType
@@ -11,8 +12,11 @@
 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
 
 
@@ -33,12 +37,18 @@ class EvaluationMeasureAPI(ResourceAPI):
 
     resource_type: ResourceType = ResourceType.EVALUATION_MEASURE
 
+    @abstractmethod
+    def list(self) -> list[str]: ...
+
 
 class EstimationProcedureAPI(ResourceAPI):
     """Abstract API interface for estimation procedure resources."""
 
     resource_type: ResourceType = ResourceType.ESTIMATION_PROCEDURE
 
+    @abstractmethod
+    def list(self) -> list[OpenMLEstimationProcedure]: ...
+
 
 class EvaluationAPI(ResourceAPI):
     """Abstract API interface for evaluation resources."""
@@ -109,3 +119,24 @@ class SetupAPI(ResourceAPI):
     """Abstract API interface for setup resources."""
 
     resource_type: ResourceType = ResourceType.SETUP
+
+    @abstractmethod
+    def list(
+        self,
+        limit: int,
+        offset: int,
+        *,
+        setup: Iterable[int] | None = None,
+        flow: int | None = None,
+        tag: str | None = None,
+    ) -> list[OpenMLSetup]: ...
+
+    @abstractmethod
+    def get(self, setup_id: int) -> OpenMLSetup: ...
+
+    @abstractmethod
+    def exists(
+        self,
+        flow: OpenMLFlow,
+        param_settings: builtins.list[dict[str, Any]],
+    ) -> int | bool: ...

openml/_api/resources/estimation_procedure.py

@@ -1,11 +1,84 @@
 from __future__ import annotations
 
+import warnings
+
+import xmltodict
+
+from openml.estimation_procedures.estimation_procedure import OpenMLEstimationProcedure
+from openml.tasks.task import TaskType
+
 from .base import EstimationProcedureAPI, ResourceV1API, ResourceV2API
 
 
 class EstimationProcedureV1API(ResourceV1API, EstimationProcedureAPI):
-    """Version 1 API implementation for estimation procedure resources."""
+    """V1 API implementation for estimation procedures.
+
+    Fetches estimation procedures from the v1 XML API endpoint.
+    """
+
+    def list(self) -> list[OpenMLEstimationProcedure]:
+        """Return a list of all estimation procedures which are on OpenML.
+
+        Returns
+        -------
+        procedures : list
+            A list of all estimation procedures. Every procedure is represented by
+            a dictionary containing the following information: id, task type id,
+            name, type, repeats, folds, stratified.
+        """
+        path = "estimationprocedure/list"
+        response = self._http.get(path)
+        xml_content = response.text
+
+        procs_dict = xmltodict.parse(xml_content)
+
+        # Minimalistic check if the XML is useful
+        if "oml:estimationprocedures" not in procs_dict:
+            raise ValueError("Error in return XML, does not contain tag oml:estimationprocedures.")
+
+        if "@xmlns:oml" not in procs_dict["oml:estimationprocedures"]:
+            raise ValueError(
+                "Error in return XML, does not contain tag "
+                "@xmlns:oml as a child of oml:estimationprocedures.",
+            )
+
+        if procs_dict["oml:estimationprocedures"]["@xmlns:oml"] != "http://openml.org/openml":
+            raise ValueError(
+                "Error in return XML, value of "
+                "oml:estimationprocedures/@xmlns:oml is not "
+                "http://openml.org/openml, but {}".format(
+                    str(procs_dict["oml:estimationprocedures"]["@xmlns:oml"])
+                ),
+            )
+
+        procs: list[OpenMLEstimationProcedure] = []
+        for proc_ in procs_dict["oml:estimationprocedures"]["oml:estimationprocedure"]:
+            task_type_int = int(proc_["oml:ttid"])
+            try:
+                task_type_id = TaskType(task_type_int)
+                procs.append(
+                    OpenMLEstimationProcedure(
+                        id=int(proc_["oml:id"]),
+                        task_type_id=task_type_id,
+                        name=proc_["oml:name"],
+                        type=proc_["oml:type"],
+                    )
+                )
+            except ValueError as e:
+                warnings.warn(
+                    f"Could not create task type id for {task_type_int} due to error {e}",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+
+        return procs
 
 
 class EstimationProcedureV2API(ResourceV2API, EstimationProcedureAPI):
-    """Version 2 API implementation for estimation procedure resources."""
+    """V2 API implementation for estimation procedures.
+
+    Fetches estimation procedures from the v2 JSON API endpoint.
+    """
+
+    def list(self) -> list[OpenMLEstimationProcedure]:
+        self._not_supported(method="list")

openml/_api/resources/evaluation_measure.py

@@ -1,11 +1,60 @@
 from __future__ import annotations
 
+import xmltodict
+
 from .base import EvaluationMeasureAPI, ResourceV1API, ResourceV2API
 
 
 class EvaluationMeasureV1API(ResourceV1API, EvaluationMeasureAPI):
-    """Version 1 API implementation for evaluation measure resources."""
+    """V1 API implementation for evaluation measures.
+
+    Fetches evaluation measures from the v1 XML API endpoint.
+    """
+
+    def list(self) -> list[str]:
+        """List all evaluation measures available on OpenML.
+
+        Returns
+        -------
+        list[str]
+            A list of evaluation measure names.
+        """
+        path = "evaluationmeasure/list"
+        response = self._http.get(path)
+        xml_content = response.text
+
+        qualities = xmltodict.parse(xml_content, force_list=("oml:measures"))
+        # Minimalistic check if the XML is useful
+        if "oml:evaluation_measures" not in qualities:
+            raise ValueError('Error in return XML, does not contain "oml:evaluation_measures"')
+
+        if not isinstance(
+            qualities["oml:evaluation_measures"]["oml:measures"][0]["oml:measure"], list
+        ):
+            raise TypeError('Error in return XML, does not contain "oml:measure" as a list')
+
+        return qualities["oml:evaluation_measures"]["oml:measures"][0]["oml:measure"]
 
 
 class EvaluationMeasureV2API(ResourceV2API, EvaluationMeasureAPI):
-    """Version 2 API implementation for evaluation measure resources."""
+    """V2 API implementation for evaluation measures.
+
+    Fetches evaluation measures from the v2 JSON API endpoint.
+    """
+
+    def list(self) -> list[str]:
+        """List all evaluation measures available on OpenML.
+
+        Returns
+        -------
+        list[str]
+            A list of evaluation measure names.
+        """
+        path = "evaluationmeasure/list"
+        response = self._http.get(path)
+        data = response.json()
+
+        if not isinstance(data, list):
+            raise ValueError(f"Expected list, got {type(data)}")
+
+        return data