anemoi-utils 0.4.27__py3-none-any.whl → 0.4.29__py3-none-any.whl

anemoi/utils/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.4.27'
-__version_tuple__ = version_tuple = (0, 4, 27)
+__version__ = version = '0.4.29'
+__version_tuple__ = version_tuple = (0, 4, 29)

anemoi/utils/dates.py

@@ -199,6 +199,15 @@ def as_timedelta(frequency: Union[int, str, datetime.timedelta]) -> datetime.tim
     except ValueError:
         pass
 
+    if frequency.startswith(" ") or frequency.startswith(" "):
+        frequency = frequency.strip()
+
+    if frequency.startswith("-"):
+        return -as_timedelta(frequency[1:])
+
+    if frequency.startswith("+"):
+        return as_timedelta(frequency[1:])
+
     if re.match(r"^\d+[hdms]$", frequency, re.IGNORECASE):
         unit = frequency[-1].lower()
         v = int(frequency[:-1])
@@ -261,6 +270,8 @@ def frequency_to_string(frequency: datetime.timedelta) -> str:
     frequency = frequency_to_timedelta(frequency)
 
     total_seconds = frequency.total_seconds()
+    if total_seconds < 0:
+        return f"-{frequency_to_string(-frequency)}"
     assert int(total_seconds) == total_seconds, total_seconds
     total_seconds = int(total_seconds)
 

anemoi/utils/mlflow/__init__.py

@@ -0,0 +1,8 @@
+# (C) Copyright 2024 Anemoi contributors.
+#
+# This software is licensed under the terms of the Apache Licence Version 2.0
+# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# In applying this licence, ECMWF does not waive the privileges and immunities
+# granted to it by virtue of its status as an intergovernmental organisation
+# nor does it submit to any jurisdiction.

anemoi/utils/mlflow/auth.py

