anemoi-datasets 0.5.25__py3-none-any.whl → 0.5.27__py3-none-any.whl

anemoi/datasets/data/missing.py

@@ -12,11 +12,6 @@ import datetime
 import logging
 from functools import cached_property
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Set
-from typing import Tuple
-from typing import Union
 
 import numpy as np
 from numpy.typing import NDArray
@@ -49,7 +44,7 @@ class MissingDates(Forwards):
         List of missing dates.
     """
 
-    def __init__(self, dataset: Dataset, missing_dates: List[Union[int, str]]) -> None:
+    def __init__(self, dataset: Dataset, missing_dates: list[int | str]) -> None:
         """Initializes the MissingDates class.
 
         Parameters
@@ -80,13 +75,13 @@ class MissingDates(Forwards):
                     self.missing_dates.append(date)
 
         n = self.forward._len
-        self._missing = set(i for i in self._missing if 0 <= i < n)
+        self._missing = {i for i in self._missing if 0 <= i < n}
         self.missing_dates = sorted(to_datetime(x) for x in self.missing_dates)
 
         assert len(self._missing), "No dates to force missing"
 
     @cached_property
-    def missing(self) -> Set[int]:
+    def missing(self) -> set[int]:
         """Returns the set of missing indices."""
         return self._missing.union(self.forward.missing)
 
@@ -148,7 +143,7 @@ class MissingDates(Forwards):
         raise MissingDateError(f"Date {self.forward.dates[n]} is missing (index={n})")
 
     @property
-    def reason(self) -> Dict[str, Any]:
+    def reason(self) -> dict[str, Any]:
         """Provides the reason for missing dates."""
         return {"missing_dates": self.missing_dates}
 
@@ -162,7 +157,7 @@ class MissingDates(Forwards):
         """
         return Node(self, [self.forward.tree()], **self.reason)
 
-    def forwards_subclass_metadata_specific(self) -> Dict[str, Any]:
+    def forwards_subclass_metadata_specific(self) -> dict[str, Any]:
         """Provides metadata specific to the subclass.
 
         Returns
@@ -184,7 +179,7 @@ class SkipMissingDates(Forwards):
         The expected access pattern.
     """
 
-    def __init__(self, dataset: Dataset, expected_access: Union[int, slice]) -> None:
+    def __init__(self, dataset: Dataset, expected_access: int | slice) -> None:
         """Initializes the SkipMissingDates class.
 
         Parameters
@@ -285,7 +280,7 @@ class SkipMissingDates(Forwards):
         return tuple(np.stack(_) for _ in result)
 
     @debug_indexing
-    def _get_slice(self, s: slice) -> Tuple[NDArray[Any], ...]:
+    def _get_slice(self, s: slice) -> tuple[NDArray[Any], ...]:
         """Retrieves a slice of items.
 
         Parameters
@@ -303,7 +298,7 @@ class SkipMissingDates(Forwards):
         return tuple(np.stack(_) for _ in result)
 
     @debug_indexing
-    def __getitem__(self, n: FullIndex) -> Tuple[NDArray[Any], ...]:
+    def __getitem__(self, n: FullIndex) -> tuple[NDArray[Any], ...]:
         """Retrieves the item at the given index.
 
         Parameters
@@ -339,7 +334,7 @@ class SkipMissingDates(Forwards):
         """
         return Node(self, [self.forward.tree()], expected_access=self.expected_access)
 
-    def forwards_subclass_metadata_specific(self) -> Dict[str, Any]:
+    def forwards_subclass_metadata_specific(self) -> dict[str, Any]:
         """Provides metadata specific to the subclass.
 
         Returns
@@ -404,7 +399,7 @@ class MissingDataset(Forwards):
         return self._dates
 
     @property
-    def missing(self) -> Set[int]:
+    def missing(self) -> set[int]:
         """Returns the set of missing indices."""
         return self._missing
 
@@ -436,7 +431,7 @@ class MissingDataset(Forwards):
         """
         return Node(self, [self.forward.tree()], start=self.start, end=self.end)
 
-    def forwards_subclass_metadata_specific(self) -> Dict[str, Any]:
+    def forwards_subclass_metadata_specific(self) -> dict[str, Any]:
         """Provides metadata specific to the subclass.
 
         Returns

anemoi/datasets/data/observations/__init__.py

@@ -10,8 +10,6 @@ import logging
 import os
 from functools import cached_property
 from typing import Any
