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

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

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

{freva_client-2508.0.0 → freva_client-2509.1.0}/assets/share/freva/freva.toml

@@ -17,3 +17,8 @@
 ## You can set a port by separating <hostname:port>
 ## for example freva.example.org:7777
 # host = ""
+
+##
+## The default flavour to use when accessing freva. You can simply list
+## the flavours you want to use and choose one as default.
+# default_flavour = "cmip6"

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

@@ -12,10 +12,11 @@ science community. With help of Freva researchers can:
 The code described here is currently in testing phase. The client and server
 library described in the documentation only support searching for data. If you
 need to apply data analysis plugins, please visit the
+official documentation: https://freva-org.github.io/freva-legacy
 """
 
 from .auth import authenticate
 from .query import databrowser
 
-__version__ = "2508.0.0"
+__version__ = "2509.1.0"
 __all__ = ["authenticate", "databrowser", "__version__"]

{freva_client-2508.0.0 → freva_client-2509.1.0}/src/freva_client/auth.py

@@ -2,27 +2,24 @@
 
 import datetime
 import json
-import socket
-import urllib.parse
-import webbrowser
-from http.server import BaseHTTPRequestHandler, HTTPServer
+import os
 from pathlib import Path
-from threading import Event, Lock, Thread
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, Optional, Union
 
 import requests
 
 from .utils import logger
 from .utils.auth_utils import (
+    AuthError,
+    DeviceAuthClient,
     Token,
     choose_token_strategy,
     get_default_token_file,
+    is_interactive_auth_possible,
     load_token,
-    wait_for_port,
 )
 from .utils.databrowser_utils import Config
 
-REDIRECT_URI = "http://localhost:{port}/callback"
 AUTH_FAILED_MSG = """Login failed or no valid token found in this environment.
 If you appear to be in a non-interactive or remote session create a new token
 via:
@@ -34,52 +31,11 @@ Then pass the token file using:"
 "    {token_path} or set the $TOKEN_ENV_VAR env. variable."""
 
 
-class AuthError(Exception):
-    """Athentication error."""
-
-    pass
-
-
-class OAuthCallbackHandler(BaseHTTPRequestHandler):
-    def log_message(self, format: str, *args: object) -> None:
-        logger.debug(format, *args)
-
-    def do_GET(self) -> None:
-        query = urllib.parse.urlparse(self.path).query
-        params = urllib.parse.parse_qs(query)
-        if "code" in params:
-            setattr(self.server, "auth_code", params["code"][0])
-            self.send_response(200)
-            self.end_headers()
-            self.wfile.write(b"Login successful! You can close this tab.")
-        else:
-            self.send_response(400)
-            self.end_headers()
-            self.wfile.write(b"Authorization code not found.")
-
-
-def start_local_server(port: int, event: Event) -> HTTPServer:
-    """Start local HTTP server to wait for a single callback."""
-    server = HTTPServer(("localhost", port), OAuthCallbackHandler)
-
-    def handle() -> None:
-        logger.info("Waiting for browser callback on port %s ...", port)
-        while not event.is_set():
-            server.handle_request()
-            if getattr(server, "auth_code", None):
-                event.set()
-
-    thread = Thread(target=handle, daemon=True)
-    thread.start()
-    return server
-
-
 class Auth:
     """Helper class for authentication."""
 
     _instance: Optional["Auth"] = None
     _auth_token: Optional[Token] = None
-    _thread_lock: Lock = Lock()
 
     def __new__(cls, *args: Any, **kwargs: Any) -> "Auth":
         if cls._instance is None:
@@ -112,83 +68,29 @@ class Auth:
     def _login(
         self,
         auth_url: str,
-        force: bool = False,
-        _timeout: int = 30,
+        _timeout: Optional[int] = 30,
     ) -> Token:
-        login_endpoint = f"{auth_url}/login"
+        device_endpoint = f"{auth_url}/device"
         token_endpoint = f"{auth_url}/token"