@@ -0,0 +1,255 @@
+# (C) Copyright 2024 Anemoi contributors.
+#
+# This software is licensed under the terms of the Apache Licence Version 2.0
+# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# In applying this licence, ECMWF does not waive the privileges and immunities
+# granted to it by virtue of its status as an intergovernmental organisation
+# nor does it submit to any jurisdiction.
+
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from datetime import datetime
+from datetime import timezone
+from functools import wraps
+from getpass import getpass
+from typing import TYPE_CHECKING
+
+import requests
+from requests.exceptions import HTTPError
+
+from ..config import config_path
+from ..config import load_config
+from ..config import save_config
+from ..remote import robust
+from ..timer import Timer
+
+REFRESH_EXPIRE_DAYS = 29
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class TokenAuth:
+    """Manage authentication with a keycloak token server."""
+
+    config_file = "mlflow-token.json"
+
+    def __init__(
+        self,
+        url: str,
+        enabled: bool = True,
+        target_env_var: str = "MLFLOW_TRACKING_TOKEN",
+    ) -> None:
+        """Initialise the token authentication object.
+
+        Parameters
+        ----------
+        url : str
+            URL of the authentication server.
+        enabled : bool, optional
+            Set this to False to turn off authentication, by default True
+        target_env_var : str, optional
+            The environment variable to store the access token in after authenticating,
+            by default `MLFLOW_TRACKING_TOKEN`
+
+        """
+        self.url = url
+        self.target_env_var = target_env_var
+        self._enabled = enabled
+
+        config = self.load_config()
+
+        self._refresh_token = config.get("refresh_token")
+        self.refresh_expires = config.get("refresh_expires", 0)
+        self.access_token = None
+        self.access_expires = 0
+
+        # the command line tool adds a default handler to the root logger on runtime,
+        # so we init our logger here (on runtime, not on import) to avoid duplicate handlers
+        self.log = logging.getLogger(__name__)
+
+    def __call__(self) -> None:
+        self.authenticate()
+
+    @property
+    def refresh_token(self) -> str:
+        return self._refresh_token
+
+    @refresh_token.setter
+    def refresh_token(self, value: str) -> None:
+        self._refresh_token = value
+        self.refresh_expires = time.time() + (REFRESH_EXPIRE_DAYS * 86400)  # 86400 seconds in a day
+
+    @staticmethod
+    def load_config() -> dict:
+        path = config_path(TokenAuth.config_file)
+
+        if not os.path.exists(path):
+            save_config(TokenAuth.config_file, {})
+
+        if os.path.exists(path) and os.stat(path).st_mode & 0o777 != 0o600:
+            os.chmod(path, 0o600)
+
+        return load_config(TokenAuth.config_file)
+
+    def enabled(fn: Callable) -> Callable:  # noqa: N805
+        """Decorator to call or ignore a function based on the `enabled` flag."""
+
+        @wraps(fn)
+        def _wrapper(self: TokenAuth, *args, **kwargs) -> Callable | None:
+            if self._enabled:
+                return fn(self, *args, **kwargs)
+            return None
+
+        return _wrapper
+
+    @enabled
+    def login(self, force_credentials: bool = False, **kwargs: dict) -> None:
+        """Acquire a new refresh token and save it to disk.
+
+        If an existing valid refresh token is already on disk it will be used.
+        If not, or the token has expired, the user will be asked to obtain one from the API.
+
+        Refresh token expiry time is set in the `REFRESH_EXPIRE_DAYS` constant (default 29 days).
+
+        This function should be called once, interactively, right before starting a training run.
+
+        Parameters
+        ----------
+        force_credentials : bool, optional
+            Force a credential login even if a refreh token is available, by default False.
+        kwargs : dict
+            Additional keyword arguments.
+
+        Raises
+        ------
+        RuntimeError
+            A new refresh token could not be acquired.
+
+        """
+        del kwargs  # unused
+        self.log.info("🌐 Logging in to %s", self.url)
+        new_refresh_token = None
+
+        if not force_credentials and self.refresh_token and self.refresh_expires > time.time():
+            new_refresh_token = self._token_request(ignore_exc=True).get("refresh_token")
+
+        if not new_refresh_token:
+            self.log.info("📝 Please obtain a seed refresh token from %s/seed", self.url)
+            self.log.info("📝 and paste it here (you will not see the output, just press enter after pasting):")
+            self.refresh_token = getpass("Refresh Token: ")
+
+            # perform a new refresh token request to check if the seed refresh token is valid
+            new_refresh_token = self._token_request().get("refresh_token")
+
+        if not new_refresh_token:
+            msg = "❌ Failed to log in. Please try again."
+            raise RuntimeError(msg)
+
+        self.refresh_token = new_refresh_token
+        self.save()
+
+        self.log.info("✅ Successfully logged in to MLflow. Happy logging!")
+
+    @enabled
+    def authenticate(self, **kwargs: dict) -> None:
+        """Check the access token and refresh it if necessary. A new refresh token will also be acquired upon refresh.
+
+        This requires a valid refresh token to be available, obtained from the `login` method.
+
+        The access token is stored in memory and in an environment variable.
+        If the access token is still valid, this function does nothing.
+
+        This function should be called before every MLflow API request.
+
+        Raises
+        ------
+        RuntimeError
+            No refresh token is available or the token request failed.
+
+        """
+        del kwargs  # unused
+        if self.access_expires > time.time():
+            return
+
+        if not self.refresh_token or self.refresh_expires < time.time():
+            msg = "You are not logged in to MLflow. Please log in first."
+            raise RuntimeError(msg)
+
+        with Timer("Access token refreshed", self.log):
+            response = self._token_request()
+
+        self.access_token = response.get("access_token")
+        self.access_expires = time.time() + (response.get("expires_in") * 0.7)  # bit of buffer
+        self.refresh_token = response.get("refresh_token")
+
+        os.environ[self.target_env_var] = self.access_token
+
+    @enabled
+    def save(self, **kwargs: dict) -> None:
+        """Save the latest refresh token to disk."""
+        del kwargs  # unused
+        if not self.refresh_token:
+            self.log.warning("No refresh token to save.")
+            return
+
+        config = {
+            "url": self.url,
+            "refresh_token": self.refresh_token,
+            "refresh_expires": self.refresh_expires,
+        }
+        save_config(self.config_file, config)
+
+        expire_date = datetime.fromtimestamp(self.refresh_expires, tz=timezone.utc)
+        self.log.info(
+            "Your MLflow login token is valid until %s UTC",
+            expire_date.strftime("%Y-%m-%d %H:%M:%S"),
+        )
+
+    def _token_request(
+        self,
+        ignore_exc: bool = False,
+    ) -> dict:
+        path = "refreshtoken"
+        payload = {"refresh_token": self.refresh_token}
+
+        try:
+            response = self._request(path, payload)
+        except Exception:
+            if ignore_exc:
+                return {}
+            raise
+
+        return response
+
+    def _request(self, path: str, payload: dict) -> dict:
+
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+        }
+
+        try:
+            response = robust(requests.post)(
+                f"{self.url}/{path}",
+                headers=headers,
+                json=payload,
+                timeout=60,
+            )
+            response.raise_for_status()
+            response_json = response.json()
+
+            if response_json.get("status", "") != "OK":
+                error_description = response_json.get("response", "Error acquiring token.")
+                msg = f"❌ {error_description}"
+                raise RuntimeError(msg)
+
+            return response_json["response"]
+        except HTTPError:
+            self.log.exception("HTTP error occurred")
+            raise