-from typing import Dict
-from typing import Tuple
 
 import numpy as np
 from anemoi.utils.dates import frequency_to_timedelta
@@ -82,10 +80,8 @@ class ObservationsBase(Dataset):
         #    return [self.getitem(j) for j in i]
 
         raise ValueError(
-            (
-                f"Expected int, got {i} of type {type(i)}. Only int is supported to index "
-                "observations datasets. Please use a second [] to select part of the data [i][a,b,c]"
-            )
+            f"Expected int, got {i} of type {type(i)}. Only int is supported to index "
+            "observations datasets. Please use a second [] to select part of the data [i][a,b,c]"
         )
 
     @property
@@ -195,13 +191,11 @@ class ObservationsZarr(ObservationsBase):
 
         if len(self.forward) != len(self.dates):
             raise ValueError(
-                (
-                    f"Dates are not consistent with the number of items in the dataset. "
-                    f"The dataset contains {len(self.forward)} time windows. "
-                    f"This is not compatible with the "
-                    f"{len(self.dates)} requested dates with frequency={frequency_hours}"
-                    f"{self.dates[0]}, {self.dates[1]}, ..., {self.dates[-2]}, {self.dates[-1]} "
-                )
+                f"Dates are not consistent with the number of items in the dataset. "
+                f"The dataset contains {len(self.forward)} time windows. "
+                f"This is not compatible with the "
+                f"{len(self.dates)} requested dates with frequency={frequency_hours}"
+                f"{self.dates[0]}, {self.dates[1]}, ..., {self.dates[-2]}, {self.dates[-1]} "
             )
 
     @property
@@ -307,7 +301,7 @@ class ObservationsZarr(ObservationsBase):
         return f"Observations({os.path.basename(self.path)}, {self.dates[0]};{self.dates[-1]}, {len(self)})"
 
 
