tests:added tests for migration

Signed-off-by: Omswastik-11 <omswastikpanda11@gmail.com>

Author: Omswastik-11

openml/_api/resources/base/resources.py

@@ -54,9 +54,3 @@ def list(
         tag: str | None = None,
         uploader: str | None = None,
     ) -> pd.DataFrame: ...
-
-    @abstractmethod
-    def publish(self, flow: OpenMLFlow) -> OpenMLFlow | tuple[OpenMLFlow, Response]: ...  # type: ignore[override]
-
-    @abstractmethod
-    def delete(self, flow_id: int) -> bool: ...

openml/_api/resources/flows.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
 from typing import Any
 
 import pandas as pd
@@ -135,49 +136,21 @@ def list(
 
         return pd.DataFrame.from_dict(flows, orient="index")
 
-    def publish(self, flow: OpenMLFlow) -> OpenMLFlow:  # type: ignore[override]
-        """Create a new flow on the OpenML server.
-
-        under development , not fully functional yet
+    def publish(self, path: str | None = None, files: Mapping[str, Any] | None = None) -> int:
+        """Publish a flow on the OpenML server.
 
         Parameters
         ----------
-        flow : OpenMLFlow
-            The flow object to upload to the server.
+        files : Mapping[str, Any] | None
+            Files to upload (including description).
 
         Returns
         -------
-        OpenMLFlow
-            The updated flow object with the server-assigned flow_id.
+        int
+            The server-assigned flow id.
         """
-        from openml.extensions import Extension
-
-        # Check if flow is an OpenMLFlow or a compatible extension object
-        if not isinstance(flow, OpenMLFlow) and not isinstance(flow, Extension):
-            raise TypeError(f"Flow must be an OpenMLFlow or Extension instance, got {type(flow)}")
-
-        # Get file elements for upload (includes XML description if not provided)
-        file_elements = flow._get_file_elements()
-        if "description" not in file_elements:
-            file_elements["description"] = flow._to_xml()
-
-        # POST to server (multipart/files). Ensure api_key is sent in the form data.
-        files = file_elements
-        data = {"api_key": self._http.api_key}
-        response = self._http.post("flow", files=files, data=data)
-
-        parsed = xmltodict.parse(response.text)
-        if "oml:error" in parsed:
-            err = parsed["oml:error"]
-            code = int(err.get("oml:code", 0)) if "oml:code" in err else None
-            message = err.get("oml:message", "Server returned an error")
-            raise OpenMLServerException(message=message, code=code)
-
-        # Parse response and update flow with server-assigned ID
-        xml_response = xmltodict.parse(response.text)
-        flow._parse_publish_response(xml_response)
-
-        return flow
+        path = "flow"
+        return super().publish(path, files)
 
     def delete(self, flow_id: int) -> bool:
         """Delete a flow from the OpenML server.
@@ -187,8 +160,7 @@ def delete(self, flow_id: int) -> bool:
         flow_id : int
             The ID of the flow to delete.
         """
-        self._http.delete(f"flow/{flow_id}")
-        return True
+        return super().delete(flow_id)
 
 
 class FlowsV2(ResourceV2, FlowsAPI):

openml/_api/runtime/core.py

@@ -16,8 +16,7 @@
 )
 
 if TYPE_CHECKING:
-    from openml._api.resources.base import DatasetsAPI, FlowsAPI, ResourceAPI, TasksAPI
-    from openml.base import OpenMLBase
+    from openml._api.resources.base import DatasetsAPI, FlowsAPI, TasksAPI
 
 
 class APIBackend:
@@ -32,25 +31,6 @@ def __init__(
         self.tasks = tasks
         self.flows = flows
 
-    def get_resource_for_entity(self, entity: OpenMLBase) -> ResourceAPI:
-        from openml.datasets.dataset import OpenMLDataset
-        from openml.flows.flow import OpenMLFlow
-        from openml.runs.run import OpenMLRun
-        from openml.study.study import OpenMLStudy
-        from openml.tasks.task import OpenMLTask
-
-        if isinstance(entity, OpenMLFlow):
-            return self.flows  # type: ignore
-        if isinstance(entity, OpenMLRun):
-            return self.runs  # type: ignore
-        if isinstance(entity, OpenMLDataset):
-            return self.datasets  # type: ignore
-        if isinstance(entity, OpenMLTask):
-            return self.tasks  # type: ignore
-        if isinstance(entity, OpenMLStudy):
-            return self.studies  # type: ignore
-        raise ValueError(f"No resource manager available for entity type {type(entity)}")
-
 
 def build_backend(version: str, *, strict: bool) -> APIBackend:
     http_cache = HTTPCache(

openml/base.py

@@ -11,7 +11,7 @@
 import openml._api_calls
 import openml.config
 
-from .utils import _tag_openml_base
+from .utils import _get_rest_api_type_alias, _tag_openml_base
 
 
 class OpenMLBase(ABC):
@@ -126,19 +126,20 @@ def _parse_publish_response(self, xml_response: dict[str, str]) -> None:
 
     def publish(self) -> OpenMLBase:
         """Publish the object on the OpenML server."""
-        from openml._api import api_context
+        file_elements = self._get_file_elements()
 
-        resource_manager = api_context.backend.get_resource_for_entity(self)
+        if "description" not in file_elements:
+            file_elements["description"] = self._to_xml()
 
-        published_entity = resource_manager.publish(self)  # type: ignore
-
-        if (
-            published_entity is not None
-            and hasattr(published_entity, "id")
-            and published_entity.id is not None
-        ):
-            self.id = published_entity.id  # type: ignore
+        call = f"{_get_rest_api_type_alias(self)}/"
+        response_text = openml._api_calls._perform_api_call(
+            call,
+            "post",
+            file_elements=file_elements,
+        )
+        xml_response = xmltodict.parse(response_text)
 
+        self._parse_publish_response(xml_response)
         return self
 
     def open_in_browser(self) -> None:

openml/flows/flow.py

@@ -431,16 +431,21 @@ def publish(self, raise_error_if_exists: bool = False) -> OpenMLFlow:  # noqa: F
         # get_flow(), while functions.py tries to import flow.py in order to
         # instantiate an OpenMLFlow.
         import openml.flows.functions
+        from openml._api import api_context
 
         flow_id = openml.flows.functions.flow_exists(self.name, self.external_version)
         if not flow_id:
             if self.flow_id:
                 raise openml.exceptions.PyOpenMLError(
                     "Flow does not exist on the server, but 'flow.flow_id' is not None.",
                 )
-            super().publish()
-            assert self.flow_id is not None  # for mypy
-            flow_id = self.flow_id
+
+            file_elements = self._get_file_elements()
+            if "description" not in file_elements:
+                file_elements["description"] = self._to_xml()
+
+            flow_id = api_context.backend.flows.publish(path="flow", files=file_elements)
+            self.flow_id = flow_id
         elif raise_error_if_exists:
             error_message = f"This OpenMLFlow already exists with id: {flow_id}."
             raise openml.exceptions.PyOpenMLError(error_message)

tests/test_flows/test_flows_migration.py

@@ -2,6 +2,8 @@
 """Tests for Flow V1 → V2 API Migration."""
 from __future__ import annotations
 
+import uuid
+
 import pytest
 
 from openml._api.resources import FallbackProxy, FlowsV1, FlowsV2
@@ -81,37 +83,67 @@ def test_list_with_tag_limit_offset(self):
         if len(flows_df) > 0:
             assert "id" in flows_df.columns
 
-    @pytest.mark.uses_test_server()
-    def test_publish(self):
-        """Test publishing a sklearn flow using V1 API."""
-        from openml_sklearn.extension import SklearnExtension
-        from sklearn.tree import ExtraTreeRegressor
-        clf = ExtraTreeRegressor()
-        extension = SklearnExtension()
-        dt_flow = extension.model_to_flow(clf)
-        published_flow = self.resource.publish(dt_flow)
-        assert isinstance(published_flow, OpenMLFlow)
-        assert getattr(published_flow, "id", None) is not None
-    
     @pytest.mark.uses_test_server()
     def test_delete(self):
         """Test deleting a flow using V1 API."""
         from openml_sklearn.extension import SklearnExtension
         from sklearn.tree import ExtraTreeRegressor
+
         clf = ExtraTreeRegressor()
         extension = SklearnExtension()
         dt_flow = extension.model_to_flow(clf)
+
+        # Check if flow exists, if not publish it
         flow_id = self.resource.exists(
             name=dt_flow.name,
-            external_version=dt_flow.external_version
+            external_version=dt_flow.external_version,
         )
+        
+        if not flow_id:
+            # Publish the flow first
+            file_elements = dt_flow._get_file_elements()
+            if "description" not in file_elements:
+                file_elements["description"] = dt_flow._to_xml()
+            
+            flow_id = self.resource.publish(file_elements)
+        
+        # Now delete it
         result = self.resource.delete(flow_id)
         assert result is True
+
+        # Verify it no longer exists
         exists = self.resource.exists(
             name=dt_flow.name,
-            external_version=dt_flow.external_version
+            external_version=dt_flow.external_version,
         )
         assert exists is False
+    
+    @pytest.mark.uses_test_server()
+    def test_publish(self):
+        """Test publishing a sklearn flow using V1 API."""
+        from openml_sklearn.extension import SklearnExtension
+        from sklearn.tree import ExtraTreeRegressor
+
+        clf = ExtraTreeRegressor()
+        extension = SklearnExtension()
+        dt_flow = extension.model_to_flow(clf)
+
+        # Check if flow already exists
+        flow_id = self.resource.exists(
+            name=dt_flow.name,
+            external_version=dt_flow.external_version,
+        )
+        
+        if not flow_id:
+            file_elements = dt_flow._get_file_elements()
+            if "description" not in file_elements:
+                print("Adding description to flow XML")
+                file_elements["description"] = dt_flow._to_xml()
+                
+            flow_id = self.resource.publish(file_elements)
+
+        assert isinstance(flow_id, int)
+        assert flow_id > 0