anemoi/utils/mlflow/client.py

@@ -0,0 +1,76 @@
+# (C) Copyright 2024 Anemoi contributors.
+#
+# This software is licensed under the terms of the Apache Licence Version 2.0
+# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# In applying this licence, ECMWF does not waive the privileges and immunities
+# granted to it by virtue of its status as an intergovernmental organisation
+# nor does it submit to any jurisdiction.
+
+
+from __future__ import annotations
+
+from typing import Any
+
+try:
+    from mlflow import MlflowClient
+except ImportError:
+    raise ImportError(
+        "The `mlflow` package is required to use AnemoiMLflowclient. Please install it with `pip install mlflow`."
+    )
+
+from .auth import TokenAuth
+from .utils import health_check
+
+
+class AnemoiMlflowClient(MlflowClient):
+    """Anemoi extension of the MLflow client with token authentication support."""
+
+    def __init__(
+        self,
+        tracking_uri: str,
+        *args,
+        authentication: bool = False,
+        check_health: bool = True,
+        **kwargs,
+    ) -> None:
+        """Behaves like a normal `mlflow.MlflowClient` but with token authentication injected on every call.
+
+        Parameters
+        ----------
+        tracking_uri : str
+            The URI of the MLflow tracking server.
+        authentication : bool, optional
+            Enable token authentication, by default False
+        check_health : bool, optional
+            Check the health of the MLflow server on init, by default True
+        *args : Any
+            Additional arguments to pass to the MLflow client.
+        **kwargs : Any
+            Additional keyword arguments to pass to the MLflow client.
+
+        """
+        self.anemoi_auth = TokenAuth(tracking_uri, enabled=authentication)
+        if check_health:
+            super().__getattribute__("anemoi_auth").authenticate()
+            health_check(tracking_uri)
+        super().__init__(tracking_uri, *args, **kwargs)
+
+    def __getattribute__(self, name: str) -> Any:
+        """Intercept attribute access and inject authentication."""
+        attr = super().__getattribute__(name)
+        if callable(attr) and name != "anemoi_auth":
+            super().__getattribute__("anemoi_auth").authenticate()
+        return attr
+
+    def login(self, force_credentials: bool = False, **kwargs) -> None:
+        """Explicitly log in to the MLflow server by acquiring or refreshing the token.
+
+        Parameters
+        ----------
+        force_credentials : bool, optional
+            Force a credential login even if a refresh token is available, by default False.
+        kwargs : dict
+            Additional keyword arguments passed to the underlying TokenAuth.login.
+        """
+        self.anemoi_auth.login(force_credentials=force_credentials, **kwargs)

