anemoi-utils 0.4.26__py3-none-any.whl → 0.4.28__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.26'
-__version_tuple__ = version_tuple = (0, 4, 26)
+__version__ = version = '0.4.28'
+__version_tuple__ = version_tuple = (0, 4, 28)

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,246 @@
+# (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 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:
+        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,159 @@
+# (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 functools
+import os
+from typing import Any
+
+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)
+
+
+def expand_iterables(
+    params: dict[str, Any],
+    *,
+    size_threshold: int | None = None,
+    recursive: bool = True,
+    delimiter: str = ".",
+) -> dict[str, Any]:
+    """Expand any iterable values to the form {key.i: value_i}.
+
+    If expanded will also add {key.all: [value_0, value_1, ...], key.length: len([value_0, value_1, ...])}.
+
+    If `size_threshold` is not None, expand the iterable only if the length of str(value) is
+    greater than `size_threshold`.
+
+    Parameters
+    ----------
+    params : dict[str, Any]
+        Parameters to be expanded.
+    size_threshold : int | None, optional
+        Threshold of str(value) to expand iterable at.
+        Default is None.
+    recursive : bool, optional
+        Expand nested dictionaries.
+        Default is True.
+    delimiter: str, optional
+        Delimiter to use for keys.
+        Default is ".".
+
+    Returns
+    -------
+    dict[str, Any]
+        Dictionary with all iterable values expanded.
+
+    Examples
+    --------
+        >>> expand_iterables({'a': ['a', 'b', 'c']})
+        {'a.0': 'a', 'a.1': 'b', 'a.2': 'c', 'a.all': ['a', 'b', 'c'], 'a.length': 3}
+        >>> expand_iterables({'a': {'b': ['a', 'b', 'c']}})
+        {'a': {'b.0': 'a', 'b.1': 'b', 'b.2': 'c', 'b.all': ['a', 'b', 'c'], 'b.length': 3}}
+        >>> expand_iterables({'a': ['a', 'b', 'c']}, size_threshold=100)
+        {'a': ['a', 'b', 'c']}
+        >>> expand_iterables({'a': [[0,1,2], 'b', 'c']})
+        {'a.0': {0: 0, 1: 1, 2: 2}, 'a.1': 'b', 'a.2': 'c', 'a.all': [[0, 1, 2], 'b', 'c'], 'a.length': 3}
+    """
+
+    def should_be_expanded(x: Any) -> bool:
+        return size_threshold is None or len(str(x)) > size_threshold
+
+    nested_func = functools.partial(expand_iterables, size_threshold=size_threshold, recursive=recursive)
+
+    def expand(val: dict | list) -> dict[str, Any]:
+        if not recursive:
+            return val
+        if isinstance(val, dict):
+            return nested_func(val)
+        if isinstance(val, list):
+            return nested_func(dict(enumerate(val)))
+        return val
+
+    expanded_params = {}
+
+    for key, value in params.items():
+        if isinstance(value, (list, tuple)):
+            if should_be_expanded(value):
+                for i, v in enumerate(value):
+                    expanded_params[f"{key}{delimiter}{i}"] = expand(v)
+
+                expanded_params[f"{key}{delimiter}all"] = value
+                expanded_params[f"{key}{delimiter}length"] = len(value)
+            else:
+                expanded_params[key] = value
+        else:
+            expanded_params[key] = expand(value)
+    return expanded_params
+
+
+def clean_config_params(params: dict[str, Any]) -> dict[str, Any]:
+    """Clean up params to avoid issues with mlflow.
+
+    Too many logged params will make the server take longer to render the
+    experiment.
+
+    Parameters
+    ----------
+    params : dict[str, Any]
+        Parameters to clean up.
+
+    Returns
+    -------
+    dict[str, Any]
+        Cleaned up params ready for MlFlow.
+    """
+    prefixes_to_remove = [
+        "hardware",
+        "data",
+        "dataloader",
+        "model",
+        "training",
+        "diagnostics",
+        "graph",
+        "metadata.config",
+        "config.dataset.sourcesmetadata.dataset.variables_metadata",
+        "metadata.dataset.sources",
+        "metadata.dataset.specific",
+        "metadata.dataset.variables_metadata",
+    ]
+
+    keys_to_remove = [key for key in params if any(key.startswith(prefix) for prefix in prefixes_to_remove)]
+    for key in keys_to_remove:
+        del params[key]
+    return params