-def observations_factory(args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> ObservationsBase:
+def observations_factory(args: tuple[Any, ...], kwargs: dict[str, Any]) -> ObservationsBase:
     observations = kwargs.pop("observations")
 
     if not isinstance(observations, dict):

anemoi/datasets/data/padded.py

@@ -12,8 +12,6 @@ import datetime
 import logging
 from functools import cached_property
 from typing import Any
-from typing import Dict
-from typing import Set
 
 import numpy as np
 from anemoi.utils.dates import frequency_to_timedelta
@@ -38,7 +36,7 @@ class Padded(Forwards):
     _after: int = 0
     _inside: int = 0
 
-    def __init__(self, dataset: Dataset, start: str, end: str, frequency: str, reason: Dict[str, Any]) -> None:
+    def __init__(self, dataset: Dataset, start: str, end: str, frequency: str, reason: dict[str, Any]) -> None:
         """Create a padded subset of a dataset.
 
         Attributes:
@@ -195,7 +193,7 @@ class Padded(Forwards):
         return (len(self.dates),) + self.dataset.shape[1:]
 
     @cached_property
-    def missing(self) -> Set[int]:
+    def missing(self) -> set[int]:
         raise NotImplementedError("Need to decide whether to include the added dates as missing or not")
         # return self.forward.missing
 
@@ -207,7 +205,7 @@ class Padded(Forwards):
         """
         return Node(self, [self.dataset.tree()], **self.reason)
 
-    def forwards_subclass_metadata_specific(self) -> Dict[str, Any]:
+    def forwards_subclass_metadata_specific(self) -> dict[str, Any]:
         """Get the metadata specific to the forwards subclass.
 
         Returns:

anemoi/datasets/data/records/backends/__init__.py

@@ -35,7 +35,7 @@ class Npz1Backend(Backend):
             return dict(np.load(f))
 
     def read_metadata(self):
-        with open(os.path.join(self.path, "metadata.json"), "r") as f:
+        with open(os.path.join(self.path, "metadata.json")) as f:
             return json.load(f)
 
     def read_statistics(self):
@@ -56,7 +56,7 @@ class Npz2Backend(Backend):
             return dict(np.load(f))
 
     def read_metadata(self):
-        with open(os.path.join(self.path, "metadata.json"), "r") as f:
+        with open(os.path.join(self.path, "metadata.json")) as f:
             return json.load(f)
 
     def read_statistics(self):

anemoi/datasets/data/rescale.py

@@ -12,11 +12,6 @@ import datetime
 import logging
 from functools import cached_property
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Tuple
-from typing import Union
 
 import numpy as np
 from numpy.typing import NDArray
@@ -35,9 +30,7 @@ from .indexing import update_tuple
 LOG = logging.getLogger(__name__)
 
 
-def make_rescale(
-    variable: str, rescale: Union[Tuple[float, float], List[str], Dict[str, float]]
-) -> Tuple[float, float]:
+def make_rescale(variable: str, rescale: tuple[float, float] | list[str] | dict[str, float]) -> tuple[float, float]:
     """Create rescale parameters (scale and offset) based on the input rescale specification.
 
     Parameters
@@ -86,7 +79,7 @@ class Rescale(Forwards):
     """A class to apply rescaling to dataset variables."""
 
     def __init__(
-        self, dataset: Dataset, rescale: Dict[str, Union[Tuple[float, float], List[str], Dict[str, float]]]
+        self, dataset: Dataset, rescale: dict[str, tuple[float, float] | list[str] | dict[str, float]]
     ) -> None:
         """Initialize the Rescale object.
 
@@ -129,7 +122,7 @@ class Rescale(Forwards):
         """
         return Node(self, [self.forward.tree()], rescale=self.rescale)
 
-    def forwards_subclass_metadata_specific(self) -> Dict[str, Any]:
+    def forwards_subclass_metadata_specific(self) -> dict[str, Any]:
         """Get the metadata specific to the rescale subclass.
 
         Returns
@@ -204,7 +197,7 @@ class Rescale(Forwards):
         return data * self._a[0] + self._b[0]
 
     @cached_property
-    def statistics(self) -> Dict[str, NDArray[Any]]:
+    def statistics(self) -> dict[str, NDArray[Any]]:
         """Get the statistics of the rescaled data."""
         result = {}
         a = self._a.squeeze()
@@ -224,7 +217,7 @@ class Rescale(Forwards):
 
         return result
 
-    def statistics_tendencies(self, delta: Optional[datetime.timedelta] = None) -> Dict[str, NDArray[Any]]:
+    def statistics_tendencies(self, delta: datetime.timedelta | None = None) -> dict[str, NDArray[Any]]:
         """Get the tendencies of the statistics of the rescaled data.
 
         Parameters

anemoi/datasets/data/select.py

@@ -12,9 +12,6 @@ import datetime
 import logging
 from functools import cached_property
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Optional
 
 from numpy.typing import NDArray
 
@@ -37,7 +34,7 @@ LOG = logging.getLogger(__name__)
 class Select(Forwards):
     """Class to select a subset of variables from a dataset."""
 
-    def __init__(self, dataset: Dataset, indices: List[int], reason: Dict[str, Any]) -> None:
+    def __init__(self, dataset: Dataset, indices: list[int], reason: dict[str, Any]) -> None:
         """Initialize the Select class.
 
         Parameters
@@ -140,26 +137,26 @@ class Select(Forwards):
         return (len(self), len(self.indices)) + self.dataset.shape[2:]
 
     @cached_property
-    def variables(self) -> List[str]:
+    def variables(self) -> list[str]:
         """Get the variables of the dataset."""
         return [self.dataset.variables[i] for i in self.indices]
 
     @cached_property
-    def variables_metadata(self) -> Dict[str, Any]:
+    def variables_metadata(self) -> dict[str, Any]:
         """Get the metadata of the variables."""
         return {k: v for k, v in self.dataset.variables_metadata.items() if k in self.variables}
 
     @cached_property
-    def name_to_index(self) -> Dict[str, int]:
+    def name_to_index(self) -> dict[str, int]:
         """Get the mapping of variable names to indices."""
         return {k: i for i, k in enumerate(self.variables)}
 
     @cached_property
-    def statistics(self) -> Dict[str, NDArray[Any]]:
+    def statistics(self) -> dict[str, NDArray[Any]]:
         """Get the statistics of the dataset."""
         return {k: v[self.indices] for k, v in self.dataset.statistics.items()}
 
-    def statistics_tendencies(self, delta: Optional[datetime.timedelta] = None) -> Dict[str, NDArray[Any]]:
+    def statistics_tendencies(self, delta: datetime.timedelta | None = None) -> dict[str, NDArray[Any]]:
         """Get the statistical tendencies of the dataset.
 
         Parameters
@@ -176,7 +173,7 @@ class Select(Forwards):
             delta = self.frequency
         return {k: v[self.indices] for k, v in self.dataset.statistics_tendencies(delta).items()}
 
-    def metadata_specific(self, **kwargs: Any) -> Dict[str, Any]:
+    def metadata_specific(self, **kwargs: Any) -> dict[str, Any]:
         """Get the specific metadata of the dataset.
 
         Parameters
@@ -216,7 +213,7 @@ class Select(Forwards):
         """
         return Node(self, [self.dataset.tree()], **self.reason)
 
-    def forwards_subclass_metadata_specific(self) -> Dict[str, Any]:
+    def forwards_subclass_metadata_specific(self) -> dict[str, Any]:
         """Get the metadata specific to the subclass.
 
         Returns
@@ -231,7 +228,7 @@ class Select(Forwards):
 class Rename(Forwards):
     """Class to rename variables in a dataset."""
 
-    def __init__(self, dataset: Dataset, rename: Dict[str, str]) -> None:
+    def __init__(self, dataset: Dataset, rename: dict[str, str]) -> None:
         """Initialize the Rename class.
 
         Parameters
@@ -251,17 +248,17 @@ class Rename(Forwards):
         self.rename = rename
 
     @property
-    def variables(self) -> List[str]:
+    def variables(self) -> list[str]:
         """Get the renamed variables."""
         return self._variables
 
     @property
-    def variables_metadata(self) -> Dict[str, Any]:
+    def variables_metadata(self) -> dict[str, Any]:
         """Get the renamed variables metadata."""
         return self._variables_metadata
 
     @cached_property
-    def name_to_index(self) -> Dict[str, int]:
+    def name_to_index(self) -> dict[str, int]:
         """Get the mapping of renamed variable names to indices."""
         return {k: i for i, k in enumerate(self.variables)}
 
@@ -273,7 +270,7 @@ class Rename(Forwards):
         """
         return Node(self, [self.forward.tree()], rename=self.rename)
 
-    def forwards_subclass_metadata_specific(self) -> Dict[str, Any]:
+    def forwards_subclass_metadata_specific(self) -> dict[str, Any]:
         """Get the metadata specific to the subclass.
 
         Returns:

anemoi/datasets/data/statistics.py

@@ -12,9 +12,6 @@ import datetime
 import logging
 from functools import cached_property
 from typing import Any
-from typing import Dict
-from typing import Optional
-from typing import Set
 
 from numpy.typing import NDArray
 
@@ -56,11 +53,11 @@ class Statistics(Forwards):
             )
 
     @cached_property