anemoi/utils/mlflow/utils.py

@@ -0,0 +1,44 @@
+# (C) Copyright 2024 Anemoi contributors.
+#
+# This software is licensed under the terms of the Apache Licence Version 2.0
+# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# In applying this licence, ECMWF does not waive the privileges and immunities
+# granted to it by virtue of its status as an intergovernmental organisation
+# nor does it submit to any jurisdiction.
+from __future__ import annotations
+
+import os
+
+import requests
+
+from ..remote import robust
+
+
+def health_check(tracking_uri: str) -> None:
+    """Query the health endpoint of an MLflow server.
+
+    If the server is not reachable, raise an error and remind the user that authentication may be required.
+
+    Raises
+    ------
+    ConnectionError
+        If the server is not reachable.
+
+    """
+    token = os.getenv("MLFLOW_TRACKING_TOKEN")
+
+    headers = {"Authorization": f"Bearer {token}"}
+    response = robust(requests.get, retry_after=30, maximum_tries=10)(
+        f"{tracking_uri}/health",
+        headers=headers,
+        timeout=60,
+    )
+
+    if response.text == "OK":
+        return
+
+    error_msg = f"Could not connect to MLflow server at {tracking_uri}. "
+    if not token:
+        error_msg += "The server may require authentication, did you forget to turn it on?"
+    raise ConnectionError(error_msg)

anemoi/utils/sanitise.py

@@ -17,19 +17,24 @@ from urllib.parse import urlencode
 from urllib.parse import urlparse
 from urllib.parse import urlunparse
 
-# Patterns used but earthkit-data for url-patterns and path-patterns
+# Patterns used by earthkit-data for url-patterns and path-patterns
 
-RE1 = re.compile(r"{([^}]*)}")
-RE2 = re.compile(r"\(([^}]*)\)")
+RE1 = re.compile(r"{([^}]*)}")  # {*}
+RE2 = re.compile(r"\(([^}]*)\)")  # (*)
 
 
-def sanitise(obj: Any) -> Any:
-    """Sanitise an object by replacing all full paths with shortened versions and URL passwords with '***'.
+def sanitise(obj: Any, level=1) -> Any:
+    """Sanitise an object by replacing all full paths with shortened versions and URL credentials with '***'.
 
     Parameters
     ----------
     obj : Any
         The object to sanitise.
+    level : int, optional
+        The level of sanitation. The higher levels will also apply the levels below it.
+        - 1: Shorten file paths to file name and hide credentials in URLs (default).
+        - 2: Hide hostnames in URLs.
+        - 3: Hide full file paths and URLs.
 
     Returns
     -------
