Merge branch 'migration' of https://github.com/geetu040/openml-python into flow-migration-stacked

# Conflicts:
#	openml/_api/resources/__init__.py
#	openml/_api/resources/base/__init__.py
#	openml/_api/runtime/core.py

Author: Omswastik-11

openml/_api/clients/http.py

@@ -284,6 +284,7 @@ def _request(  # noqa: PLR0913
         method: str,
         url: str,
         params: Mapping[str, Any],
+        data: Mapping[str, Any],
         headers: Mapping[str, str],
         timeout: float | int,
         files: Mapping[str, Any] | None,
@@ -297,6 +298,7 @@ def _request(  # noqa: PLR0913
                 method=method,
                 url=url,
                 params=params,
+                data=data,
                 headers=headers,
                 timeout=timeout,
                 files=files,
@@ -331,20 +333,23 @@ def request(
         url = urljoin(self.server, urljoin(self.base_url, path))
         retries = max(1, self.retries)
 
-        # prepare params
         params = request_kwargs.pop("params", {}).copy()
+        data = request_kwargs.pop("data", {}).copy()
+
         if use_api_key:
             params["api_key"] = self.api_key
 
+        if method.upper() in {"POST", "PUT", "PATCH"}:
+            data = {**params, **data}
+            params = {}
+
         # prepare headers
         headers = request_kwargs.pop("headers", {}).copy()
         headers.update(self.headers)
 
         timeout = request_kwargs.pop("timeout", self.timeout)
         files = request_kwargs.pop("files", None)
 
-        use_cache = False
-
         if use_cache and self.cache is not None:
             cache_key = self.cache.get_key(url, params)
             try:
@@ -359,6 +364,7 @@ def request(
                 method=method,
                 url=url,
                 params=params,
+                data=data,
                 headers=headers,
                 timeout=timeout,
                 files=files,

openml/_api/resources/__init__.py

@@ -1,10 +1,12 @@
+from openml._api.resources.base.fallback import FallbackProxy
 from openml._api.resources.datasets import DatasetsV1, DatasetsV2
 from openml._api.resources.flows import FlowsV1, FlowsV2
 from openml._api.resources.tasks import TasksV1, TasksV2
 
 __all__ = [
     "DatasetsV1",
     "DatasetsV2",
+    "FallbackProxy",
     "FlowsV1",
     "FlowsV2",
     "TasksV1",

openml/_api/resources/base/__init__.py

@@ -1,10 +1,12 @@
 from openml._api.resources.base.base import APIVersion, ResourceAPI, ResourceType
+from openml._api.resources.base.fallback import FallbackProxy
 from openml._api.resources.base.resources import DatasetsAPI, FlowsAPI, TasksAPI
 from openml._api.resources.base.versions import ResourceV1, ResourceV2
 
 __all__ = [
     "APIVersion",
     "DatasetsAPI",
+    "FallbackProxy",
     "FlowsAPI",
     "ResourceAPI",
     "ResourceType",

openml/_api/resources/base/base.py

@@ -5,6 +5,9 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from typing import Any
+
     from openml._api.clients import HTTPClient
 
 
@@ -34,6 +37,18 @@ class ResourceAPI(ABC):
     def __init__(self, http: HTTPClient):
         self._http = http
 
+    @abstractmethod
+    def delete(self, resource_id: int) -> bool: ...
+
+    @abstractmethod
+    def publish(self, path: str, files: Mapping[str, Any] | None) -> int: ...
+
+    @abstractmethod
+    def tag(self, resource_id: int, tag: str) -> list[str]: ...
+
+    @abstractmethod
+    def untag(self, resource_id: int, tag: str) -> list[str]: ...
+
     def _get_not_implemented_message(self, method_name: str | None = None) -> str:
         version = getattr(self.api_version, "name", "Unknown version")
         resource = getattr(self.resource_type, "name", "Unknown resource")
@@ -42,9 +57,3 @@ def _get_not_implemented_message(self, method_name: str | None = None) -> str:
             f"{self.__class__.__name__}: {version} API does not support this "
             f"functionality for resource: {resource}.{method_info}"
         )
-
-    @abstractmethod
-    def delete(self, resource_id: int) -> bool: ...
-
-    @abstractmethod
-    def publish(self) -> None: ...

openml/_api/resources/base/fallback.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+
+class FallbackProxy:
+    def __init__(self, *api_versions: Any):
+        if not api_versions:
+            raise ValueError("At least one API version must be provided")
+        self._apis = api_versions
+
+    def __getattr__(self, name: str) -> Any:
+        api, attr = self._find_attr(name)
+        if callable(attr):
+            return self._wrap_callable(name, api, attr)
+        return attr
+
+    def _find_attr(self, name: str) -> tuple[Any, Any]:
+        for api in self._apis:
+            attr = getattr(api, name, None)
+            if attr is not None:
+                return api, attr
+        raise AttributeError(f"{self.__class__.__name__} has no attribute {name}")
+
+    def _wrap_callable(
+        self,
+        name: str,
+        primary_api: Any,
+        primary_attr: Callable[..., Any],
+    ) -> Callable[..., Any]:
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return primary_attr(*args, **kwargs)
+            except NotImplementedError:
+                return self._call_fallbacks(name, primary_api, *args, **kwargs)
+
+        return wrapper
+
+    def _call_fallbacks(
+        self,
+        name: str,
+        skip_api: Any,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        for api in self._apis:
+            if api is skip_api:
+                continue
+            attr = getattr(api, name, None)
+            if callable(attr):
+                try:
+                    return attr(*args, **kwargs)
+                except NotImplementedError:
+                    continue
+        raise NotImplementedError(f"Could not fallback to any API for method: {name}")

openml/_api/resources/base/resources.py

@@ -34,6 +34,8 @@ def get(
 
 
 class FlowsAPI(ResourceAPI, ABC):
+    resource_type: ResourceType = ResourceType.FLOW
+
     @abstractmethod
     def get(
         self,

openml/_api/resources/base/versions.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
+from typing import Any
+
 import xmltodict
 
 from openml._api.resources.base import APIVersion, ResourceAPI, ResourceType
@@ -13,71 +16,138 @@
 class ResourceV1(ResourceAPI):
     api_version: APIVersion = APIVersion.V1
 
+    def publish(self, path: str, files: Mapping[str, Any] | None) -> int:
+        response = self._http.post(path, files=files)
+        parsed_response = xmltodict.parse(response.content)
+        return self._extract_id_from_upload(parsed_response)
+
     def delete(self, resource_id: int) -> bool:
-        if self.resource_type == ResourceType.DATASET:
-            resource_type = "data"
-        else:
-            resource_type = self.resource_type.name
-
-        legal_resources = {
-            "data",
-            "flow",
-            "task",
-            "run",
-            "study",
-            "user",
-        }
+        resource_type = self._get_endpoint_name()
+
+        legal_resources = {"data", "flow", "task", "run", "study", "user"}
         if resource_type not in legal_resources:
             raise ValueError(f"Can't delete a {resource_type}")
 
-        url_suffix = f"{resource_type}/{resource_id}"
+        path = f"{resource_type}/{resource_id}"
         try:
-            response = self._http.delete(url_suffix)
+            response = self._http.delete(path)
             result = xmltodict.parse(response.content)
             return f"oml:{resource_type}_delete" in result
         except OpenMLServerException as e:
-            # https://github.com/openml/OpenML/blob/21f6188d08ac24fcd2df06ab94cf421c946971b0/openml_OS/views/pages/api_new/v1/xml/pre.php
-            # Most exceptions are descriptive enough to be raised as their standard
-            # OpenMLServerException, however there are two cases where we add information:
-            #  - a generic "failed" message, we direct them to the right issue board
-            #  - when the user successfully authenticates with the server,
-            #    but user is not allowed to take the requested action,
-            #    in which case we specify a OpenMLNotAuthorizedError.
-            by_other_user = [323, 353, 393, 453, 594]
-            has_dependent_entities = [324, 326, 327, 328, 354, 454, 464, 595]
-            unknown_reason = [325, 355, 394, 455, 593]
-            if e.code in by_other_user:
-                raise OpenMLNotAuthorizedError(
-                    message=(
-                        f"The {resource_type} can not be deleted "
-                        "because it was not uploaded by you."
-                    ),
-                ) from e
-            if e.code in has_dependent_entities:
-                raise OpenMLNotAuthorizedError(
-                    message=(
-                        f"The {resource_type} can not be deleted because "
-                        f"it still has associated entities: {e.message}"
-                    ),
-                ) from e
-            if e.code in unknown_reason:
-                raise OpenMLServerError(
-                    message=(
-                        f"The {resource_type} can not be deleted for unknown reason,"
-                        " please open an issue at: https://github.com/openml/openml/issues/new"
-                    ),
-                ) from e
-            raise e
-
-    def publish(self) -> None:
-        pass
+            self._handle_delete_exception(resource_type, e)
+            raise
+
+    def tag(self, resource_id: int, tag: str) -> list[str]:
+        resource_type = self._get_endpoint_name()
+
+        legal_resources = {"data", "task", "flow", "setup", "run"}
+        if resource_type not in legal_resources:
+            raise ValueError(f"Can't tag a {resource_type}")
+
+        path = f"{resource_type}/tag"
+        data = {f"{resource_type}_id": resource_id, "tag": tag}
+        response = self._http.post(path, data=data)
+
+        main_tag = f"oml:{resource_type}_tag"
+        parsed_response = xmltodict.parse(response.content, force_list={"oml:tag"})
+        result = parsed_response[main_tag]
+        tags: list[str] = result.get("oml:tag", [])
+
+        return tags
+
+    def untag(self, resource_id: int, tag: str) -> list[str]:
+        resource_type = self._get_endpoint_name()
+
+        legal_resources = {"data", "task", "flow", "setup", "run"}
+        if resource_type not in legal_resources:
+            raise ValueError(f"Can't tag a {resource_type}")
+
+        path = f"{resource_type}/untag"
+        data = {f"{resource_type}_id": resource_id, "tag": tag}
+        response = self._http.post(path, data=data)
+
+        main_tag = f"oml:{resource_type}_untag"
+        parsed_response = xmltodict.parse(response.content, force_list={"oml:tag"})
+        result = parsed_response[main_tag]
+        tags: list[str] = result.get("oml:tag", [])
+
+        return tags
+
+    def _get_endpoint_name(self) -> str:
+        if self.resource_type == ResourceType.DATASET:
+            return "data"
+        return self.resource_type.name
+
+    def _handle_delete_exception(
+        self, resource_type: str, exception: OpenMLServerException
+    ) -> None:
+        # https://github.com/openml/OpenML/blob/21f6188d08ac24fcd2df06ab94cf421c946971b0/openml_OS/views/pages/api_new/v1/xml/pre.php
+        # Most exceptions are descriptive enough to be raised as their standard
+        # OpenMLServerException, however there are two cases where we add information:
+        #  - a generic "failed" message, we direct them to the right issue board
+        #  - when the user successfully authenticates with the server,
+        #    but user is not allowed to take the requested action,
+        #    in which case we specify a OpenMLNotAuthorizedError.
+        by_other_user = [323, 353, 393, 453, 594]
+        has_dependent_entities = [324, 326, 327, 328, 354, 454, 464, 595]
+        unknown_reason = [325, 355, 394, 455, 593]
+        if exception.code in by_other_user:
+            raise OpenMLNotAuthorizedError(
+                message=(
+                    f"The {resource_type} can not be deleted because it was not uploaded by you."
+                ),
+            ) from exception
+        if exception.code in has_dependent_entities:
+            raise OpenMLNotAuthorizedError(
+                message=(
+                    f"The {resource_type} can not be deleted because "
+                    f"it still has associated entities: {exception.message}"
+                ),
+            ) from exception
+        if exception.code in unknown_reason:
+            raise OpenMLServerError(
+                message=(
+                    f"The {resource_type} can not be deleted for unknown reason,"
+                    " please open an issue at: https://github.com/openml/openml/issues/new"
+                ),
+            ) from exception
+        raise exception
+
+    def _extract_id_from_upload(self, parsed: Mapping[str, Any]) -> int:
+        # reads id from
+        # sample parsed dict: {"oml:openml": {"oml:upload_flow": {"oml:id": "42"}}}
+
+        # xmltodict always gives exactly one root key
+        ((_, root_value),) = parsed.items()
+
+        if not isinstance(root_value, Mapping):
+            raise ValueError("Unexpected XML structure")
+
+        # upload node (e.g. oml:upload_task, oml:study_upload, ...)
+        ((_, upload_value),) = root_value.items()
+
+        if not isinstance(upload_value, Mapping):
+            raise ValueError("Unexpected upload node structure")
+
+        # ID is the only leaf value
+        for v in upload_value.values():
+            if isinstance(v, (str, int)):
+                return int(v)
+
+        raise ValueError("No ID found in upload response")
 
 
 class ResourceV2(ResourceAPI):
     api_version: APIVersion = APIVersion.V2
 
-    def delete(self, resource_id: int) -> bool:
+    def publish(self, path: str, files: Mapping[str, Any] | None) -> int:
         raise NotImplementedError(self._get_not_implemented_message("publish"))
 
-    def publish(self) -> None:
-        raise NotImplementedError(self._get_not_implemented_message("publish"))
+    def delete(self, resource_id: int) -> bool:
+        raise NotImplementedError(self._get_not_implemented_message("delete"))
+
+    def tag(self, resource_id: int, tag: str) -> list[str]:
+        raise NotImplementedError(self._get_not_implemented_message("untag"))
+
+    def untag(self, resource_id: int, tag: str) -> list[str]:
+        raise NotImplementedError(self._get_not_implemented_message("untag"))