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

Author: Omswastik-11

openml/_api/clients/http.py

@@ -116,15 +116,15 @@ def __init__(  # noqa: PLR0913
         server: str,
         base_url: str,
         api_key: str,
-        timeout: int,
+        timeout_seconds: int,
         retries: int,
         retry_policy: RetryPolicy,
         cache: HTTPCache | None = None,
     ) -> None:
         self.server = server
         self.base_url = base_url
         self.api_key = api_key
-        self.timeout = timeout
+        self.timeout_seconds = timeout_seconds
         self.retries = retries
         self.retry_policy = retry_policy
         self.cache = cache
@@ -343,7 +343,7 @@ def request(
         headers = request_kwargs.pop("headers", {}).copy()
         headers.update(self.headers)
 
-        timeout = request_kwargs.pop("timeout", self.timeout)
+        timeout = request_kwargs.pop("timeout", self.timeout_seconds)
         files = request_kwargs.pop("files", None)
 
         if use_cache and not reset_cache and self.cache is not None:

openml/_api/setup/backend.py

@@ -1,11 +1,24 @@
 from __future__ import annotations
 
 from copy import deepcopy
-from typing import Any
+from typing import TYPE_CHECKING, Any, cast
 
 from .builder import APIBackendBuilder
 from .config import Config
 
+if TYPE_CHECKING:
+    from openml._api.resources import (
+        DatasetAPI,
+        EstimationProcedureAPI,
+        EvaluationAPI,
+        EvaluationMeasureAPI,
+        FlowAPI,
+        RunAPI,
+        SetupAPI,
+        StudyAPI,
+        TaskAPI,
+    )
+
 
 class APIBackend:
     _instance: APIBackend | None = None
@@ -14,12 +27,41 @@ def __init__(self, config: Config | None = None):
         self._config: Config = config or Config()
         self._backend = APIBackendBuilder.build(self._config)
 
-    def __getattr__(self, name: str) -> Any:
-        """
-        Delegate attribute access to the underlying backend.
-        Called only if attribute is not found on RuntimeBackend.
-        """
-        return getattr(self._backend, name)
+    @property
+    def dataset(self) -> DatasetAPI:
+        return cast("DatasetAPI", self._backend.dataset)
+
+    @property
+    def task(self) -> TaskAPI:
+        return cast("TaskAPI", self._backend.task)
+
+    @property
+    def evaluation_measure(self) -> EvaluationMeasureAPI:
+        return cast("EvaluationMeasureAPI", self._backend.evaluation_measure)
+
+    @property
+    def estimation_procedure(self) -> EstimationProcedureAPI:
+        return cast("EstimationProcedureAPI", self._backend.estimation_procedure)
+
+    @property
+    def evaluation(self) -> EvaluationAPI:
+        return cast("EvaluationAPI", self._backend.evaluation)
+
+    @property
+    def flow(self) -> FlowAPI:
+        return cast("FlowAPI", self._backend.flow)
+
+    @property
+    def study(self) -> StudyAPI:
+        return cast("StudyAPI", self._backend.study)
+
+    @property
+    def run(self) -> RunAPI:
+        return cast("RunAPI", self._backend.run)
+
+    @property
+    def setup(self) -> SetupAPI:
+        return cast("SetupAPI", self._backend.setup)
 
     @classmethod
     def get_instance(cls) -> APIBackend:
@@ -38,7 +80,7 @@ def set_config(cls, config: Config) -> None:
         instance._backend = APIBackendBuilder.build(config)
 
     @classmethod
-    def get_config_value(cls, key: str) -> Config:
+    def get_config_value(cls, key: str) -> Any:
         keys = key.split(".")
         config_value = cls.get_instance()._config
         for k in keys:
@@ -60,3 +102,27 @@ def set_config_value(cls, key: str, value: Any) -> None:
         else:
             setattr(parent, keys[-1], value)
         cls.set_config(config)
+
+    @classmethod
+    def get_config_values(cls, keys: list[str]) -> list[Any]:
+        values = []
+        for key in keys:
+            value = cls.get_config_value(key)
+            values.append(value)
+        return values
+
+    @classmethod
+    def set_config_values(cls, config_dict: dict[str, Any]) -> None:
+        config = cls.get_instance()._config
+
+        for key, value in config_dict.items():
+            keys = key.split(".")
+            parent = config
+            for k in keys[:-1]:
+                parent = parent[k] if isinstance(parent, dict) else getattr(parent, k)
+            if isinstance(parent, dict):
+                parent[keys[-1]] = value
+            else:
+                setattr(parent, keys[-1], value)
+
+        cls.set_config(config)

openml/_api/setup/builder.py

@@ -6,10 +6,9 @@
 
 from openml._api.clients import HTTPCache, HTTPClient, MinIOClient
 from openml._api.resources import API_REGISTRY, FallbackProxy, ResourceAPI
+from openml.enums import ResourceType
 
 if TYPE_CHECKING:
-    from openml.enums import ResourceType
-
     from .config import Config
 
 
@@ -18,8 +17,15 @@ def __init__(
         self,
         resource_apis: Mapping[ResourceType, ResourceAPI | FallbackProxy],
     ):
-        for resource_type, resource_api in resource_apis.items():
-            setattr(self, resource_type.value, resource_api)
+        self.dataset = resource_apis[ResourceType.DATASET]
+        self.task = resource_apis[ResourceType.TASK]
+        self.evaluation_measure = resource_apis[ResourceType.EVALUATION_MEASURE]
+        self.estimation_procedure = resource_apis[ResourceType.ESTIMATION_PROCEDURE]
+        self.evaluation = resource_apis[ResourceType.EVALUATION]
+        self.flow = resource_apis[ResourceType.FLOW]
+        self.study = resource_apis[ResourceType.STUDY]
+        self.run = resource_apis[ResourceType.RUN]
+        self.setup = resource_apis[ResourceType.SETUP]
 
     @classmethod
     def build(cls, config: Config) -> APIBackendBuilder:
@@ -33,7 +39,7 @@ def build(cls, config: Config) -> APIBackendBuilder:
             server=primary_api_config.server,
             base_url=primary_api_config.base_url,
             api_key=primary_api_config.api_key,
-            timeout=config.connection.timeout,
+            timeout_seconds=config.connection.timeout_seconds,
             retries=config.connection.retries,
             retry_policy=config.connection.retry_policy,
             cache=http_cache,
@@ -51,7 +57,7 @@ def build(cls, config: Config) -> APIBackendBuilder:
             server=fallback_api_config.server,
             base_url=fallback_api_config.base_url,
             api_key=fallback_api_config.api_key,
-            timeout=config.connection.timeout,
+            timeout_seconds=config.connection.timeout_seconds,
             retries=config.connection.retries,
             retry_policy=config.connection.retry_policy,
             cache=http_cache,

openml/_api/setup/config.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from datetime import timedelta
 
 from openml.enums import APIVersion, RetryPolicy
 
@@ -18,7 +19,7 @@ class APIConfig:
 class ConnectionConfig:
     retries: int
     retry_policy: RetryPolicy
-    timeout: int
+    timeout_seconds: int
 
 
 @dataclass
@@ -51,13 +52,13 @@ class Config:
         default_factory=lambda: ConnectionConfig(
             retries=5,
             retry_policy=RetryPolicy.HUMAN,
-            timeout=10,
+            timeout_seconds=10,
         )
     )
 
     cache: CacheConfig = field(
         default_factory=lambda: CacheConfig(
             dir=str(_resolve_default_cache_dir()),
-            ttl=60 * 60 * 24 * 7,
+            ttl=int(timedelta(weeks=1).total_seconds()),
         )
     )