@@ -37,6 +42,8 @@ def sanitise(obj: Any) -> Any:
         The sanitised object.
     """
 
+    assert level in (1, 2, 3), "level must be 1, 2 or 3"
+
     if isinstance(obj, dict):
         return {sanitise(k): sanitise(v) for k, v in obj.items()}
 
@@ -47,29 +54,21 @@ def sanitise(obj: Any) -> Any:
         return tuple(sanitise(v) for v in obj)
 
     if isinstance(obj, str):
-        return _sanitise_string(obj)
+        return _sanitise_string(obj, level)
 
     return obj
 
 
-def _sanitise_string(obj: str) -> str:
-    """Sanitise a string by replacing full paths and URL passwords.
-
-    Parameters
-    ----------
-    obj : str
-        The string to sanitise.
-
-    Returns
-    -------
-    str
-        The sanitised string.
-    """
+def _sanitise_string(obj: str, level=1) -> str:
+    """Sanitise a string by replacing full paths and URL passwords."""
 
     parsed = urlparse(obj, allow_fragments=True)
 
     if parsed.scheme and parsed.scheme[0].isalpha():
-        return _sanitise_url(parsed)
+        return _sanitise_url(parsed, level)
+
+    if level > 2:
+        return "hidden"
 
     if obj.startswith("/") or obj.startswith("~"):
         return _sanitise_path(obj)
@@ -77,19 +76,8 @@ def _sanitise_string(obj: str) -> str:
     return obj
 
 
-def _sanitise_url(parsed: Any) -> str:
-    """Sanitise a URL by replacing passwords with '***'.
-
-    Parameters
-    ----------
-    parsed : Any
-        The parsed URL.
-
-    Returns
-    -------
-    str
-        The sanitised URL.
-    """
+def _sanitise_url(parsed: Any, level=1) -> str:
+    """Sanitise a URL by replacing passwords with '***'."""
 
     LIST = [
         "pass",
@@ -107,6 +95,9 @@ def _sanitise_url(parsed: Any) -> str:
         "_api_key",
         "username",
         "login",
+        "auth",
+        "auth_token",
+        "auth_key",
     ]
 
     scheme, netloc, path, params, query, fragment = parsed
@@ -130,26 +121,25 @@ def _sanitise_url(parsed: Any) -> str:
                 qs[k] = "hidden"
         params = urlencode(qs, doseq=True)
 
-    return urlunparse([scheme, netloc, path, params, query, fragment])
+    if level > 1:
+        if (bits := netloc.split("@")) and len(bits) > 1:
+            netloc = f"{bits[0]}@hidden"
+        else:
+            netloc = "hidden"
 
+    if level > 2:
+        return urlunparse([scheme, netloc, "", "", "", ""])
 
-def _sanitise_path(path: str) -> str:
-    """Sanitise a file path by shortening it.
+    return urlunparse([scheme, netloc, path, params, query, fragment])
 
-    Parameters
-    ----------
-    path : str
-        The file path to sanitise.
 