-    def statistics(self) -> Dict[str, NDArray[Any]]:
+    def statistics(self) -> dict[str, NDArray[Any]]:
         """Get the statistics."""
         return self._statistic.statistics
 
-    def statistics_tendencies(self, delta: Optional[datetime.timedelta] = None) -> Dict[str, NDArray[Any]]:
+    def statistics_tendencies(self, delta: datetime.timedelta | None = None) -> dict[str, NDArray[Any]]:
         """Get the statistics tendencies.
 
         Parameters
@@ -77,7 +74,7 @@ class Statistics(Forwards):
             delta = self.frequency
         return self._statistic.statistics_tendencies(delta)
 
-    def forwards_subclass_metadata_specific(self) -> Dict[str, Any]:
+    def forwards_subclass_metadata_specific(self) -> dict[str, Any]:
         """Get the metadata specific to the forwards subclass.
 
         Returns
@@ -97,7 +94,7 @@ class Statistics(Forwards):
         """
         return Node(self, [self.forward.tree()])
 
-    def get_dataset_names(self, names: Set[str]) -> None:
+    def get_dataset_names(self, names: set[str]) -> None:
         """Get the dataset names.
 
         Parameters

anemoi/datasets/data/stores.py

@@ -15,11 +15,6 @@ import tempfile
 import warnings
 from functools import cached_property
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Set
-from typing import Union
 from urllib.parse import urlparse
 
 import numpy as np
