update _config.py

Author: geetu040

openml/_api/clients/http.py

@@ -212,21 +212,21 @@ def __init__(
 
     @property
     def server(self) -> str:
-        server = openml.config.SERVERS[self.api_version]["server"]
+        server = openml.config.servers[self.api_version]["server"]
         if server is None:
+            servers_repr = {k.value: v for k, v in openml.config.servers}
             raise ValueError(
-                f"server found to be None for api_version={self.api_version}"
-                f" in {openml.config.SERVERS}"
+                f'server found to be None for api_version="{self.api_version}" in {servers_repr}'
             )
-        return server
+        return cast("str", server)
 
     @property
     def api_key(self) -> str | None:
-        return openml.config.SERVERS[self.api_version]["apikey"]
+        return cast("str | None", openml.config.SERVERS[self.api_version]["apikey"])
 
     @property
     def retries(self) -> int:
-        return openml.config.connection_n_retries
+        return cast("int", openml.config.connection_n_retries)
 
     @property
     def retry_policy(self) -> RetryPolicy:

openml/_config.py

@@ -18,10 +18,46 @@
 from typing import Any, ClassVar, Literal, cast
 from urllib.parse import urlparse
 
+from openml.enums import APIVersion
+
 logger = logging.getLogger(__name__)
 openml_logger = logging.getLogger("openml")
 
 
+SERVERS_REGISTRY: dict[str, dict[APIVersion, dict[str, str | None]]] = {
+    "production": {
+        APIVersion.V1: {
+            "server": "https://www.openml.org/api/v1/xml/",
+            "apikey": None,
+        },
+        APIVersion.V2: {
+            "server": None,
+            "apikey": None,
+        },
+    },
+    "test": {
+        APIVersion.V1: {
+            "server": "https://test.openml.org/api/v1/xml/",
+            "apikey": "normaluser",
+        },
+        APIVersion.V2: {
+            "server": None,
+            "apikey": None,
+        },
+    },
+    "local": {
+        APIVersion.V1: {
+            "server": "http://localhost:8000/api/v1/xml/",
+            "apikey": "normaluser",
+        },
+        APIVersion.V2: {
+            "server": "http://localhost:8002/api/v1/xml/",
+            "apikey": "normaluser",
+        },
+    },
+}
+
+
 def _resolve_default_cache_dir() -> Path:
     user_defined_cache_dir = os.environ.get("OPENML_CACHE_DIR")
     if user_defined_cache_dir is not None:
@@ -57,19 +93,38 @@ def _resolve_default_cache_dir() -> Path:
 class OpenMLConfig:
     """Dataclass storing the OpenML configuration."""
 
-    apikey: str | None = ""
-    server: str = "https://www.openml.org/api/v1/xml"
+    servers: dict[APIVersion, dict[str, str | None]] = field(
+        default_factory=lambda: SERVERS_REGISTRY["production"]
+    )
+    api_version: APIVersion = APIVersion.V1
+    fallback_api_version: APIVersion | None = None
     cachedir: Path = field(default_factory=_resolve_default_cache_dir)
     avoid_duplicate_runs: bool = False
     retry_policy: Literal["human", "robot"] = "human"
     connection_n_retries: int = 5
     show_progress: bool = False
 
-    def __setattr__(self, name: str, value: Any) -> None:
-        if name == "apikey" and value is not None and not isinstance(value, str):
-            raise ValueError("apikey must be a string or None")
+    @property
+    def server(self) -> str:
+        server = self.servers[self.api_version]["server"]
+        if server is None:
+            servers_repr = {k.value: v for k, v in self.servers.items()}
+            raise ValueError(
+                f'server found to be None for api_version="{self.api_version}" in {servers_repr}'
+            )
+        return server
+
+    @server.setter
+    def server(self, value: str | None) -> None:
+        self.servers[self.api_version]["server"] = value
+
+    @property
+    def apikey(self) -> str | None:
+        return self.servers[self.api_version]["apikey"]
 
-        super().__setattr__(name, value)
+    @apikey.setter
+    def apikey(self, value: str | None) -> None:
+        self.servers[self.api_version]["apikey"] = value
 
 
 class OpenMLConfigManager:
@@ -79,11 +134,14 @@ def __init__(self) -> None:
         self.console_handler: logging.StreamHandler | None = None
         self.file_handler: logging.handlers.RotatingFileHandler | None = None
 
+        server_test_v1_apikey = SERVERS_REGISTRY["test"][APIVersion.V1]["apikey"]
+        server_test_v1_server = SERVERS_REGISTRY["test"][APIVersion.V1]["server"]
+
         self.OPENML_CACHE_DIR_ENV_VAR = "OPENML_CACHE_DIR"
         self.OPENML_SKIP_PARQUET_ENV_VAR = "OPENML_SKIP_PARQUET"
-        self._TEST_SERVER_NORMAL_USER_KEY = "normaluser"
+        self._TEST_SERVER_NORMAL_USER_KEY = server_test_v1_apikey
         self.OPENML_TEST_SERVER_ADMIN_KEY_ENV_VAR = "OPENML_TEST_SERVER_ADMIN_KEY"
-        self.TEST_SERVER_URL = "https://test.openml.org"
+        self.TEST_SERVER_URL = cast("str", server_test_v1_server).split("/api/v1/xml")[0]
 
         self._config: OpenMLConfig = OpenMLConfig()
         # for legacy test `test_non_writable_home`
@@ -127,6 +185,10 @@ def __setattr__(self, name: str, value: Any) -> None:
             object.__setattr__(self, "_config", replace(self._config, **{name: value}))
             return None
 
+        if name in ["server", "apikey"]:
+            setattr(self._config, name, value)
+            return None
+
         object.__setattr__(self, name, value)
         return None
 
@@ -190,6 +252,21 @@ def get_server_base_url(self) -> str:
         domain, _ = self._config.server.split("/api", maxsplit=1)
         return domain.replace("api", "www")
 
+    def set_server_mode(self, mode: str) -> None:
+        if mode not in SERVERS_REGISTRY:
+            raise ValueError(
+                f'invalid mode="{mode}" allowed modes: {", ".join(list(SERVERS_REGISTRY.keys()))}'
+            )
+        self._config = replace(self._config, servers=SERVERS_REGISTRY[mode])
+
+    def set_api_version(self, api_version: APIVersion) -> None:
+        if api_version not in APIVersion:
+            raise ValueError(
+                f'invalid api_version="{api_version}" '
+                f"allowed versions: {', '.join(list(APIVersion))}"
+            )
+        self._config = replace(self._config, api_version=api_version)
+
     def set_retry_policy(
         self, value: Literal["human", "robot"], n_retries: int | None = None
     ) -> None:
@@ -317,13 +394,18 @@ def _setup(self, config: dict[str, Any] | None = None) -> None:
 
         self._config = replace(
             self._config,
-            apikey=config["apikey"],
-            server=config["server"],
+            servers=config["servers"],
+            api_version=config["api_version"],
+            fallback_api_version=config["fallback_api_version"],
             show_progress=config["show_progress"],
             avoid_duplicate_runs=config["avoid_duplicate_runs"],
             retry_policy=config["retry_policy"],
             connection_n_retries=int(config["connection_n_retries"]),
         )
+        if "server" in config:
+            self._config.server = config["server"]
+        if "apikey" in config:
+            self._config.apikey = config["apikey"]
 
         user_defined_cache_dir = os.environ.get(self.OPENML_CACHE_DIR_ENV_VAR)
         if user_defined_cache_dir is not None:
@@ -393,42 +475,34 @@ def overwrite_config_context(self, config: dict[str, Any]) -> Iterator[dict[str,
 class ConfigurationForExamples:
     """Allows easy switching to and from a test configuration, used for examples."""
 
-    _last_used_server = None
-    _last_used_key = None
+    _last_used_servers = None
     _start_last_called = False
 
     def __init__(self, manager: OpenMLConfigManager):
         self._manager = manager
-        self._test_apikey = manager._TEST_SERVER_NORMAL_USER_KEY
-        self._test_server = f"{manager.TEST_SERVER_URL}/api/v1/xml"
+        self._test_servers = SERVERS_REGISTRY["test"]
 
     def start_using_configuration_for_example(self) -> None:
         """Sets the configuration to connect to the test server with valid apikey.
 
         To configuration as was before this call is stored, and can be recovered
         by using the `stop_use_example_configuration` method.
         """
-        if (
-            self._start_last_called
-            and self._manager._config.server == self._test_server
-            and self._manager._config.apikey == self._test_apikey
-        ):
+        if self._start_last_called and self._manager._config.servers == self._test_servers:
             # Method is called more than once in a row without modifying the server or apikey.
             # We don't want to save the current test configuration as a last used configuration.
             return
 
-        self._last_used_server = self._manager._config.server
-        self._last_used_key = self._manager._config.apikey
+        self._last_used_servers = self._manager._config.servers
         type(self)._start_last_called = True
 
         # Test server key for examples
         self._manager._config = replace(
             self._manager._config,
-            server=self._test_server,
-            apikey=self._test_apikey,
+            servers=self._test_servers,
         )
         warnings.warn(
-            f"Switching to the test server {self._test_server} to not upload results to "
+            f"Switching to the test servers {self._test_servers} to not upload results to "
             "the live server. Using the test server may result in reduced performance of the "
             "API!",
             stacklevel=2,
@@ -446,8 +520,7 @@ def stop_using_configuration_for_example(self) -> None:
 
         self._manager._config = replace(
             self._manager._config,
-            server=cast("str", self._last_used_server),
-            apikey=cast("str", self._last_used_key),
+            servers=cast("dict[APIVersion, dict[str, str | None]]", self._last_used_servers),
         )
         type(self)._start_last_called = False
 

openml/testing.py

@@ -49,7 +49,7 @@ class TestBase(unittest.TestCase):
         "user": [],
     }
     flow_name_tracker: ClassVar[list[str]] = []
-    test_server = f"{openml.config.TEST_SERVER_URL}/api/v1/xml"
+    test_server = f"{openml.config.TEST_SERVER_URL}/api/v1/xml/"
     admin_key = os.environ.get(openml.config.OPENML_TEST_SERVER_ADMIN_KEY_ENV_VAR)
     user_key = openml.config._TEST_SERVER_NORMAL_USER_KEY
 

tests/test_openml/test_config.py

@@ -15,7 +15,7 @@
 import openml
 import openml.testing
 from openml.testing import TestBase
-from openml.enums import APIVersion, ServerType
+from openml.enums import APIVersion
 
 
 @contextmanager
@@ -80,26 +80,22 @@ def test_get_config_as_dict(self):
         _config = {}
         _config["api_version"] = APIVersion.V1
         _config["fallback_api_version"] = None
-        _config["server_type"] = ServerType.PRODUCTION
-        _config["apikey"] = TestBase.user_key
-        _config["server"] = f"{openml.config.TEST_SERVER_URL}/api/v1/xml"
+        _config["servers"] = openml._config.SERVERS_REGISTRY['production']
         _config["cachedir"] = self.workdir
         _config["avoid_duplicate_runs"] = False
         _config["connection_n_retries"] = 20
         _config["retry_policy"] = "robot"
         _config["show_progress"] = False
         assert isinstance(config, dict)
-        assert len(config) == 10
+        assert len(config) == 8
         self.assertDictEqual(config, _config)
 
     def test_setup_with_config(self):
         """Checks if the OpenML configuration can be updated using _setup()."""
         _config = {}
         _config["api_version"] = APIVersion.V1
         _config["fallback_api_version"] = None
-        _config["server_type"] = ServerType.PRODUCTION
-        _config["apikey"] = TestBase.user_key
-        _config["server"] = "https://www.openml.org/api/v1/xml"
+        _config["servers"] = openml._config.SERVERS_REGISTRY['production']
         _config["cachedir"] = self.workdir
         _config["avoid_duplicate_runs"] = True
         _config["retry_policy"] = "human"