-    Returns
-    -------
-    str
-        The sanitised file path.
-    """
+def _sanitise_path(path: str) -> str:
+    """Sanitise a file path by shortening it."""
     bits = list(reversed(Path(path).parts))
     result = [bits.pop(0)]
     for bit in bits:
         if RE1.match(bit) or RE2.match(bit):
+            # keep earthkit-data folder patterns
             result.append(bit)
             continue
         if result[-1] == "...":

{anemoi_utils-0.4.27.dist-info → anemoi_utils-0.4.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anemoi-utils
-Version: 0.4.27
+Version: 0.4.29
 Summary: A package to hold various functions to support training of ML models on ECMWF data.
 Author-email: "European Centre for Medium-Range Weather Forecasts (ECMWF)" <software.support@ecmwf.int>
 License:                                  Apache License
@@ -236,7 +236,7 @@ Requires-Dist: rich
 Requires-Dist: tomli; python_version < "3.11"
 Requires-Dist: tqdm
 Provides-Extra: all
-Requires-Dist: anemoi-utils[grib,provenance,s3,text]; extra == "all"
+Requires-Dist: anemoi-utils[grib,mlflow,provenance,s3,text]; extra == "all"
 Provides-Extra: dev
 Requires-Dist: anemoi-utils[all,docs,tests]; extra == "dev"
 Provides-Extra: docs
@@ -250,13 +250,18 @@ Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Requires-Dist: termcolor; extra == "docs"
 Provides-Extra: grib
 Requires-Dist: requests; extra == "grib"
+Provides-Extra: mlflow
+Requires-Dist: mlflow-skinny>=2.11.1; extra == "mlflow"
+Requires-Dist: requests; extra == "mlflow"
 Provides-Extra: provenance
 Requires-Dist: gitpython; extra == "provenance"
 Requires-Dist: nvsmi; extra == "provenance"
 Provides-Extra: s3
 Requires-Dist: boto3>1.36; extra == "s3"
 Provides-Extra: tests
+Requires-Dist: anemoi-utils[mlflow]; extra == "tests"
 Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-mock>=3; extra == "tests"
 Provides-Extra: text
 Requires-Dist: termcolor; extra == "text"
 Requires-Dist: wcwidth; extra == "text"

{anemoi_utils-0.4.27.dist-info → anemoi_utils-0.4.29.dist-info}/RECORD

@@ -1,12 +1,12 @@
 anemoi/utils/__init__.py,sha256=uVhpF-VjIl_4mMywOVtgTutgsdIsqz-xdkwxeMhzuag,730
 anemoi/utils/__main__.py,sha256=6LlE4MYrPvqqrykxXh7XMi50UZteUY59NeM8P9Zs2dU,910
-anemoi/utils/_version.py,sha256=l2RpdEWLXHjIi56KlS-u-66k8wBi9yvFH_NPLD7QkmQ,513
+anemoi/utils/_version.py,sha256=M33mpOYpqw35qLoEcg5GxMG4YQ25eohx8wEQkM6FTT0,513
 anemoi/utils/caching.py,sha256=rXbeAmpBcMbbfN4EVblaHWKicsrtx1otER84FEBtz98,6183
 anemoi/utils/checkpoints.py,sha256=PydBqA-wI8_05zU-3yT-ZP53GnvuqB7vPXl-w6-9XX8,9541
 anemoi/utils/cli.py,sha256=Cd3ESQkNWecbGnJjkR_SKHdFPETJWFrHqg5ovtANDKs,6522
 anemoi/utils/compatibility.py,sha256=wRBRMmxQP88rNcWiP5gqXliwYQbBv1iCAsDjcCRi5UY,2234
 anemoi/utils/config.py,sha256=EEfcSxW2CD6fFOzDtqz_uYlMKuYq4X5QinJW_8GBYj4,17325
-anemoi/utils/dates.py,sha256=CnY6JOdpk0T-waPEowMRTkcMzxcN0GcjPVtLkwH_byw,17196
+anemoi/utils/dates.py,sha256=Ew11G-Upl0VM9R9Sgg3Be6KIkXfpMCD69kgiao7Xv48,17534
 anemoi/utils/devtools.py,sha256=W3OBu96MkXRIl7Qh1SE5Zd6aB1R0QlnmlrlpBYM0fVY,3527
 anemoi/utils/grib.py,sha256=201WcxjjAl92Y2HX2kZ2S8Qr5dN-oG7nV-vQLaybzP4,3610
 anemoi/utils/grids.py,sha256=VlhuN8MZDBu-G50QFI1XHV9IXLway2LpvI9X8sDjb5s,6047
@@ -17,7 +17,7 @@ anemoi/utils/provenance.py,sha256=iTsn4r-VPq2D8tSHPSuAIqG077_opkqMT42G03DRWJg,14
 anemoi/utils/registry.py,sha256=e3nOIRyMYQ-mpEvaHAv5tuvMYNbkJ5yz94ns7BnvkjM,9717
 anemoi/utils/rules.py,sha256=VspUoPmw7tijrs6l_wl4vDjr_zVQsFjx9ITiBSvxgc8,6972
 anemoi/utils/s3.py,sha256=xMT48kbcelcjjqsaU567WI3oZ5eqo88Rlgyx5ECszAU,4074
-anemoi/utils/sanitise.py,sha256=ZYGdSX6qihQANr3pHZjbKnoapnzP1KcrWdW1Ul1mOGk,3668
+anemoi/utils/sanitise.py,sha256=XkQzibDbu-VFJkJC4WcB9ovkcTkVAynXtkn1Tlc2CC4,4019
 anemoi/utils/sanitize.py,sha256=43ZKDcfVpeXSsJ9TFEc9aZnD6oe2cUh151XnDspM98M,462
 anemoi/utils/testing.py,sha256=DeTAkmg-RCMPXBBRUy_Gti5UJriUPRKT6ruE3JL2GVc,10372
 anemoi/utils/text.py,sha256=HkzIvi24obDceFLpJEwBJ9PmPrJUkQN2TrElJ-A87gU,14441
@@ -30,14 +30,18 @@ anemoi/utils/commands/transfer.py,sha256=29o1RQ46dCJ6kTD1sbxp8XFgB-Qx3RceMccypBM
 anemoi/utils/mars/__init__.py,sha256=b-Lc3L1TAQd9ODs0Z1YSJzgZCO1K_M3DSgx_yd2qXvM,2724
 anemoi/utils/mars/mars.yaml,sha256=R0dujp75lLA4wCWhPeOQnzJ45WZAYLT8gpx509cBFlc,66
 anemoi/utils/mars/requests.py,sha256=VFMHBVAAl0_2lOcMBa1lvaKHctN0lDJsI6_U4BucGew,1142
+anemoi/utils/mlflow/__init__.py,sha256=hCW0QcLHJmE-C1r38P27_ZOvCLNewex5iQEtZqx2ckI,393
+anemoi/utils/mlflow/auth.py,sha256=Zgn2Ru7GE99_ZTBeskl5M1WnrlEGNU9XxsRVgVoUwmM,8376
+anemoi/utils/mlflow/client.py,sha256=Y34ceLcp1-H0XTt8h8-IhHKX9bApc_QJcgVrzZKtabY,2752
+anemoi/utils/mlflow/utils.py,sha256=0d-dp7YmDLJ59ikJWUcZooqBIdrNDxPShDQubcX-a3k,1310
 anemoi/utils/remote/__init__.py,sha256=7nHu-LRspYW2Fx9GNLjsxpytAUIvhIbOjb0Xmxb-33s,20988
 anemoi/utils/remote/s3.py,sha256=DxO_TjmetX_r3ZvGaHjpz40oqvcQYP3Vd_A4ojMGlSA,21379
 anemoi/utils/remote/ssh.py,sha256=xNtsawh8okytCKRehkRCVExbHZj-CRUQNormEHglfuw,8088
 anemoi/utils/schemas/__init__.py,sha256=nkinKlsPLPXEjfTYQT1mpKC4cvs-14w_zBkDRxakwxw,698
 anemoi/utils/schemas/errors.py,sha256=lgOXzVTYzAE0qWQf3OZ42vCWixv8lilSqLLhzARBmvI,1831
-anemoi_utils-0.4.27.dist-info/licenses/LICENSE,sha256=8HznKF1Vi2IvfLsKNE5A2iVyiri3pRjRPvPC9kxs6qk,11354
-anemoi_utils-0.4.27.dist-info/METADATA,sha256=zqysYlsP5gsTcGN93z7KW5rSIehOpVjg85arxug6MZE,15486
-anemoi_utils-0.4.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-anemoi_utils-0.4.27.dist-info/entry_points.txt,sha256=LENOkn88xzFQo-V59AKoA_F_cfYQTJYtrNTtf37YgHY,60
-anemoi_utils-0.4.27.dist-info/top_level.txt,sha256=DYn8VPs-fNwr7fNH9XIBqeXIwiYYd2E2k5-dUFFqUz0,7
-anemoi_utils-0.4.27.dist-info/RECORD,,
+anemoi_utils-0.4.29.dist-info/licenses/LICENSE,sha256=8HznKF1Vi2IvfLsKNE5A2iVyiri3pRjRPvPC9kxs6qk,11354
+anemoi_utils-0.4.29.dist-info/METADATA,sha256=v5sHgt4rZA9mZ2YW1pMO0S76mlvZ09hoB3Q-G7xp6-Y,15717
+anemoi_utils-0.4.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+anemoi_utils-0.4.29.dist-info/entry_points.txt,sha256=LENOkn88xzFQo-V59AKoA_F_cfYQTJYtrNTtf37YgHY,60
+anemoi_utils-0.4.29.dist-info/top_level.txt,sha256=DYn8VPs-fNwr7fNH9XIBqeXIwiYYd2E2k5-dUFFqUz0,7
+anemoi_utils-0.4.29.dist-info/RECORD,,