@@ -90,7 +85,7 @@ class S3Store(ReadOnlyStore):
     options using the anemoi configs.
     """
 
-    def __init__(self, url: str, region: Optional[str] = None) -> None:
+    def __init__(self, url: str, region: str | None = None) -> None:
         """Initialize the S3Store with a URL and optional region."""
         from anemoi.utils.remote.s3 import s3_client
 
@@ -107,51 +102,6 @@ class S3Store(ReadOnlyStore):
         return response["Body"].read()
 
 
-class PlanetaryComputerStore(ReadOnlyStore):
-    """We write our own Store to access catalogs on Planetary Computer,
-    as it requires some extra arguments to use xr.open_zarr.
-    """
-
-    def __init__(self, data_catalog_id: str) -> None:
-        """Initialize the PlanetaryComputerStore with a data catalog ID.
-
-        Parameters
-        ----------
-        data_catalog_id : str
-            The data catalog ID.
-        """
-        self.data_catalog_id = data_catalog_id
-
-        import planetary_computer
-        import pystac_client
-
-        catalog = pystac_client.Client.open(
-            "https://planetarycomputer.microsoft.com/api/stac/v1/",
-            modifier=planetary_computer.sign_inplace,
-        )
-        collection = catalog.get_collection(self.data_catalog_id)
-
-        asset = collection.assets["zarr-abfs"]
-
-        if "xarray:storage_options" in asset.extra_fields:
-            store = {
-                "store": asset.href,
-                "storage_options": asset.extra_fields["xarray:storage_options"],
-                **asset.extra_fields["xarray:open_kwargs"],
-            }
-        else:
-            store = {
-                "filename_or_obj": asset.href,
-                **asset.extra_fields["xarray:open_kwargs"],
-            }
-
-        self.store = store
-
-    def __getitem__(self, key: str) -> bytes:
-        """Retrieve an item from the store."""
-        raise NotImplementedError()
-
-
 class DebugStore(ReadOnlyStore):
     """A store to debug the zarr loading."""
 
@@ -190,11 +140,11 @@ def name_to_zarr_store(path_or_url: str) -> ReadOnlyStore:
 
     if store.startswith("http://") or store.startswith("https://"):
 
-        parsed = urlparse(store)
-
         if store.endswith(".zip"):
             import multiurl
 
+            parsed = urlparse(store)
+
             # Zarr cannot handle zip files over HTTP
             tmpdir = tempfile.gettempdir()
             name = os.path.basename(parsed.path)
@@ -210,15 +160,7 @@ def name_to_zarr_store(path_or_url: str) -> ReadOnlyStore:
             os.rename(path + ".tmp", path)
             return name_to_zarr_store(path)
 
-        bits = parsed.netloc.split(".")
-        if len(bits) == 5 and (bits[1], bits[3], bits[4]) == ("s3", "amazonaws", "com"):
-            s3_url = f"s3://{bits[0]}{parsed.path}"
-            store = S3Store(s3_url, region=bits[2])
-        elif store.startswith("https://planetarycomputer.microsoft.com/"):
-            data_catalog_id = store.rsplit("/", 1)[-1]
-            store = PlanetaryComputerStore(data_catalog_id).store
-        else:
-            store = HTTPStore(store)
+        return HTTPStore(store)
 
     return store
 
@@ -252,7 +194,7 @@ def open_zarr(path: str, dont_fail: bool = False, cache: int = None) -> zarr.hie
 class Zarr(Dataset):
     """A zarr dataset."""
 
-    def __init__(self, path: Union[str, zarr.hierarchy.Group]) -> None:
+    def __init__(self, path: str | zarr.hierarchy.Group) -> None:
         """Initialize the Zarr dataset with a path or zarr group."""
         if isinstance(path, zarr.hierarchy.Group):
             self.was_zarr = True
@@ -268,7 +210,7 @@ class Zarr(Dataset):
         self._missing = set()
 
     @property
-    def missing(self) -> Set[int]:
+    def missing(self) -> set[int]:
         """Return the missing dates of the dataset."""
         return self._missing
 
@@ -289,7 +231,7 @@ class Zarr(Dataset):
         """Retrieve an item from the dataset."""
         return self.data[n]
 
-    def _unwind(self, index: Union[int, slice, list, tuple], rest: list, shape: tuple, axis: int, axes: list) -> iter:
+    def _unwind(self, index: int | slice | list | tuple, rest: list, shape: tuple, axis: int, axes: list) -> iter:
         """Unwind the index for multi-dimensional indexing."""
         if not isinstance(index, (int, slice, list, tuple)):
             try:
@@ -351,7 +293,7 @@ class Zarr(Dataset):
             return self.z.longitude[:]
 
     @property
-    def statistics(self) -> Dict[str, NDArray[Any]]:
+    def statistics(self) -> dict[str, NDArray[Any]]:
         """Return the statistics of the dataset."""
         return dict(
             mean=self.z.mean[:],
@@ -360,7 +302,7 @@ class Zarr(Dataset):
             minimum=self.z.minimum[:],
         )
 
-    def statistics_tendencies(self, delta: Optional[datetime.timedelta] = None) -> Dict[str, NDArray[Any]]:
+    def statistics_tendencies(self, delta: datetime.timedelta | None = None) -> dict[str, NDArray[Any]]:
         """Return the statistical tendencies of the dataset."""
         if delta is None:
             delta = self.frequency
@@ -407,14 +349,14 @@ class Zarr(Dataset):
         return dates[1].astype(object) - dates[0].astype(object)
 
     @property
-    def name_to_index(self) -> Dict[str, int]:
+    def name_to_index(self) -> dict[str, int]:
         """Return the name to index mapping of the dataset."""
         if "variables" in self.z.attrs:
             return {n: i for i, n in enumerate(self.z.attrs["variables"])}
         return self.z.attrs["name_to_index"]
 
     @property
-    def variables(self) -> List[str]:
+    def variables(self) -> list[str]:
         """Return the variables of the dataset."""
         return [
             k
@@ -425,7 +367,7 @@ class Zarr(Dataset):
         ]
 
     @cached_property
-    def constant_fields(self) -> List[str]:
+    def constant_fields(self) -> list[str]:
         """Return the constant fields of the dataset."""
         result = self.z.attrs.get("constant_fields")
         if result is None:
@@ -433,7 +375,7 @@ class Zarr(Dataset):
         return self.computed_constant_fields()
 
     @property
-    def variables_metadata(self) -> Dict[str, Any]:
+    def variables_metadata(self) -> dict[str, Any]:
         """Return the metadata of the variables."""
         return self.z.attrs.get("variables_metadata", {})
 
@@ -445,7 +387,7 @@ class Zarr(Dataset):
         """Return the end date of the statistics."""
         return self.dates[-1]
 
-    def metadata_specific(self, **kwargs: Any) -> Dict[str, Any]:
+    def metadata_specific(self, **kwargs: Any) -> dict[str, Any]:
         """Return the specific metadata of the dataset."""
         return super().metadata_specific(
             attrs=dict(self.z.attrs),
@@ -469,7 +411,7 @@ class Zarr(Dataset):
         """Return the tree representation of the dataset."""
         return Node(self, [], path=self.path)
 
-    def get_dataset_names(self, names: Set[str]) -> None:
+    def get_dataset_names(self, names: set[str]) -> None:
         """Get the names of the datasets."""
         name, _ = os.path.splitext(os.path.basename(self.path))
         names.add(name)
@@ -486,17 +428,17 @@ class Zarr(Dataset):
 class ZarrWithMissingDates(Zarr):
     """A zarr dataset with missing dates."""
 
-    def __init__(self, path: Union[str, zarr.hierarchy.Group]) -> None:
+    def __init__(self, path: str | zarr.hierarchy.Group) -> None:
         """Initialize the ZarrWithMissingDates dataset with a path or zarr group."""
         super().__init__(path)
 
         missing_dates = self.z.attrs.get("missing_dates", [])
-        missing_dates = set([np.datetime64(x, "s") for x in missing_dates])
+        missing_dates = {np.datetime64(x, "s") for x in missing_dates}
         self.missing_to_dates = {i: d for i, d in enumerate(self.dates) if d in missing_dates}
         self._missing = set(self.missing_to_dates)
 
     @property
-    def missing(self) -> Set[int]:
+    def missing(self) -> set[int]:
         """Return the missing dates of the dataset."""
         return self._missing
 
@@ -559,12 +501,16 @@ class ZarrWithMissingDates(Zarr):
 QUIET = set()
 
 
-def zarr_lookup(name: str, fail: bool = True) -> Optional[str]:
+def zarr_lookup(name: str, fail: bool = True) -> str | None:
     """Look up a zarr dataset by name."""
 
     config = load_config()["datasets"]
     use_search_path_not_found = config.get("use_search_path_not_found", False)
 
+    if name.endswith(".zarr/"):
+        LOG.warning("Removing trailing slash from path: %s", name)
+        name = name[:-1]
+
     if name.endswith(".zarr") or name.endswith(".zip"):
 
         if os.path.exists(name):