update server methods in config

Author: geetu040

openml/_config.py

@@ -27,39 +27,54 @@
 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,
-        },
+_PROD_SERVERS: dict[APIVersion, dict[str, str | None]] = {
+    APIVersion.V1: {
+        "server": "https://www.openml.org/api/v1/xml/",
+        "apikey": None,
+    },
+    APIVersion.V2: {
+        "server": None,
+        "apikey": None,
+    },
+}
+
+_TEST_SERVERS: dict[APIVersion, dict[str, str | None]] = {
+    APIVersion.V1: {
+        "server": "https://test.openml.org/api/v1/xml/",
+        "apikey": "normaluser",
     },
-    "test": {
-        APIVersion.V1: {
-            "server": "https://test.openml.org/api/v1/xml/",
-            "apikey": "normaluser",
-        },
-        APIVersion.V2: {
-            "server": None,
-            "apikey": None,
-        },
+    APIVersion.V2: {
+        "server": None,
+        "apikey": None,
     },
-    "local": {
-        APIVersion.V1: {
-            "server": "http://localhost:8080/api/v1/xml/",
-            "apikey": "normaluser",
-        },
-        APIVersion.V2: {
-            "server": "http://localhost:8082/",
-            "apikey": "AD000000000000000000000000000000",
-        },
+}
+
+_TEST_SERVERS_LOCAL: dict[APIVersion, dict[str, str | None]] = {
+    APIVersion.V1: {
+        "server": "http://localhost:8080/api/v1/xml/",
+        "apikey": "normaluser",
+    },
+    APIVersion.V2: {
+        "server": "http://localhost:8082/",
+        "apikey": "AD000000000000000000000000000000",
     },
 }
 
+_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,
+}
+
+
+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()))}'
+        )
+    return deepcopy(_SERVERS_REGISTRY[mode])
+
 
 def _resolve_default_cache_dir() -> Path:
     user_defined_cache_dir = os.environ.get("OPENML_CACHE_DIR")
@@ -97,7 +112,7 @@ class OpenMLConfig:
     """Dataclass storing the OpenML configuration."""
 
     servers: dict[APIVersion, dict[str, str | None]] = field(
-        default_factory=lambda: deepcopy(_SERVERS_REGISTRY["production"])
+        default_factory=lambda: _get_servers("production")
     )
     api_version: APIVersion = APIVersion.V1
     fallback_api_version: APIVersion | None = None
@@ -251,17 +266,25 @@ 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]]:
-        if mode not in _SERVERS_REGISTRY:
-            raise ValueError(
-                f'invalid mode="{mode}" allowed modes: {", ".join(list(_SERVERS_REGISTRY.keys()))}'
-            )
-        return deepcopy(_SERVERS_REGISTRY[mode])
+    def _get_servers(self, mode: str) -> dict[APIVersion, dict[str, str | None]]:
+        return _get_servers(mode)
 