anemoi/utils/remote/s3.py

@@ -47,8 +47,8 @@ SECRETS = ["aws_access_key_id", "aws_secret_access_key"]
 thread_local = threading.local()
 
 
-def s3_client(bucket: str, *, region: str = None, service: str = "s3") -> Any:
-    """Get an S3 client for the specified bucket and region.
+def _s3_config(bucket: str, *, region: str = None) -> Any:
+    """Get an S3 client config for the specified bucket and region.
 
     Parameters
     ----------
@@ -56,31 +56,15 @@ def s3_client(bucket: str, *, region: str = None, service: str = "s3") -> Any:
         The name of the S3 bucket.
     region : str, optional
         The AWS region of the S3 bucket.
-    service : str, optional
-        The AWS service to use, default is "s3".
 
     Returns
     -------
     Any
         The S3 client.
     """
-    import boto3
     from botocore import UNSIGNED
-    from botocore.client import Config
 
-    if not hasattr(thread_local, "s3_clients"):
-        thread_local.s3_clients = {}
-
-    key = f"{bucket}-{region}-{service}"
-
-    if key in thread_local.s3_clients:
-        return thread_local.s3_clients[key]
-
-    boto3_config = dict(
-        max_pool_connections=25,
-        request_checksum_calculation="when_required",
-        response_checksum_validation="when_required",
-    )
+    boto3_config = {}
 
     if region:
         # This is using AWS
@@ -129,6 +113,85 @@ def s3_client(bucket: str, *, region: str = None, service: str = "s3") -> Any:
             boto3_config.update(options["config"])
             del options["config"]
 
+    def _(options):
+
+        def __(k, v):
+            if k in SECRETS:
+                return "***"
+            return v
+
+        if isinstance(options, dict):
+            return {k: __(k, v) for k, v in options.items()}
+
+        if isinstance(options, list):
+            return [_(o) for o in options]
+
+        return options
+
+    LOG.debug(f"Using S3 options: {_(options)}")
+
+    return boto3_config, options
+
+
+def s3_options(bucket: str, *, region: str = None, service: str = "s3") -> dict:
+    """Get the S3 configuration for the specified bucket and region.
+
+    Parameters
+    ----------
+    bucket : str
+        The name of the S3 bucket.
+    region : str, optional
+        The AWS region of the S3 bucket.
+    service : str, optional
+        The AWS service to use, default is "s3".
+
+    Returns
+    -------
+    dict
+        The S3 configuration.
+    """
+    _, options = _s3_config(bucket, region=region)
+    return options
+
+
+def s3_client(bucket: str, *, region: str = None, service: str = "s3") -> Any:
+    """Get an S3 client for the specified bucket and region.
+
+    Parameters
+    ----------
+    bucket : str
+        The name of the S3 bucket.
+    region : str, optional
+        The AWS region of the S3 bucket.
+    service : str, optional
+        The AWS service to use, default is "s3".
+
+    Returns
+    -------
+    Any
+        The S3 client.
+    """
+    import boto3
+    from botocore.client import Config
+
+    if not hasattr(thread_local, "s3_clients"):
+        thread_local.s3_clients = {}
+
+    key = f"{bucket}-{region}-{service}"
+
+    if key in thread_local.s3_clients:
+        return thread_local.s3_clients[key]
+
+    boto3_config, options = _s3_config(bucket, region=region)
+
+    boto3_config.update(
+        dict(
+            max_pool_connections=25,
+            request_checksum_calculation="when_required",
+            response_checksum_validation="when_required",
+        )
+    )
+
     options["config"] = Config(**boto3_config)
 
     def _(options):

{anemoi_utils-0.4.26.dist-info → anemoi_utils-0.4.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anemoi-utils
-Version: 0.4.26
+Version: 0.4.28
 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,6 +250,9 @@ 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>=2.11.1; extra == "mlflow"
+Requires-Dist: requests; extra == "mlflow"
 Provides-Extra: provenance
 Requires-Dist: gitpython; extra == "provenance"
 Requires-Dist: nvsmi; extra == "provenance"
@@ -257,6 +260,7 @@ Provides-Extra: s3
 Requires-Dist: boto3>1.36; extra == "s3"
 Provides-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.26.dist-info → anemoi_utils-0.4.28.dist-info}/RECORD

@@ -1,6 +1,6 @@
 anemoi/utils/__init__.py,sha256=uVhpF-VjIl_4mMywOVtgTutgsdIsqz-xdkwxeMhzuag,730
 anemoi/utils/__main__.py,sha256=6LlE4MYrPvqqrykxXh7XMi50UZteUY59NeM8P9Zs2dU,910
-anemoi/utils/_version.py,sha256=ggjVlIoxYrdpYCbFUc7ixm914S2kJVBvieeqeCBnvjY,513
+anemoi/utils/_version.py,sha256=B7w9p3e_jRrhCAcRVz7MulIQ9D0PoLvF57YvgUIilfM,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
@@ -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=hMuS3vrX4VDfEFiIlRM_7U6XHvYRGU149doi4jlgsW8,8092
+anemoi/utils/mlflow/client.py,sha256=Y34ceLcp1-H0XTt8h8-IhHKX9bApc_QJcgVrzZKtabY,2752
+anemoi/utils/mlflow/utils.py,sha256=2zwNqkS69TXKz-vUy8cdGckJA7jjtjbUZ6P7cj9U8OM,4940
 anemoi/utils/remote/__init__.py,sha256=7nHu-LRspYW2Fx9GNLjsxpytAUIvhIbOjb0Xmxb-33s,20988
-anemoi/utils/remote/s3.py,sha256=VgxNuJpJBnfxwkkV9TyrSkf7fjIuHqy1YG9vRdj9QRc,19978
+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.26.dist-info/licenses/LICENSE,sha256=8HznKF1Vi2IvfLsKNE5A2iVyiri3pRjRPvPC9kxs6qk,11354
-anemoi_utils-0.4.26.dist-info/METADATA,sha256=tx5q6lKfqmvh5eq9ty0Pw1e8LtzX4wysYzm_lVNeIQQ,15486
-anemoi_utils-0.4.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-anemoi_utils-0.4.26.dist-info/entry_points.txt,sha256=LENOkn88xzFQo-V59AKoA_F_cfYQTJYtrNTtf37YgHY,60
-anemoi_utils-0.4.26.dist-info/top_level.txt,sha256=DYn8VPs-fNwr7fNH9XIBqeXIwiYYd2E2k5-dUFFqUz0,7
-anemoi_utils-0.4.26.dist-info/RECORD,,
+anemoi_utils-0.4.28.dist-info/licenses/LICENSE,sha256=8HznKF1Vi2IvfLsKNE5A2iVyiri3pRjRPvPC9kxs6qk,11354
+anemoi_utils-0.4.28.dist-info/METADATA,sha256=CxRjsdH4Audnqnun7v-FSgCNxxSVFtwIuSQqgnoIHUk,15656
+anemoi_utils-0.4.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+anemoi_utils-0.4.28.dist-info/entry_points.txt,sha256=LENOkn88xzFQo-V59AKoA_F_cfYQTJYtrNTtf37YgHY,60
+anemoi_utils-0.4.28.dist-info/top_level.txt,sha256=DYn8VPs-fNwr7fNH9XIBqeXIwiYYd2E2k5-dUFFqUz0,7
+anemoi_utils-0.4.28.dist-info/RECORD,,