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

Author: Omswastik-11

openml/_api/clients/http.py

@@ -50,8 +50,8 @@ def get_key(self, url: str, params: dict[str, Any]) -> str:
         """
         Generate a filesystem-safe cache key for a request.
 
-        The key is constructed from the reversed domain components, URL path
-        segments, and URL-encoded query parameters (excluding ``api_key``).
+        The key is constructed from URL path segments and
+        URL-encoded query parameters (excluding ``api_key``).
 
         Parameters
         ----------
@@ -66,13 +66,12 @@ def get_key(self, url: str, params: dict[str, Any]) -> str:
             A relative path string representing the cache key.
         """
         parsed_url = urlparse(url)
-        netloc_parts = parsed_url.netloc.split(".")[::-1]
         path_parts = parsed_url.path.strip("/").split("/")
 
         filtered_params = {k: v for k, v in params.items() if k != "api_key"}
         params_part = [urlencode(filtered_params)] if filtered_params else []
 
-        return str(Path(*netloc_parts, *path_parts, *params_part))
+        return str(Path(*path_parts, *params_part))
 
     def _key_to_path(self, key: str) -> Path:
         """

openml/_config.py

@@ -19,7 +19,7 @@
 from typing import Any, ClassVar, Literal, cast
 from urllib.parse import urlparse
 
-from openml.enums import APIVersion
+from openml.enums import APIVersion, ServerMode
 
 from .__version__ import __version__
 
@@ -56,23 +56,21 @@
     },
     APIVersion.V2: {
         "server": "http://localhost:8082/",
-        "apikey": "AD000000000000000000000000000000",
+        "apikey": "normaluser",
     },
 }
 
-_SERVERS_REGISTRY: dict[str, dict[APIVersion, dict[str, str | None]]] = {
-    "production": _PROD_SERVERS,
-    "test": _TEST_SERVERS_LOCAL
-    if os.getenv("OPENML_USE_LOCAL_SERVICES") == "true"
-    else _TEST_SERVERS,
+_SERVERS_REGISTRY: dict[ServerMode, dict[APIVersion, dict[str, str | None]]] = {
+    ServerMode.PRODUCTION: _PROD_SERVERS,
+    ServerMode.TEST: (
+        _TEST_SERVERS_LOCAL if os.getenv("OPENML_USE_LOCAL_SERVICES") == "true" else _TEST_SERVERS
+    ),
 }
 
 
-def _get_servers(mode: str) -> dict[APIVersion, dict[str, str | None]]:
-    if mode not in _SERVERS_REGISTRY:
-        raise ValueError(
-            f'invalid mode="{mode}" allowed modes: {", ".join(list(_SERVERS_REGISTRY.keys()))}'
-        )
+def _get_servers(mode: ServerMode) -> dict[APIVersion, dict[str, str | None]]:
+    if mode not in ServerMode:
+        raise ValueError(f'invalid mode="{mode}" allowed modes: {", ".join(list(ServerMode))}')
     return deepcopy(_SERVERS_REGISTRY[mode])
 
 
@@ -112,7 +110,7 @@ class OpenMLConfig:
     """Dataclass storing the OpenML configuration."""
 
     servers: dict[APIVersion, dict[str, str | None]] = field(
-        default_factory=lambda: _get_servers("production")
+        default_factory=lambda: _get_servers(ServerMode.PRODUCTION)
     )
     api_version: APIVersion = APIVersion.V1
     fallback_api_version: APIVersion | None = None
@@ -266,24 +264,24 @@ def get_server_base_url(self) -> str:
         domain, _ = self._config.server.split("/api", maxsplit=1)
         return domain.replace("api", "www")
 
-    def _get_servers(self, mode: str) -> dict[APIVersion, dict[str, str | None]]:
+    def _get_servers(self, mode: ServerMode) -> dict[APIVersion, dict[str, str | None]]:
         return _get_servers(mode)
 
-    def _set_servers(self, mode: str) -> None:
+    def _set_servers(self, mode: ServerMode) -> None:
         servers = self._get_servers(mode)
         self._config = replace(self._config, servers=servers)
 
     def get_production_servers(self) -> dict[APIVersion, dict[str, str | None]]:
-        return self._get_servers(mode="production")
+        return self._get_servers(mode=ServerMode.PRODUCTION)
 
     def get_test_servers(self) -> dict[APIVersion, dict[str, str | None]]:
-        return self._get_servers(mode="test")
+        return self._get_servers(mode=ServerMode.TEST)
 
     def use_production_servers(self) -> None:
-        self._set_servers(mode="production")
+        self._set_servers(mode=ServerMode.PRODUCTION)
 
     def use_test_servers(self) -> None:
-        self._set_servers(mode="test")
+        self._set_servers(mode=ServerMode.TEST)
 
     def set_api_version(
         self,

openml/enums.py

@@ -3,6 +3,13 @@
 from enum import Enum
 
 
+class ServerMode(str, Enum):
+    """Supported modes in server."""
+
+    PRODUCTION = "production"
+    TEST = "test"
+
+
 class APIVersion(str, Enum):
     """Supported OpenML API versions."""
 

tests/test_api/test_http.py

@@ -42,22 +42,30 @@ def sample_download_url_v1(test_server_v1) -> str:
 def test_cache(cache, sample_url_v1):
     params = {"param1": "value1", "param2": "value2"}
 
+    # validate key
+
     parsed_url = urlparse(sample_url_v1)
-    netloc_parts = parsed_url.netloc.split(".")[::-1]
     path_parts = parsed_url.path.strip("/").split("/")
     params_key = "&".join([f"{k}={v}" for k, v in params.items()])
 
-
     key = cache.get_key(sample_url_v1, params)
 
     expected_key = os.path.join(
-        *netloc_parts,
         *path_parts,
         params_key,
     )
 
     assert key == expected_key
 
+    # validate path
+
+    path = cache._key_to_path(key)
+    expected_path = Path(openml.config.get_cache_directory()).joinpath(key)
+
+    assert path == expected_path
+
+    # validate save/load
+
     # mock response
     req = Request("GET", sample_url_v1).prepare()
     response = Response()

tests/test_openml/test_config.py

@@ -16,7 +16,7 @@
 import openml
 import openml.testing
 from openml.testing import TestBase
-from openml.enums import APIVersion
+from openml.enums import APIVersion, ServerMode
 
 
 @contextmanager
@@ -193,7 +193,7 @@ def test_openml_cache_dir_env_var(tmp_path: Path) -> None:
         assert openml.config.get_cache_directory() == str(expected_path / "org" / "openml" / "www")
 
 
-@pytest.mark.parametrize("mode", ["production", "test"])
+@pytest.mark.parametrize("mode", list(ServerMode))
 @pytest.mark.parametrize("api_version", [APIVersion.V1, APIVersion.V2])
 def test_get_servers(mode, api_version):
     orig_servers = openml.config._get_servers(mode)
@@ -208,7 +208,7 @@ def test_get_servers(mode, api_version):
     assert openml.config._get_servers(mode) == orig_servers
 
 
-@pytest.mark.parametrize("mode", ["production", "test"])
+@pytest.mark.parametrize("mode", list(ServerMode))
 @pytest.mark.parametrize("api_version", [APIVersion.V1, APIVersion.V2])
 def test_set_servers(mode, api_version):
     openml.config._set_servers(mode)