-    def set_servers(self, mode: str) -> None:
-        servers = self.get_servers(mode)
+    def _set_servers(self, mode: str) -> 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")
+
+    def get_test_servers(self) -> dict[APIVersion, dict[str, str | None]]:
+        return self._get_servers(mode="test")
+
+    def use_production_servers(self) -> None:
+        self._set_servers(mode="production")
+
+    def use_test_servers(self) -> None:
+        self._set_servers(mode="test")
+
     def set_api_version(
         self,
         api_version: APIVersion,
@@ -498,7 +521,7 @@ class ConfigurationForExamples:
 
     def __init__(self, manager: OpenMLConfigManager):
         self._manager = manager
-        self._test_servers = manager.get_servers("test")
+        self._test_servers = manager.get_test_servers()
 
     def start_using_configuration_for_example(self) -> None:
         """Sets the configuration to connect to the test server with valid apikey.

openml/cli.py

@@ -112,9 +112,9 @@ def check_server(server: str) -> str:
 
     def replace_shorthand(server: str) -> str:
         if server == "test":
-            return cast("str", openml.config.get_servers("test")[APIVersion.V1]["server"])
+            return cast("str", openml.config.get_test_servers()[APIVersion.V1]["server"])
         if server == "production_server":
-            return cast("str", openml.config.get_servers("production")[APIVersion.V1]["server"])
+            return cast("str", openml.config.get_production_servers()[APIVersion.V1]["server"])
         return server
 
     configure_field(

openml/testing.py

@@ -124,7 +124,7 @@ def use_production_server(self) -> None:
 
         Please use this sparingly - it is better to use the test server.
         """
-        openml.config.set_servers("production")
+        openml.config.use_production_servers()
 
     def tearDown(self) -> None:
         """Tear down the test"""

tests/conftest.py

@@ -99,7 +99,7 @@ def delete_remote_files(tracker, flow_names) -> None:
     :param tracker: Dict
     :return: None
     """
-    openml.config.set_servers("test")
+    openml.config.use_test_servers()
 
     # reordering to delete sub flows at the end of flows
     # sub-flows have shorter names, hence, sorting by descending order of flow name length
@@ -252,22 +252,22 @@ def test_files_directory() -> Path:
 
 @pytest.fixture(scope="session")
 def test_server_v1() -> str:
-    return openml.config.get_servers("test")[APIVersion.V1]["server"]
+    return openml.config.get_test_servers()[APIVersion.V1]["server"]
 
 
 @pytest.fixture(scope="session")
 def test_apikey_v1() -> str:
-    return openml.config.get_servers("test")[APIVersion.V1]["apikey"]
+    return openml.config.get_test_servers()[APIVersion.V1]["apikey"]
 
 
 @pytest.fixture(scope="session")
 def test_server_v2() -> str:
-    return openml.config.get_servers("test")[APIVersion.V2]["server"]
+    return openml.config.get_test_servers()[APIVersion.V2]["server"]
 
 
 @pytest.fixture(scope="session")
 def test_apikey_v2() -> str:
-    return openml.config.get_servers("test")[APIVersion.V2]["apikey"]
+    return openml.config.get_test_servers()[APIVersion.V2]["apikey"]
 
 
 @pytest.fixture(autouse=True, scope="function")
@@ -288,18 +288,11 @@ def as_robot() -> Iterator[None]:
 
 @pytest.fixture(autouse=True)
 def with_server(request):
-    openml.config.set_api_version(APIVersion.V1)
-
     if "production_server" in request.keywords:
-        # use-production-server (remote)
-        openml.config.set_servers("production")
-    elif os.getenv("OPENML_USE_LOCAL_SERVICES") == "true":
-        # use-test-server (local)
-        openml.config.set_servers("local")
-    else:
-        # use-test-server (remote)
-        openml.config.set_servers("test")
-
+        openml.config.use_production_servers()
+        yield
+        return
+    openml.config.use_test_servers()
     yield
 
 

tests/test_openml/test_config.py

@@ -81,7 +81,7 @@ def test_get_config_as_dict(self):
         _config = {}
         _config["api_version"] = APIVersion.V1
         _config["fallback_api_version"] = None
-        _config["servers"] = openml.config.get_servers("test")
+        _config["servers"] = openml.config.get_test_servers()
         _config["cachedir"] = self.workdir
         _config["avoid_duplicate_runs"] = False
         _config["connection_n_retries"] = 20
@@ -96,7 +96,7 @@ def test_setup_with_config(self):
         _config = {}
         _config["api_version"] = APIVersion.V1
         _config["fallback_api_version"] = None
-        _config["servers"] = openml.config.get_servers("test")
+        _config["servers"] = openml.config.get_test_servers()
         _config["cachedir"] = self.workdir
         _config["avoid_duplicate_runs"] = True
         _config["retry_policy"] = "human"
@@ -113,21 +113,22 @@ class TestConfigurationForExamples(openml.testing.TestBase):
     @pytest.mark.production_server()
     def test_switch_to_example_configuration(self):
         """Verifies the test configuration is loaded properly."""
-        openml.config.set_servers("production")
+        openml.config.use_production_servers()
 
         openml.config.start_using_configuration_for_example()
 
-        openml.config.servers = openml.config.get_servers("test")
+        assert openml.config.servers == openml.config.get_test_servers()
 
     @pytest.mark.production_server()
     def test_switch_from_example_configuration(self):
         """Verifies the previous configuration is loaded after stopping."""
         # Below is the default test key which would be used anyway, but just for clarity:
-        openml.config.set_servers("production")
+        openml.config.use_production_servers()
 
         openml.config.start_using_configuration_for_example()
         openml.config.stop_using_configuration_for_example()
-        openml.config.servers = openml.config.get_servers("production")
+
+        assert openml.config.servers == openml.config.get_production_servers()
 
     def test_example_configuration_stop_before_start(self):
         """Verifies an error is raised if `stop_...` is called before `start_...`."""
@@ -144,13 +145,13 @@ def test_example_configuration_stop_before_start(self):
     @pytest.mark.production_server()
     def test_example_configuration_start_twice(self):
         """Checks that the original config can be returned to if `start..` is called twice."""
-        openml.config.set_servers("production")
+        openml.config.use_production_servers()
 
         openml.config.start_using_configuration_for_example()
         openml.config.start_using_configuration_for_example()
         openml.config.stop_using_configuration_for_example()
 
-        assert openml.config.servers == openml.config.get_servers("production")
+        assert openml.config.servers == openml.config.get_production_servers()
 
 
 def test_configuration_file_not_overwritten_on_load():
@@ -192,28 +193,28 @@ 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", "local"])
+@pytest.mark.parametrize("mode", ["production", "test"])
 @pytest.mark.parametrize("api_version", [APIVersion.V1, APIVersion.V2])
 def test_get_servers(mode, api_version):
-    orig_servers = openml.config.get_servers(mode)
+    orig_servers = openml.config._get_servers(mode)
 
-    openml.config.set_servers(mode)
+    openml.config._set_servers(mode)
     openml.config.set_api_version(api_version)
     openml.config.server = "temp-server1"
     openml.config.apikey = "temp-apikey1"
-    openml.config.get_servers(mode)["server"] = 'temp-server2'
-    openml.config.get_servers(mode)["apikey"] = 'temp-server2'
+    openml.config._get_servers(mode)["server"] = 'temp-server2'
+    openml.config._get_servers(mode)["apikey"] = 'temp-server2'
 
-    assert openml.config.get_servers(mode) == orig_servers
+    assert openml.config._get_servers(mode) == orig_servers
 
 
-@pytest.mark.parametrize("mode", ["production", "test", "local"])
+@pytest.mark.parametrize("mode", ["production", "test"])
 @pytest.mark.parametrize("api_version", [APIVersion.V1, APIVersion.V2])
 def test_set_servers(mode, api_version):
-    openml.config.set_servers(mode)
+    openml.config._set_servers(mode)
     openml.config.set_api_version(api_version)
 
-    assert openml.config.servers == openml.config.get_servers(mode)
+    assert openml.config.servers == openml.config._get_servers(mode)
     assert openml.config.api_version == api_version
 
     openml.config.server = "temp-server"
@@ -224,6 +225,34 @@ def test_set_servers(mode, api_version):
 
     for version, servers in openml.config.servers.items():
         if version == api_version:
-            assert servers != openml.config.get_servers(mode)[version]
+            assert servers != openml.config._get_servers(mode)[version]
         else:
-            assert servers == openml.config.get_servers(mode)[version]
+            assert servers == openml.config._get_servers(mode)[version]
+
+
+def test_get_production_servers():
+    assert openml.config.get_production_servers() == openml.config._get_servers("production")
+
+
+def test_get_test_servers():
+    assert openml.config.get_test_servers() == openml.config._get_servers("test")
+
+
+def test_use_production_servers():
+    openml.config.use_production_servers()
+    servers_1 = openml.config.servers
+
+    openml.config._set_servers("production")
+    servers_2 = openml.config.servers
+
+    assert servers_1 == servers_2
+
+
+def test_use_test_servers():
+    openml.config.use_test_servers()
+    servers_1 = openml.config.servers
+
+    openml.config._set_servers("test")
+    servers_2 = openml.config.servers
+
+    assert servers_1 == servers_2