-        port = self.find_free_port(auth_url)
-        redirect_uri = REDIRECT_URI.format(port=port)
-        params = {
-            "redirect_uri": redirect_uri,
-        }
-        if force:
-            params["prompt"] = "login"
-        query = urllib.parse.urlencode(params)
-        login_url = f"{login_endpoint}?{query}"
-        logger.info("Opening browser for login:\n%s", login_url)
-        logger.info(
-            "If you are using this on a remote host, you might need to "
-            "forward port %d:\n"
-            "    ssh -L %d:localhost:%d user@remotehost",
-            port,
-            port,
-            port,
+        client = DeviceAuthClient(
+            device_endpoint=device_endpoint,
+            token_endpoint=token_endpoint,
+            timeout=_timeout,
         )
-        event = Event()
-        server = start_local_server(port, event)
-        code: Optional[str] = None
-        reason = "Login failed."
-        try:
-            wait_for_port("localhost", port)
-            webbrowser.open(login_url)
-            success = event.wait(timeout=_timeout)
-            if not success:
-                raise TimeoutError(
-                    f"Login did not complete within {_timeout} seconds. "
-                    "Possibly headless environment."
-                )
-            code = getattr(server, "auth_code", None)
-        except Exception as error:
-            logger.warning(
-                "Could not open browser automatically. %s"
-                "Please open the URL manually.",
-                error,
-            )
-            reason = str(error)
-
-        finally:
-            logger.debug("Cleaning up login state")
-            if hasattr(server, "server_close"):
-                try:
-                    server.server_close()
-                except Exception as error:
-                    logger.debug("Failed to close server cleanly: %s", error)
-        if not code:
-            raise AuthError(reason)
-        return self.get_token(
-            token_endpoint,
-            data={
-                "code": code,
-                "redirect_uri": redirect_uri,
-                "grant_type": "authorization_code",
-            },
+        is_interactive_auth = int(
+            os.getenv("BROWSER_SESSION", str(int(is_interactive_auth_possible())))
         )
-
-    @staticmethod
-    def find_free_port(auth_url: str) -> int:
-        """Get a free port where we can start the test server."""
-        ports: List[int] = (
-            requests.get(f"{auth_url}/auth-ports").json().get("valid_ports", [])
+        response = client.login(
+            token_normalizer=self.get_token, auto_open=bool(is_interactive_auth)
+        )
+        return self.set_token(
+            access_token=response["access_token"],
+            token_type=response["token_type"],
+            expires=response["expires"],
+            refresh_token=response["refresh_token"],
+            refresh_expires=response["refresh_expires"],
+            scope=response["scope"],
         )
-        for port in ports:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                try:
-                    s.bind(("localhost", port))
-                    return port
-                except (OSError, PermissionError):
-                    pass
-        raise OSError("No free ports available for login flow")
 
     def set_token(
         self,
@@ -223,9 +125,7 @@ class Auth:
         return self._auth_token
 
     def _refresh(
-        self,
-        url: str,
-        refresh_token: str,
+        self, url: str, refresh_token: str, timeout: Optional[int] = 30
     ) -> Token:
         """Refresh the access_token with a refresh token."""
         try:
@@ -235,7 +135,7 @@ class Auth:
             )
         except (AuthError, KeyError) as error:
             logger.warning("Failed to refresh token: %s", error)
-            return self._login(url)
+            return self._login(url, _timeout=timeout)
 
     def authenticate(
         self,
@@ -243,6 +143,7 @@ class Auth:
         config: Optional[Config] = None,
         *,
         force: bool = False,
+        timeout: Optional[int] = 30,
         _cli: bool = False,
     ) -> Token:
         """Authenticate the user to the host."""
@@ -258,9 +159,11 @@ class Auth:
             return self._auth_token
         try:
             if strategy == "refresh_token" and token:
-                return self._refresh(cfg.auth_url, token["refresh_token"])
+                return self._refresh(
+                    cfg.auth_url, token["refresh_token"], timeout=timeout
+                )
             if strategy == "browser_auth":
-                return self._login(cfg.auth_url, force=force)
+                return self._login(cfg.auth_url, _timeout=timeout)
         except AuthError as error:
             reason = str(error)
 
@@ -287,6 +190,7 @@ def authenticate(
     token_file: Optional[Union[Path, str]] = None,
     host: Optional[str] = None,
     force: bool = False,
+    timeout: Optional[int] = 30,
 ) -> Token:
     """Authenticate to the host.
 
@@ -294,13 +198,15 @@ def authenticate(
 
     Parameters
     ----------
-    refresh_token: str, optional
+    token_file: str, optional
         Instead of setting a password, you can set a refresh token to refresh
         the access token. This is recommended for non-interactive environments.
     host: str, optional
         The hostname of the REST server.
     force: bool, default: False
         Force token recreation, even if current token is still valid.
+    timeout: int, default: 30
+        Set the timeout, None for indefinate.
 
     Returns
     -------
@@ -313,7 +219,7 @@ def authenticate(
     .. code-block:: python
 
         from freva_client import authenticate
-        token = authenticate()
+        token = authenticate(timeout=120)
         print(token)
 
     Batch mode authentication with a refresh token:
@@ -327,4 +233,5 @@ def authenticate(
     return auth.authenticate(
         host=host,
         force=force,
+        timeout=timeout,
     )

{freva_client-2508.0.0 → freva_client-2509.1.0}/src/freva_client/cli/auth_cli.py

@@ -44,6 +44,11 @@ def authenticate_cli(
         "-f",
         help="Force token recreation, even if current token is still valid.",
     ),
+    timeout: int = typer.Option(
+        30,
+        "--timeout",
+        help="Set the timeout for login in secdonds, 0 for indefinate",
+    ),
     verbose: int = typer.Option(0, "-v", help="Increase verbosity", count=True),
     version: Optional[bool] = typer.Option(
         False,
@@ -59,5 +64,6 @@ def authenticate_cli(
         host=host,
         force=force,
         _cli=True,
+        timeout=timeout,
     )
     print(json.dumps(token, indent=3))

freva_client-2509.1.0/src/freva_client/cli/cli_utils.py

@@ -0,0 +1,69 @@
+"""Utilities for the command line interface."""
+
+from typing import Any, Dict, List
+
+import pandas as pd
+import typer
+from rich import print as pprint
+from rich.console import Console
+from rich.table import Table
+
+from freva_client import __version__
+from freva_client.utils import logger
+
+APP_NAME: str = "freva-client"
+
+
+def version_callback(version: bool) -> None:
+    """Print the version and exit."""
+    if version:
+        pprint(f"{APP_NAME}: {__version__}")
+        raise typer.Exit()
+
+
+def parse_cli_args(cli_args: List[str]) -> Dict[str, List[str]]:
+    """Convert the cli arguments to a dictionary."""
+    logger.debug("parsing command line arguments.")
+    kwargs = {}
+    for entry in cli_args:
+        key, _, value = entry.partition("=")
+        if value and key not in kwargs:
+            kwargs[key] = [value]
+        elif value:
+            kwargs[key].append(value)
+    logger.debug(kwargs)
+    return kwargs
+
+
+def _summarize(val: Any, max_items: int = 6) -> str:
+    """Summarize values for table display, truncating long lists."""
+    n = len(val)
+    head = ", ".join(map(str, val[:max_items]))
+    if n > max_items:
+        return f"{head} … (+{n - max_items} more)"
+    return head
+
+
+def print_df(s: pd.Series, max_items: int = 6) -> None:
+    """Print a pandas Series as a rich table.
+
+    Parameters
+    ----------
+    s : pd.Series
+        The pandas Series to print.
+    max_items : int, optional
+        Maximum number of items to display for list-like values,
+        by default 6.
+    """
+    left_col: str = s.index.name or "index"
+    right_col: str = s.name or "value"
+
+    table: Table = Table(show_header=True, header_style="bold magenta")
+    table.add_column(left_col, style="cyan", no_wrap=True)
+    table.add_column(right_col, style="green")
+
+    for key, val in s.items():
+        table.add_row(str(key), _summarize(val, max_items=max_items))
+
+    console: Console = Console()
+    console.print(table)