freva-client 2509.1.0__tar.gz → 2509.2.0__tar.gz

{freva_client-2509.1.0 → freva_client-2509.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freva-client
-Version: 2509.1.0
+Version: 2509.2.0
 Summary: Search for climate data based on key-value pairs
 Author-email: "DKRZ, Clint" <freva@dkrz.de>
 Requires-Python: >=3.8

{freva_client-2509.1.0 → freva_client-2509.2.0}/src/freva_client/__init__.py

@@ -18,5 +18,5 @@ official documentation: https://freva-org.github.io/freva-legacy
 from .auth import authenticate
 from .query import databrowser
 
-__version__ = "2509.1.0"
+__version__ = "2509.2.0"
 __all__ = ["authenticate", "databrowser", "__version__"]

{freva_client-2509.1.0 → freva_client-2509.2.0}/src/freva_client/utils/databrowser_utils.py

@@ -42,11 +42,18 @@ class Config:
         uniq_key: Literal["file", "uri"] = "file",
         flavour: Optional[str] = None,
     ) -> None:
-        self.databrowser_url = f"{self.get_api_url(host)}/databrowser"
-        self.auth_url = f"{self.get_api_url(host)}/auth/v2"
-        self.get_api_main_url = self.get_api_url(host)
+        config_host = host or cast(str, self._get_databrowser_param_from_config("host"))
+
+        self.databrowser_url = f"{self.get_api_url(config_host)}/databrowser"
+        self.auth_url = f"{self.get_api_url(config_host)}/auth/v2"
+        self.get_api_main_url = self.get_api_url(config_host)
         self.uniq_key = uniq_key
-        self.flavour = self.get_flavour(flavour)
+        self._flavour = (
+            flavour or self._get_databrowser_param_from_config(
+                "flavour",
+                optional=True
+            )
+        )
 
     @cached_property
     def validate_server(self) -> bool:
@@ -59,18 +66,17 @@ class Config:
                 f"Could not connect to {self.databrowser_url}: {e}"
             ) from None
 
-    def get_flavour(self, flavour: Optional[str]) -> str:
-        """Get the current flavour."""
-        if flavour:
-            return flavour
-        else:
-            try:
-                config_flavour = self._get_databrowser_params_from_config().get(
-                    "flavour", ""
-                )
-                return config_flavour or "freva"
-            except ValueError:
-                return "freva"
+    @property
+    def flavour(self) -> str:
+        """Get the flavour, using server default if not configured."""
+        if self._flavour:
+            return self._flavour
+        try:
+            flavours = self.overview.get("flavours", [])
+            self._flavour = flavours[0] if flavours else "freva"
+        except (ValueError, IndexError, KeyError):
+            self._flavour = "freva"
+        return self._flavour
 
     def _read_ini(self, path: Path) -> Dict[str, str]:
         """Read an ini file.
@@ -115,8 +121,11 @@ class Config:
         """
         try:
             config = tomli.loads(path.read_text()).get("freva", {})
-            scheme, host = self._split_url(cast(str, config.get("host", "")))
+            raw_host = cast(str, config.get("host", ""))
             flavour = config.get("default_flavour", "")
+            if not raw_host:
+                return {"host": "", "flavour": flavour}
+            scheme, host = self._split_url(raw_host)
         except (tomli.TOMLDecodeError, KeyError):
             return {}
         host, _, port = host.partition(":")
@@ -186,9 +195,10 @@ class Config:
                 f"Could not connect to {self.databrowser_url}"
             ) from None
 
-    def _get_databrowser_params_from_config(self) -> Dict[str, str]:
-        """Get the config file order."""
-
+    def _get_databrowser_param_from_config(
+            self, key: str, optional: bool = False
+    ) -> Optional[str]:
+        """Get a single config parameter following proper precedence."""
         eval_conf = self.get_dirs(user=False) / "evaluation_system.conf"
         freva_config = Path(
             os.environ.get("FREVA_CONFIG")
@@ -202,20 +212,22 @@ class Config:
                 os.environ.get("EVALUATION_SYSTEM_CONFIG_FILE") or eval_conf
             ): "ini",
         }
+
         for config_path, config_type in paths.items():
             if config_path.is_file():
                 config_data = self._read_config(config_path, config_type)
-                host = config_data.get("host", "")
-                flavour = config_data.get("flavour", "")
-                if host:
-                    return {
-                        "host": host,
-                        "flavour": flavour
-                    }
+                value = config_data.get(key, "")
+                # we cannot igonore the empty string here, because
+                # it needs to check the next config file
+                if value:
+                    return value if value else None
+        if optional:
+            return None
+
         raise ValueError(
-            "No databrowser host configured, please use a"
-            " configuration defining a databrowser host or"
-            " set a host name using the `host` key"
+            f"No databrowser {key} configured, please use a"
+            f" configuration defining a databrowser {key} or"
+            f" set a host name using the `{key}` key"
         )
 
     @property
@@ -257,9 +269,8 @@ class Config:
         scheme = scheme or "http"
         return scheme, hostname
 
-    def get_api_url(self, url: Optional[str]) -> str:
+    def get_api_url(self, url: str) -> str:
         """Construct the databrowser url from a given hostname."""
-        url = url or self._get_databrowser_params_from_config().get("host", "")
         scheme, hostname = self._split_url(url)
         hostname, _, port = hostname.partition(":")
         if port:
@@ -385,7 +396,7 @@ class UserDataHandler:
     ) -> None:
         for data in validated_userdata:
             metadata = self._get_metadata(data)
-            if isinstance(metadata, Exception) or metadata == {}:
+            if metadata == {}:
                 logger.warning("Error getting metadata: %s", metadata)
             else:
                 self.user_metadata.append(metadata)