openml/config.py

@@ -18,6 +18,8 @@
 from typing_extensions import TypedDict
 from urllib.parse import urlparse
 
+from openml.enums import RetryPolicy
+
 logger = logging.getLogger(__name__)
 openml_logger = logging.getLogger("openml")
 console_handler: logging.StreamHandler | None = None
@@ -206,6 +208,8 @@ def set_retry_policy(value: Literal["human", "robot"], n_retries: int | None = N
     retry_policy = value
     connection_n_retries = default_retries_by_policy[value] if n_retries is None else n_retries
 
+    _sync_api_config()
+
 
 class ConfigurationForExamples:
     """Allows easy switching to and from a test configuration, used for examples."""
@@ -244,6 +248,8 @@ def start_using_configuration_for_example(cls) -> None:
             stacklevel=2,
         )
 
+        _sync_api_config()
+
     @classmethod
     def stop_using_configuration_for_example(cls) -> None:
         """Return to configuration as it was before `start_use_example_configuration`."""
@@ -262,6 +268,8 @@ def stop_using_configuration_for_example(cls) -> None:
         apikey = cast("str", cls._last_used_key)
         cls._start_last_called = False
 
+        _sync_api_config()
+
 
 def _handle_xdg_config_home_backwards_compatibility(
     xdg_home: str,
@@ -374,6 +382,8 @@ def _setup(config: _Config | None = None) -> None:
         short_cache_dir = Path(config["cachedir"])
     _root_cache_directory = short_cache_dir.expanduser().resolve()
 
+    _sync_api_config()
+
     try:
         cache_exists = _root_cache_directory.exists()
         # create the cache subdirectory
@@ -408,6 +418,8 @@ def set_field_in_config_file(field: str, value: Any) -> None:
             if value is not None:
                 fh.write(f"{f} = {value}\n")
 
+    _sync_api_config()
+
 
 def _parse_config(config_file: str | Path) -> _Config:
     """Parse the config file, set up defaults."""
@@ -495,6 +507,8 @@ def set_root_cache_directory(root_cache_directory: str | Path) -> None:
     global _root_cache_directory  # noqa: PLW0603
     _root_cache_directory = Path(root_cache_directory)
 
+    _sync_api_config()
+
 
 start_using_configuration_for_example = (
     ConfigurationForExamples.start_using_configuration_for_example
@@ -514,6 +528,28 @@ def overwrite_config_context(config: dict[str, Any]) -> Iterator[_Config]:
     _setup(existing_config)
 
 
+def _sync_api_config() -> None:
+    """Sync the new API config with the legacy config in this file."""
+    from ._api import APIBackend
+
+    p = urlparse(server)
+    v1_server = f"{p.scheme}://{p.netloc}/"
+    v1_base_url = p.path.lstrip("/")
+    connection_retry_policy = RetryPolicy.HUMAN if retry_policy == "human" else RetryPolicy.ROBOT
+    cache_dir = str(_root_cache_directory)
+
+    APIBackend.set_config_values(
+        {
+            "api_configs.v1.server": v1_server,
+            "api_configs.v1.base_url": v1_base_url,
+            "api_configs.v1.api_key": apikey,
+            "cache.dir": cache_dir,
+            "connection.retry_policy": connection_retry_policy,
+            "connection.retries": connection_n_retries,
+        }
+    )
+
+
 __all__ = [
     "get_cache_directory",
     "get_config_as_dict",