roms-tools 3.1.0__py3-none-any.whl → 3.1.1__py3-none-any.whl

roms_tools/constants.py

@@ -3,3 +3,4 @@ MAXIMUM_GRID_SIZE = 25000  # in km
 UPPER_BOUND_THETA_S = 10  # upper bound for surface vertical stretching parameter
 UPPER_BOUND_THETA_B = 10  # upper bound for bottom vertical stretching parameter
 NUM_TRACERS = 34  # Number of tracers (temperature, salinity, BGC tracers)
+MAX_DISTINCT_COLORS = 20  # Based on tab20 colormap

roms_tools/plot.py

@@ -1097,3 +1097,111 @@ def plot(
 
     if save_path:
         plt.savefig(save_path, dpi=300, bbox_inches="tight")
+
+
+def assign_category_colors(names: list[str]) -> dict[str, tuple]:
+    """
+    Assign a distinct color to each name using a Matplotlib categorical colormap.
+
+    Parameters
+    ----------
+    names : list[str]
+        List of category names (e.g., releases, rivers, etc.) to assign colors to.
+
+    Returns
+    -------
+    dict[str, tuple]
+        Dictionary mapping each name to a unique RGBA color.
+
+    Raises
+    ------
+    ValueError
+        If the number of names exceeds the selected colormap's capacity.
+
+    Notes
+    -----
+    Colormap selection is based on the number of items:
+    - <= 10: 'tab10'
+    - <= 20: 'tab20'
+    - > 20 : 'tab20b'
+    """
+    n = len(names)
+
+    if n <= 10:
+        cmap = plt.get_cmap("tab10")
+    elif n <= 20:
+        cmap = plt.get_cmap("tab20")
+
+    if n > cmap.N:
+        raise ValueError(
+            f"Too many categories ({n}) for selected colormap ({cmap.name}) "
+            f"which supports only {cmap.N} distinct entries."
+        )
+
+    return {name: cmap(i) for i, name in enumerate(names)}
+
+
+def plot_location(
+    grid_ds: xr.Dataset,
+    points: dict[str, dict],
+    ax: Axes,
+    include_legend: bool = True,
+) -> None:
+    """Plot named geographic points on a top-down map view.
+
+    Each point is represented as a marker on the map, optionally colored.
+    This function is generic and can be used for releases, rivers, etc.
+
+    Parameters
+    ----------
+    grid_ds : xr.Dataset
+        The grid dataset containing 'lon_rho' and 'lat_rho', and a 'straddle' attribute.
+
+    points : dict[str, dict]
+        Dictionary of points to plot. Keys are point names. Each value is a dict with:
+        - "lat": float, latitude in degrees
+        - "lon": float, longitude in degrees
+        - Optional "color": tuple or str, matplotlib color
+
+    ax : matplotlib.axes.Axes
+        The axis object to plot on.
+
+    include_legend : bool, default True
+        Whether to include a legend showing point names.
+
+    Returns
+    -------
+    None
+    """
+    lon_deg = grid_ds.lon_rho
+    lat_deg = grid_ds.lat_rho
+
+    if "straddle" not in grid_ds.attrs:
+        raise AttributeError("Grid dataset must have a 'straddle' attribute.")
+
+    straddle = grid_ds.attrs["straddle"] == "True"
+    if straddle:
+        lon_deg = xr.where(lon_deg > 180, lon_deg - 360, lon_deg)
+
+    trans = get_projection(lon_deg, lat_deg)
+    proj = ccrs.PlateCarree()
+
+    for name, info in points.items():
+        lon = info["lon"]
+        lat = info["lat"]
+        color = info.get("color", "k")  # Default to black if no color specified
+
+        x, y = trans.transform_point(lon, lat, proj)
+
+        ax.plot(
+            x,
+            y,
+            marker="x",
+            markersize=8,
+            markeredgewidth=2,
+            label=name,
+            color=color,
+        )
+
+    if include_legend:
+        ax.legend(loc="center left", bbox_to_anchor=(1.1, 0.5))

roms_tools/setup/cdr_forcing.py

@@ -6,12 +6,10 @@ from datetime import datetime
 from pathlib import Path
 from typing import Annotated
 
-import cartopy.crs as ccrs
 import matplotlib.gridspec as gridspec
 import matplotlib.pyplot as plt
 import numpy as np
 import xarray as xr
-from matplotlib.axes import Axes
 from pydantic import (
     BaseModel,
     Field,
@@ -22,7 +20,14 @@ from pydantic import (
 )
 
 from roms_tools import Grid
-from roms_tools.plot import get_projection, plot, plot_2d_horizontal_field
+from roms_tools.constants import MAX_DISTINCT_COLORS
+from roms_tools.plot import (
+    assign_category_colors,
+    get_projection,
+    plot,
+    plot_2d_horizontal_field,
+    plot_location,
+)
 from roms_tools.setup.cdr_release import (
     Release,
     ReleaseType,
@@ -36,6 +41,7 @@ from roms_tools.setup.utils import (
     gc_dist,
     get_target_coords,
     to_dict,
+    validate_names,
     write_to_yaml,
 )
 from roms_tools.utils import (
@@ -45,6 +51,7 @@ from roms_tools.utils import (
 from roms_tools.vertical_coordinate import compute_depth_coordinates
 
 INCLUDE_ALL_RELEASE_NAMES = "all"
+MAX_RELEASES_TO_PLOT = 20  # must be <= MAX_DISTINCT_COLORS
 
 
 class ReleaseSimulationManager(BaseModel):
@@ -389,7 +396,10 @@ class CDRForcing(BaseModel):
         return self._ds
 
     def plot_volume_flux(
-        self, start=None, end=None, release_names=INCLUDE_ALL_RELEASE_NAMES
+        self,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        release_names: list[str] | str = INCLUDE_ALL_RELEASE_NAMES,
     ):
         """Plot the volume flux for each specified release within the given time range.
 
@@ -419,12 +429,7 @@ class CDRForcing(BaseModel):
         start = start or self.start_time
         end = end or self.end_time
 
-        valid_release_names = [r.name for r in self.releases]
-
-        if release_names == INCLUDE_ALL_RELEASE_NAMES:
-            release_names = valid_release_names
-
-        _validate_release_input(release_names, valid_release_names)
+        release_names = _validate_release_names(release_names, self.releases)
 
         data = self.ds["cdr_volume"]
 
@@ -440,9 +445,9 @@ class CDRForcing(BaseModel):
     def plot_tracer_concentration(
         self,
         tracer_name: str,
-        start=None,
-        end=None,
-        release_names=INCLUDE_ALL_RELEASE_NAMES,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        release_names: list[str] | str = INCLUDE_ALL_RELEASE_NAMES,
     ):
         """Plot the concentration of a given tracer for each specified release within
         the given time range.
@@ -476,12 +481,7 @@ class CDRForcing(BaseModel):
         start = start or self.start_time
         end = end or self.end_time
 
-        valid_release_names = [r.name for r in self.releases]
-
-        if release_names == INCLUDE_ALL_RELEASE_NAMES:
-            release_names = valid_release_names
-
-        _validate_release_input(release_names, valid_release_names)
+        release_names = _validate_release_names(release_names, self.releases)
 
         tracer_names = list(self.ds["tracer_name"].values)
         if tracer_name not in tracer_names:
@@ -511,9 +511,9 @@ class CDRForcing(BaseModel):
     def plot_tracer_flux(
         self,
         tracer_name: str,
-        start=None,
-        end=None,
-        release_names=INCLUDE_ALL_RELEASE_NAMES,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        release_names: list[str] | str = INCLUDE_ALL_RELEASE_NAMES,
     ):
         """Plot the flux of a given tracer for each specified release within the given
         time range.
@@ -547,12 +547,7 @@ class CDRForcing(BaseModel):
         start = start or self.start_time
         end = end or self.end_time
 
-        valid_release_names = [r.name for r in self.releases]
-
-        if release_names == INCLUDE_ALL_RELEASE_NAMES:
-            release_names = valid_release_names
-
-        _validate_release_input(release_names, valid_release_names)
+        release_names = _validate_release_names(release_names, self.releases)
 
         tracer_names = list(self.ds["tracer_name"].values)
         if tracer_name not in tracer_names:
@@ -577,7 +572,10 @@ class CDRForcing(BaseModel):
     def _plot_line(self, data, release_names, start, end, title="", ylabel=""):
         """Plots a line graph for the specified releases and time range."""
         valid_release_names = [r.name for r in self.releases]
-        colors = _get_release_colors(valid_release_names)
+        if len(valid_release_names) > MAX_DISTINCT_COLORS:
+            colors = assign_category_colors(release_names)
+        else:
+            colors = assign_category_colors(valid_release_names)
 
         fig, ax = plt.subplots(1, 1, figsize=(7, 4))
         for name in release_names:
@@ -596,7 +594,9 @@ class CDRForcing(BaseModel):
         ax.set(title=title, ylabel=ylabel, xlabel="time")
         ax.set_xlim([start, end])
 
-    def plot_locations(self, release_names="all"):
+    def plot_locations(
+        self, release_names: list[str] | str = INCLUDE_ALL_RELEASE_NAMES
+    ):
         """Plot centers of release locations in top-down view.
 
         Parameters
@@ -619,12 +619,7 @@ class CDRForcing(BaseModel):
                 "A grid must be provided for plotting. Please pass a valid `Grid` object."
             )
 
-        valid_release_names = [r.name for r in self.releases]
-
-        if release_names == "all":
-            release_names = valid_release_names
-
-        _validate_release_input(release_names, valid_release_names)
+        release_names = _validate_release_names(release_names, self.releases)
 
         lon_deg = self.grid.ds.lon_rho
         lat_deg = self.grid.ds.lat_rho
@@ -645,12 +640,22 @@ class CDRForcing(BaseModel):
         plot_2d_horizontal_field(field, kwargs=kwargs, ax=ax, add_colorbar=False)
 
         # Plot release locations
-        colors = _get_release_colors(valid_release_names)
-        _plot_location(
-            grid=self.grid,
-            releases=[self.releases[name] for name in release_names],
+        valid_release_names = [r.name for r in self.releases]
+        if len(valid_release_names) > MAX_DISTINCT_COLORS:
+            colors = assign_category_colors(release_names)
+        else:
+            colors = assign_category_colors(valid_release_names)
+        plot_location(
+            grid_ds=self.grid.ds,
+            points={
+                name: {
+                    "lat": self.releases[name].lat,
+                    "lon": self.releases[name].lon,
+                    "color": colors.get(name, "k"),
+                }
+                for name in release_names
+            },
             ax=ax,
-            colors=colors,
         )
 
     def plot_distribution(self, release_name: str, mark_release_center: bool = True):
@@ -680,8 +685,13 @@ class CDRForcing(BaseModel):
                 "A grid must be provided for plotting. Please pass a valid `Grid` object."
             )
 
-        valid_release_names = [r.name for r in self.releases]
-        _validate_release_input(release_name, valid_release_names, list_allowed=False)
+        if not isinstance(release_name, str):
+            raise ValueError(
+                f"Only a single release name (string) is allowed. Got: {release_name!r}"
+            )
+
+        release_name = _validate_release_names([release_name], self.releases)[0]
+
         release = self.releases[release_name]
 
         # Prepare grid coordinates
@@ -713,8 +723,16 @@ class CDRForcing(BaseModel):
             title="Depth-integrated distribution",
         )
         if mark_release_center:
-            _plot_location(
-                grid=self.grid, releases=[release], ax=ax0, include_legend=False
+            plot_location(
+                grid_ds=self.grid.ds,
+                points={
+                    release.name: {
+                        "lat": release.lat,
+                        "lon": release.lon,
+                    }
+                },
+                ax=ax0,
+                include_legend=False,
             )
 
         # Spread horizontal Gaussian field into the vertical
@@ -828,106 +846,39 @@ class CDRForcing(BaseModel):
         return cls(grid=grid, **params)
 
 
-def _validate_release_input(releases, valid_releases, list_allowed=True):
-    """Validates the input for release names in plotting methods to ensure they are in
-    an acceptable format and exist within the set of valid releases.
-
-    This method ensures that the `releases` parameter is either a single release name (string) or a list
-    of release names (strings), and checks that each release exists in the set of valid releases.
-
-    Parameters
-    ----------
-    releases : str or list of str
-        A single release name as a string, or a list of release names (strings) to validate.
-
-    list_allowed : bool, optional
-        If `True`, a list of release names is allowed. If `False`, only a single release name (string)
-        is allowed. Default is `True`.
-
-    Raises
-    ------
-    ValueError
-        If `releases` is not a string or list of strings, or if any release name is invalid (not in `self.releases`).
-
-    Notes
-    -----
-    This method checks that the `releases` input is in a valid format (either a string or a list of strings),
-    and ensures each release is present in the set of valid releases defined in `self.releases`. Invalid releases
-    are reported in the error message.
-
-    If `list_allowed` is set to `False`, only a single release name (string) will be accepted. Otherwise, a
-    list of release names is also acceptable.
+def _validate_release_names(
+    release_names: list[str] | str, releases: ReleaseCollector
+) -> list[str]:
     """
-    # Ensure that a list of releases is only allowed if `list_allowed` is True
-    if not list_allowed and not isinstance(releases, str):
-        raise ValueError(
-            f"Only a single release name (string) is allowed. Got: {releases}"
-        )
-
-    if isinstance(releases, str):
-        releases = [releases]  # Convert to list if a single string is provided
-    elif isinstance(releases, list):
-        if not all(isinstance(r, str) for r in releases):
-            raise ValueError("All elements in `releases` list must be strings.")
-    else:
-        raise ValueError(
-            "`releases` should be a string (single release name) or a list of strings (release names)."
-        )
-
-    # Validate that the specified releases exist in self.releases
-    invalid_releases = [
-        release for release in releases if release not in valid_releases
-    ]
-    if invalid_releases:
-        raise ValueError(f"Invalid releases: {', '.join(invalid_releases)}")
+    Validate and filter a list of release names.
 
-
-def _get_release_colors(valid_releases: list[str]) -> dict[str, tuple]:
-    """Returns a dictionary of colors for the valid releases, based on a consistent
-    colormap.
+    Ensures that each release name exists in `releases` and limits the list
+    to `MAX_RELEASES_TO_PLOT` entries with a warning if truncated.
 
     Parameters
     ----------
-    valid_releases : List[str]
-        List of release names to assign colors to.
+    release_names : list of str or INCLUDE_ALL_RELEASE_NAMES
+        Names of releases to plot, or sentinel to include all.
+    releases : ReleaseCollector
+        Object containing valid release names.
 
     Returns
     -------
-    Dict[str, tuple]
-        A dictionary where the keys are release names and the values are their corresponding colors,
-        assigned based on the order of releases in the valid releases list.
+    list of str
+        Validated and truncated list of release names.
 
     Raises
     ------
     ValueError
-        If the number of valid releases exceeds the available colormap capacity.
-
-    Notes
-    -----
-    The colormap is chosen dynamically based on the number of valid releases:
-
-    - If there are 10 or fewer releases, the "tab10" colormap is used.
-    - If there are more than 10 but fewer than or equal to 20 releases, the "tab20" colormap is used.
-    - For more than 20 releases, the "tab20b" colormap is used.
+        If any names are invalid.
     """
-    # Determine the colormap based on the number of releases
-    if len(valid_releases) <= 10:
-        color_map = plt.get_cmap("tab10")
-    elif len(valid_releases) <= 20:
-        color_map = plt.get_cmap("tab20")
-    else:
-        color_map = plt.get_cmap("tab20b")
-
-    # Ensure the number of releases doesn't exceed the available colormap capacity
-    if len(valid_releases) > color_map.N:
-        raise ValueError(
-            f"Too many releases. The selected colormap supports up to {color_map.N} releases."
-        )
-
-    # Create a dictionary of colors based on the release indices
-    colors = {name: color_map(i) for i, name in enumerate(valid_releases)}
-
-    return colors
+    return validate_names(
+        release_names,
+        [r.name for r in releases],
+        INCLUDE_ALL_RELEASE_NAMES,
+        MAX_RELEASES_TO_PLOT,
+        label="release",
+    )
 
 
 def _validate_release_location(grid, release: Release):
@@ -1106,73 +1057,3 @@ def _map_3d_gaussian(
         distribution_3d /= distribution_3d.sum()
 
     return distribution_3d
-
-
-def _plot_location(
-    grid: Grid,
-    releases: ReleaseCollector,
-    ax: Axes,
-    colors: dict[str, tuple] | None = None,
-    include_legend: bool = True,
-) -> None:
-    """Plot the center location of each release on a top-down map view.
-
-    Each release is represented as a point on the map, with its color
-    determined by the `colors` dictionary.
-
-    Parameters
-    ----------
-    grid : Grid
-        The grid object defining the spatial extent and coordinate system for the plot.
-
-    releases : ReleaseCollector
-        Collection of `Release` objects to plot. Each `Release` must have `.lat`, `.lon`,
-        and `.name` attributes.
-
-    ax : matplotlib.axes.Axes
-        The Matplotlib axis object to plot on.
-
-    colors : dict of str to tuple, optional
-        Optional dictionary mapping release names to RGBA color tuples. If not provided,
-        all releases are plotted in a default color (`"#dd1c77"`).
-
-    include_legend : bool, default True
-        Whether to include a legend showing release names.
-
-    Returns
-    -------
-    None
-    """
-    lon_deg = grid.ds.lon_rho
-    lat_deg = grid.ds.lat_rho
-    if grid.straddle:
-        lon_deg = xr.where(lon_deg > 180, lon_deg - 360, lon_deg)
-    trans = get_projection(lon_deg, lat_deg)
-
-    proj = ccrs.PlateCarree()
-
-    for release in releases:
-        # transform coordinates to projected space
-        transformed_lon, transformed_lat = trans.transform_point(
-            release.lon,
-            release.lat,
-            proj,
-        )
-
-        if colors is not None:
-            color = colors[release.name]
-        else:
-            color = "k"
-
-        ax.plot(
-            transformed_lon,
-            transformed_lat,
-            marker="x",
-            markersize=8,
-            markeredgewidth=2,
-            label=release.name,
-            color=color,
-        )
-
-    if include_legend:
-        ax.legend(loc="center left", bbox_to_anchor=(1.1, 0.5))

roms_tools/setup/river_forcing.py

@@ -4,14 +4,18 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
 
-import cartopy.crs as ccrs
-import matplotlib.cm as cm
 import matplotlib.pyplot as plt
 import numpy as np
 import xarray as xr
 
 from roms_tools import Grid
-from roms_tools.plot import get_projection, plot_2d_horizontal_field
+from roms_tools.constants import MAX_DISTINCT_COLORS
+from roms_tools.plot import (
+    assign_category_colors,
+    get_projection,
+    plot_2d_horizontal_field,
+    plot_location,
+)
 from roms_tools.setup.datasets import (
     DaiRiverDataset,
     get_indices_of_nearest_grid_cell_for_rivers,
@@ -26,10 +30,14 @@ from roms_tools.setup.utils import (
     get_variable_metadata,
     substitute_nans_by_fillvalue,
     to_dict,
+    validate_names,
     write_to_yaml,
 )
 from roms_tools.utils import save_datasets
 
+INCLUDE_ALL_RIVER_NAMES = "all"
+MAX_RIVERS_TO_PLOT = 20  # must be <= MAX_DISTINCT_COLORS
+
 
 @dataclass(kw_only=True)
 class RiverForcing:
@@ -672,8 +680,24 @@ class RiverForcing:
                     "`convert_to_climatology = 'if_any_missing'` to automatically fill missing values with climatological data."
                 )
 
-    def plot_locations(self):
-        """Plots the original and updated river locations on a map projection."""
+    def plot_locations(self, river_names: list[str] | str = INCLUDE_ALL_RIVER_NAMES):
+        """Plots the original and updated river locations on a map projection.
+
+        Parameters
+        ----------
+        river_names : list[str], or str, optional
+            A list of release names to plot.
+            If a string equal to "all", all rivers will be plotted.
+            Defaults to "all".
+
+        """
+        valid_river_names = list(self.indices.keys())
+        river_names = _validate_river_names(river_names, valid_river_names)
+        if len(valid_river_names) > MAX_DISTINCT_COLORS:
+            colors = assign_category_colors(river_names)
+        else:
+            colors = assign_category_colors(valid_river_names)
+
         field = self.grid.ds.mask_rho
         lon_deg = self.grid.ds.lon_rho
         lat_deg = self.grid.ds.lat_rho
@@ -695,53 +719,37 @@ class RiverForcing:
         for ax in axs:
             plot_2d_horizontal_field(field, kwargs=kwargs, ax=ax, add_colorbar=False)
 
-        proj = ccrs.PlateCarree()
-
-        if len(self.indices) <= 10:
-            color_map = cm.get_cmap("tab10")
-        elif len(self.indices) <= 20:
-            color_map = cm.get_cmap("tab20")
-        else:
-            color_map = cm.get_cmap("tab20b")
-        # Create a dictionary of colors
-        colors = {name: color_map(i) for i, name in enumerate(self.indices.keys())}
-
-        for ax, indices in zip(axs, [self.original_indices, self.indices]):
-            added_labels = set()
-            for name in indices.keys():
-                for tuple in indices[name]:
-                    eta_index = tuple[0]
-                    xi_index = tuple[1]
-
-                    # transform coordinates to projected space
-                    transformed_lon, transformed_lat = trans.transform_point(
-                        self.grid.ds.lon_rho[eta_index, xi_index],
-                        self.grid.ds.lat_rho[eta_index, xi_index],
-                        proj,
-                    )
-
-                    if name not in added_labels:
-                        added_labels.add(name)
-                        label = name
-                    else:
-                        label = "_None"
-
-                    ax.plot(
-                        transformed_lon,
-                        transformed_lat,
-                        marker="x",
-                        markersize=8,
-                        markeredgewidth=2,
-                        label=label,
-                        color=colors[name],
-                    )
+        points = {}
+        for j, (ax, indices) in enumerate(
+            [(ax, ind) for ax, ind in zip(axs, [self.original_indices, self.indices])]
+        ):
+            for name in river_names:
+                if name in indices:
+                    for i, (eta_index, xi_index) in enumerate(indices[name]):
+                        lon = self.grid.ds.lon_rho[eta_index, xi_index].item()
+                        lat = self.grid.ds.lat_rho[eta_index, xi_index].item()
+                        key = name if i == 0 else f"_{name}_{i}"
+                        points[key] = {
+                            "lon": lon,
+                            "lat": lat,
+                            "color": colors[name],
+                        }
+
+            plot_location(
+                grid_ds=self.grid.ds,
+                points=points,
+                ax=ax,
+                include_legend=(j == 1),
+            )
 
         axs[0].set_title("Original river locations")
         axs[1].set_title("Updated river locations")
 
-        axs[1].legend(loc="center left", bbox_to_anchor=(1.1, 0.5))
-
-    def plot(self, var_name="river_volume"):
+    def plot(
+        self,
+        var_name: str = "river_volume",
+        river_names: list[str] | str = INCLUDE_ALL_RIVER_NAMES,
+    ):
         """Plots the river flux (e.g., volume, temperature, or salinity) over time for
         all rivers.
 
@@ -791,8 +799,19 @@ class RiverForcing:
             - 'river_diazFe' : river diazFe (from river_tracer).
 
             The default is 'river_volume'.
+
+        river_names : list[str], or str, optional
+            A list of release names to plot.
+            If a string equal to "all", all rivers will be plotted.
+            Defaults to "all".
+
         """
-        fig, ax = plt.subplots(1, 1, figsize=(9, 5))
+        valid_river_names = list(self.indices.keys())
+        river_names = _validate_river_names(river_names, valid_river_names)
+        if len(valid_river_names) > MAX_DISTINCT_COLORS:
+            colors = assign_category_colors(river_names)
+        else:
+            colors = assign_category_colors(valid_river_names)
 
         if self.climatology:
             xticks = self.ds.month.values
@@ -814,15 +833,19 @@ class RiverForcing:
             units = d[var_name_wo_river]["units"]
             long_name = f"River {d[var_name_wo_river]['long_name']}"
 
-        for i in range(len(self.ds.nriver)):
+        fig, ax = plt.subplots(1, 1, figsize=(9, 5))
+        for name in river_names:
+            nriver = np.where(self.ds["river_name"].values == name)[0].item()
+
             ax.plot(
                 xticks,
-                field.isel(nriver=i),
+                field.isel(nriver=nriver),
                 marker="x",
                 markersize=8,
                 markeredgewidth=2,
                 lw=2,
-                label=self.ds.isel(nriver=i).river_name.values,
+                label=name,
+                color=colors[name],
             )
 
         ax.set_xticks(xticks)
@@ -965,3 +988,38 @@ def check_river_locations_are_along_coast(mask, indices):
                 raise ValueError(
                     f"River `{key}` is not located on the coast at grid cell ({eta_rho}, {xi_rho})."
                 )
+
+
+def _validate_river_names(
+    river_names: list[str] | str, valid_river_names: list[str]
+) -> list[str]:
+    """
+    Validate and filter a list of river names.
+
+    Ensures that each river name exists in `valid_river_names` and limits the list
+    to `MAX_RIVERS_TO_PLOT` entries with a warning if truncated.
+
+    Parameters
+    ----------
+    river_names : list of str or INCLUDE_ALL_RIVER_NAMES
+        Names of rivers to plot, or sentinel to include all.
+    valid_river_names : list of str
+        List of valid river names.
+
+    Returns
+    -------
+    list of str
+        Validated and truncated list of river names.
+
+    Raises
+    ------
+    ValueError
+        If any names are invalid.
+    """
+    return validate_names(
+        river_names,
+        valid_river_names,
+        INCLUDE_ALL_RIVER_NAMES,
+        MAX_RIVERS_TO_PLOT,
+        label="river",
+    )

roms_tools/setup/utils.py

@@ -1,4 +1,5 @@
 import importlib.metadata
+import logging
 from collections.abc import Sequence
 from dataclasses import asdict, fields, is_dataclass
 from datetime import datetime
@@ -1794,3 +1795,59 @@ def to_float(val):
     if isinstance(val, list):
         return [float(v) for v in val]
     return float(val)
+
+
+def validate_names(
+    names: list[str] | str,
+    valid_names: list[str],
+    include_all_sentinel: str,
+    max_to_plot: int,
+    label: str = "item",
+) -> list[str]:
+    """
+    Generic validation and filtering for a list of names.
+
+    Parameters
+    ----------
+    names : list of str or sentinel
+        Names to validate, or sentinel value to include all valid names.
+    valid_names : list of str
+        List of valid names to check against.
+    include_all_sentinel : str
+        Sentinel value to indicate all names should be included.
+    max_to_plot : int
+        Maximum number of names to return.
+    label : str, default "item"
+        Label to use in error and warning messages.
+
+    Returns
+    -------
+    list of str
+        Validated and possibly truncated list of names.
+
+    Raises
+    ------
+    ValueError
+        If any names are invalid or input is not a list of strings.
+    """
+    if names == include_all_sentinel:
+        names = valid_names
+
+    if isinstance(names, list):
+        if not all(isinstance(n, str) for n in names):
+            raise ValueError(f"All elements in `{label}_names` must be strings.")
+    else:
+        raise ValueError(f"`{label}_names` should be a list of strings.")
+
+    invalid = [n for n in names if n not in valid_names]
+    if invalid:
+        raise ValueError(f"Invalid {label}s: {', '.join(invalid)}")
+
+    if len(names) > max_to_plot:
+        logging.warning(
+            f"Only the first {max_to_plot} {label}s will be plotted "
+            f"(received {len(names)})."
+        )
+        names = names[:max_to_plot]
+
+    return names

roms_tools/tests/test_setup/test_cdr_forcing.py

@@ -9,7 +9,7 @@ from pydantic import ValidationError
 
 from conftest import calculate_file_hash
 from roms_tools import CDRForcing, Grid, TracerPerturbation, VolumeRelease
-from roms_tools.constants import NUM_TRACERS
+from roms_tools.constants import MAX_DISTINCT_COLORS, NUM_TRACERS
 from roms_tools.setup.cdr_forcing import (
     CDRForcingDatasetBuilder,
     ReleaseCollector,
@@ -725,6 +725,8 @@ class TestCDRForcing:
             rot=0,
             N=3,
         )
+        self.grid = grid
+
         grid_that_straddles = Grid(
             nx=18,
             ny=18,
@@ -817,8 +819,13 @@ class TestCDRForcing:
             self.volume_release_cdr_forcing_with_straddling_grid,
         ]:
             cdr.plot_volume_flux()
+            cdr.plot_volume_flux(release_names=["first_release"])
+
             cdr.plot_tracer_concentration("ALK")
+            cdr.plot_tracer_concentration("ALK", release_names=["first_release"])
+
             cdr.plot_tracer_concentration("DIC")
+            cdr.plot_tracer_concentration("DIC", release_names=["first_release"])
 
         self.volume_release_cdr_forcing.plot_locations()
         self.volume_release_cdr_forcing.plot_locations(release_names=["first_release"])
@@ -830,13 +837,56 @@ class TestCDRForcing:
             self.tracer_perturbation_cdr_forcing_with_straddling_grid,
         ]:
             cdr.plot_tracer_flux("ALK")
+            cdr.plot_tracer_flux("ALK", release_names=["first_release"])
+
             cdr.plot_tracer_flux("DIC")
+            cdr.plot_tracer_flux("DIC", release_names=["first_release"])
 
         self.tracer_perturbation_cdr_forcing.plot_locations()
         self.tracer_perturbation_cdr_forcing.plot_locations(
             release_names=["first_release"]
         )
 
+    def test_plot_max_releases(self, caplog):
+        # Prepare releases with more than MAX_DISTINCT_COLORS unique names
+        releases = []
+        for i in range(MAX_DISTINCT_COLORS + 1):
+            release = self.first_volume_release.__replace__(name=f"release_{i}")
+            releases.append(release)
+
+        # Construct a CDRForcing object with too many releases to plot
+        cdr_forcing = CDRForcing(
+            grid=self.grid,
+            start_time=self.start_time,
+            end_time=self.end_time,
+            releases=releases,
+        )
+
+        release_names = [r.name for r in releases]
+
+        plot_methods_with_release_names = [
+            cdr_forcing.plot_locations,
+            cdr_forcing.plot_volume_flux,
+        ]
+
+        for plot_func in plot_methods_with_release_names:
+            caplog.clear()
+            with caplog.at_level("WARNING"):
+                plot_func(release_names=release_names)
+            assert any(
+                f"Only the first {MAX_DISTINCT_COLORS} releases will be plotted"
+                in message
+                for message in caplog.messages
+            ), f"Warning not raised by {plot_func.__name__}"
+
+        with caplog.at_level("WARNING"):
+            cdr_forcing.plot_locations(release_names=release_names)
+
+        assert any(
+            f"Only the first {MAX_DISTINCT_COLORS} releases will be plotted" in message
+            for message in caplog.messages
+        )
+
     @pytest.mark.skipif(xesmf is None, reason="xesmf required")
     def test_plot_distribution(self):
         self.volume_release_cdr_forcing.plot_distribution("first_release")
@@ -856,10 +906,10 @@ class TestCDRForcing:
         with pytest.raises(ValueError, match="Invalid releases"):
             self.volume_release_cdr_forcing.plot_locations(release_names=["fake"])
 
-        with pytest.raises(ValueError, match="should be a string"):
+        with pytest.raises(ValueError, match="should be a list"):
             self.volume_release_cdr_forcing.plot_locations(release_names=4)
 
-        with pytest.raises(ValueError, match="list must be strings"):
+        with pytest.raises(ValueError, match="must be strings"):
             self.volume_release_cdr_forcing.plot_locations(release_names=[4])
 
     def test_cdr_forcing_save(self, tmp_path):

roms_tools/tests/test_setup/test_river_forcing.py

@@ -9,6 +9,7 @@ import xarray as xr
 
 from conftest import calculate_file_hash
 from roms_tools import Grid, RiverForcing
+from roms_tools.constants import MAX_DISTINCT_COLORS
 
 
 @pytest.fixture
@@ -57,6 +58,29 @@ def river_forcing_for_grid_that_straddles_dateline():
     )
 
 
+@pytest.fixture
+def river_forcing_for_gulf_of_mexico():
+    """Fixture for creating a RiverForcing object for the Gulf of Mexico with 45 rivers."""
+    grid = Grid(
+        nx=20,
+        ny=15,
+        size_x=2000,
+        size_y=1500,
+        center_lon=-89,
+        center_lat=24,
+        rot=0,
+        N=3,
+    )
+    start_time = datetime(2012, 1, 1)
+    end_time = datetime(2012, 1, 31)
+
+    return RiverForcing(
+        grid=grid,
+        start_time=start_time,
+        end_time=end_time,
+    )
+
+
 @pytest.fixture
 def single_cell_indices():
     # These are the indices that the `river_forcing` fixture generates automatically.
@@ -247,13 +271,46 @@ class TestRiverForcingGeneral:
             )
 
     def test_river_forcing_plot(self, river_forcing_with_bgc):
-        """Test plot method."""
+        """Test plot methods with and without specifying river_names."""
+        river_names = list(river_forcing_with_bgc.indices.keys())[0:2]
+
+        # Test plot_locations
         river_forcing_with_bgc.plot_locations()
-        river_forcing_with_bgc.plot("river_volume")
-        river_forcing_with_bgc.plot("river_temp")
-        river_forcing_with_bgc.plot("river_salt")
-        river_forcing_with_bgc.plot("river_ALK")
-        river_forcing_with_bgc.plot("river_PO4")
+        river_forcing_with_bgc.plot_locations(river_names=river_names)
+
+        # Fields to test
+        variables = [
+            "river_volume",
+            "river_temp",
+            "river_salt",
+            "river_ALK",
+            "river_PO4",
+        ]
+
+        for var in variables:
+            river_forcing_with_bgc.plot(var)
+            river_forcing_with_bgc.plot(var, river_names=river_names)
+
+    def test_plot_max_releases(self, caplog, river_forcing_for_gulf_of_mexico):
+        river_names = list(river_forcing_for_gulf_of_mexico.indices.keys())
+
+        caplog.clear()
+        with caplog.at_level("WARNING"):
+            river_forcing_for_gulf_of_mexico.plot_locations()
+        assert any(
+            f"Only the first {MAX_DISTINCT_COLORS} rivers will be plotted" in message
+            for message in caplog.messages
+        )
+
+        with caplog.at_level("WARNING"):
+            river_forcing_for_gulf_of_mexico.plot(
+                "river_volume", river_names=river_names
+            )
+
+        assert any(
+            f"Only the first {MAX_DISTINCT_COLORS} rivers will be plotted" in message
+            for message in caplog.messages
+        )
 
     @pytest.mark.parametrize(
         "river_forcing_fixture",

roms_tools/tests/test_setup/test_utils.py

@@ -1,3 +1,4 @@
+import logging
 from datetime import datetime
 from pathlib import Path
 
@@ -7,9 +8,7 @@ import xarray as xr
 from roms_tools import BoundaryForcing, Grid
 from roms_tools.download import download_test_data
 from roms_tools.setup.datasets import ERA5Correction
-from roms_tools.setup.utils import (
-    interpolate_from_climatology,
-)
+from roms_tools.setup.utils import interpolate_from_climatology, validate_names
 
 
 def test_interpolate_from_climatology(use_dask):
@@ -71,3 +70,53 @@ def test_roundtrip_yaml(
 
         filepath = Path(filepath)
         filepath.unlink()
+
+
+# test validate_names function
+
+VALID_NAMES = ["a", "b", "c", "d"]
+SENTINEL = "ALL"
+MAX_TO_PLOT = 3
+
+
+def test_valid_names_no_truncation():
+    names = ["a", "b"]
+    result = validate_names(names, VALID_NAMES, SENTINEL, MAX_TO_PLOT, label="test")
+    assert result == names
+
+
+def test_valid_names_with_truncation(caplog):
+    names = ["a", "b", "c", "d"]
+    with caplog.at_level(logging.WARNING):
+        result = validate_names(
+            names, VALID_NAMES, SENTINEL, max_to_plot=2, label="test"
+        )
+        assert result == ["a", "b"]
+        assert "Only the first 2 tests will be plotted" in caplog.text
+
+
+def test_include_all_sentinel():
+    result = validate_names(SENTINEL, VALID_NAMES, SENTINEL, MAX_TO_PLOT, label="test")
+    assert result == VALID_NAMES[:MAX_TO_PLOT]
+
+
+def test_invalid_name_raises():
+    with pytest.raises(ValueError, match="Invalid tests: z"):
+        validate_names(["a", "z"], VALID_NAMES, SENTINEL, MAX_TO_PLOT, label="test")
+
+
+def test_non_list_input_raises():
+    with pytest.raises(ValueError, match="`test_names` should be a list of strings."):
+        validate_names("a", VALID_NAMES, SENTINEL, MAX_TO_PLOT, label="test")
+
+
+def test_non_string_elements_in_list_raises():
+    with pytest.raises(
+        ValueError, match="All elements in `test_names` must be strings."
+    ):
+        validate_names(["a", 2], VALID_NAMES, SENTINEL, MAX_TO_PLOT, label="test")
+
+
+def test_custom_label_in_errors():
+    with pytest.raises(ValueError, match="Invalid foozs: z"):
+        validate_names(["z"], VALID_NAMES, SENTINEL, MAX_TO_PLOT, label="fooz")

{roms_tools-3.1.0.dist-info → roms_tools-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roms-tools
-Version: 3.1.0
+Version: 3.1.1
 Summary: Tools for running and analysing UCLA-ROMS simulations
 Author-email: Nora Loose <nora.loose@gmail.com>, Thomas Nicholas <tom@cworthy.org>, Scott Eilerman <scott.eilerman@cworthy.org>
 License: Apache-2
@@ -36,9 +36,11 @@ Requires-Dist: numba>=0.61.2
 Requires-Dist: pydantic<3,>2
 Provides-Extra: dask
 Requires-Dist: dask[diagnostics]; extra == "dask"
+Requires-Dist: zarr; extra == "dask"
 Provides-Extra: stream
 Requires-Dist: dask[diagnostics]; extra == "stream"
 Requires-Dist: gcsfs; extra == "stream"
+Requires-Dist: zarr; extra == "stream"
 Dynamic: license-file
 
 # ROMS-Tools

{roms_tools-3.1.0.dist-info → roms_tools-3.1.1.dist-info}/RECORD

@@ -1,16 +1,16 @@
 ci/environment-with-xesmf.yml,sha256=1QF0gdRsjisydUNCCZTrsrybh3cCuHrwnLAT0Z1bqmk,234
 ci/environment.yml,sha256=jAi1xo_ZoFNrWevxDRkiKIjMGm1FxzPKocTZwqToT9Y,224
 roms_tools/__init__.py,sha256=XXDoj86gV6gP_sFeKCW0Y6amL8wfDz-iC98VFQGSkfs,1164
-roms_tools/constants.py,sha256=F14YUMAzcbd8QGTo8qRbncV0Y_GFjkOcv8D5NUoob6s,319
+roms_tools/constants.py,sha256=VxhoT2dE_Urqgp7bBdxIfdFDgR7WR83hY2IE7oqIYDE,371
 roms_tools/download.py,sha256=Yc7bi1vb0VM-099MQoT-JcPAGwhsQ4QeB0K7CzyRQMo,8372
-roms_tools/plot.py,sha256=1lqpqfRmzbDY52Uq56ySrkLb7OjGh02ao6MtZEZhhLI,36339
+roms_tools/plot.py,sha256=R7qjRJ6throsTtFTbNbUopuONUh93ln3kFa7mFCUUS0,39234
 roms_tools/regrid.py,sha256=LQhhM5JpjzpgIGSPsj7mr7b_TDUgdyGf5XuQ_GQY9tg,10471
 roms_tools/utils.py,sha256=kAVGVCeTXzi-5euhjbSMbK30aFigvLBfqDSvbQEX9Ls,25321
 roms_tools/vertical_coordinate.py,sha256=081LONzUSe8tL9H6XniAmY1tIyehc87rMnRZ-kYQ0FI,7417
 roms_tools/analysis/roms_output.py,sha256=L2yqhbgHgHkPsross4LgINNY0f__g2ffUMh_FY-5dlE,25223
 roms_tools/setup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 roms_tools/setup/boundary_forcing.py,sha256=tc8NYOEaeEWAX5zHO2xQoRrtFP03MhmVnkm-Zc2QjOg,45043
-roms_tools/setup/cdr_forcing.py,sha256=ta3u1FTtNS3pwF91jxLoaXMaolzXahjU2YGUc-Y2CQY,41023
+roms_tools/setup/cdr_forcing.py,sha256=DpLzeclPNvCP9Ad4f8Q2vQmdOEuHLKx7xWTEpOfjxwY,36610
 roms_tools/setup/cdr_release.py,sha256=TEN_DFLCSJ72UBnZJ5X8Vp8crXtzZ-GjtaymsHG51so,19481
 roms_tools/setup/datasets.py,sha256=5ffqSh0dAeaelny5ucVoYk6vkVisfFVlDocHk9baRWI,109255
 roms_tools/setup/fill.py,sha256=eM5bFqwHcKIQCGBTPi7XOhJiSoCPYsjShbr6w10lIMs,11117
@@ -18,11 +18,11 @@ roms_tools/setup/grid.py,sha256=vtc7sZHEBScxB7GLGmj4amtZXT6jOfddz5Z_TNVsMRU,5447
 roms_tools/setup/initial_conditions.py,sha256=dXuKwiPAhDDS6vJqADxJFaoYfnsY5d_8CcbOE3tMB7g,32245
 roms_tools/setup/mask.py,sha256=MaVfTEc0YhVzuZMLFwuQ-uRKJeQT2bMl3QvVz6dq1P0,3414
 roms_tools/setup/nesting.py,sha256=-tLnp9s_hEI7SM60xJ-fK1FKJ2PSCmHtZgD00Z_MwCo,27012
-roms_tools/setup/river_forcing.py,sha256=5WJsH_dGCHoyywKGYyVYbQNksAFsrN-Fqb2kQv2Q7C4,40235
+roms_tools/setup/river_forcing.py,sha256=MJKRZRawSK4YNzV9lBCDoEyKT4YhNRYkgWWjtA5SaCc,41900
 roms_tools/setup/surface_forcing.py,sha256=q1UBpOfER15SoDOd1BweN-Lx4vivwtu7Z43p6ntt1NQ,29514
 roms_tools/setup/tides.py,sha256=ofnDS5MqKI_mqV-dCxKvtw7LDXBaJEq27Zyh2uAzJ04,16287
 roms_tools/setup/topography.py,sha256=W17vUZK1t3QE_w43r4ucKVGHHE6d6lYwECdQ_FCH2OE,14498
-roms_tools/setup/utils.py,sha256=6N8SxQE8Q-CgQzTdy18Nw0V-Q7s-9zQ32h78Rj0Jsoc,60777
+roms_tools/setup/utils.py,sha256=qCak3jCNSnsBlLGQ3lUl94LhYZLm_0PJd_63_YeM28w,62397
 roms_tools/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 roms_tools/tests/test_regrid.py,sha256=EUeFXcsIUZ3Z1usH5hPEQdkIX4b2XSiBM5zPGG3HXFo,4686
 roms_tools/tests/test_utils.py,sha256=uDddcU-MrCV-7EBYYlThbT_WN3OnpmO-N_cSx6n0GIY,697
@@ -30,17 +30,17 @@ roms_tools/tests/test_vertical_coordinate.py,sha256=_L4FGDJGhnDbMhV7g3fc3SGoRt_1
 roms_tools/tests/test_analysis/test_roms_output.py,sha256=VS2JckETcO_nEDKMpJXkQfcmgABqM8yUYDU1FAUrtEs,21818
 roms_tools/tests/test_setup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 roms_tools/tests/test_setup/test_boundary_forcing.py,sha256=DnKKvcSZLCU7r8j7iNIRqqyWPA0uRHOHca02CcmFFD0,25137
-roms_tools/tests/test_setup/test_cdr_forcing.py,sha256=05dKglJzGKhlKYnVaGtSO0SKsrS8Im4rHB0BrkD6T4E,34619
+roms_tools/tests/test_setup/test_cdr_forcing.py,sha256=E0aX3-U-hroxaHcV8H79OZwmI9ZGRulu-FM3UOrSUOM,36487
 roms_tools/tests/test_setup/test_cdr_release.py,sha256=p2gONUYeZ1lbUegR8NMrDQ9ZsiTdGMru7DhERU8hvZ4,14370
 roms_tools/tests/test_setup/test_datasets.py,sha256=A8pxkU22eouQnESqrbaxyAJpzJYeLbZKdOfUKPyY-n0,21709
 roms_tools/tests/test_setup/test_fill.py,sha256=NvMV-k2J0fRMEKI9D7kjlaERwJ9x-XggJfMd9Vst_7U,3734
 roms_tools/tests/test_setup/test_grid.py,sha256=sjBO6XbrvZ3dvaL31UkiGv-rpqFlH_8-m1xIqtQHGRY,22428
 roms_tools/tests/test_setup/test_initial_conditions.py,sha256=ERjIVcRWW49jeMHdZR3bPbv2AMTeFX1y4UZDOw0Rf_4,19777
 roms_tools/tests/test_setup/test_nesting.py,sha256=75UxhfzfsINBolBzBHJsw6zGebwAG8A8NJUuXTryQpc,18791
-roms_tools/tests/test_setup/test_river_forcing.py,sha256=FLmosc4gzwaLuntWNyJ-1JuwuXwvPmW8864Mffn_7Bk,32999
+roms_tools/tests/test_setup/test_river_forcing.py,sha256=Egj1BzRwk4_o4651p6v2ENNX1kQolZVXgReAZ0Yo7ic,34620
 roms_tools/tests/test_setup/test_surface_forcing.py,sha256=336-qf-A05SxWIXLIXgEpUhAiLedRHyRXau3uVQKT4Q,31534
 roms_tools/tests/test_setup/test_tides.py,sha256=Rh5pkI9-z_TRtgLSTook5GM0OmynAkm6H6dQoqNWwxE,10537
-roms_tools/tests/test_setup/test_utils.py,sha256=u5-jrLKzqQzjY6nDaIXgUC-LqQEeYfP-H8Y4Q5-HS5M,2258
+roms_tools/tests/test_setup/test_utils.py,sha256=SK_Dn8wZjljAWn23-DYGF0f3hqgWX19xCm8MSE0pKqs,3869
 roms_tools/tests/test_setup/test_validation.py,sha256=aqi3g-c7yhAhBAFSv6aPyxlDLbQxk2u76BQBDUYknl8,3861
 roms_tools/tests/test_setup/test_data/bgc_boundary_forcing_from_climatology.zarr/zarr.json,sha256=gERlygacAzytRigJbNCKS9LonhqTzBL73cRBgSYM2aU,160667
 roms_tools/tests/test_setup/test_data/bgc_boundary_forcing_from_climatology.zarr/ALK_ALT_CO2_east/zarr.json,sha256=KSNZ-MO2SPQq_XFwju_mKbmEiVMFHBMf-uw063Ow4gc,888
@@ -1101,8 +1101,8 @@ roms_tools/tests/test_setup/test_data/tidal_forcing.zarr/v_Re/zarr.json,sha256=i
 roms_tools/tests/test_setup/test_data/tidal_forcing.zarr/v_Re/c/0/0/0,sha256=auJ0X3zKvmJprw4ucmJHfspezi6QWHLZzSe9zHEbK0c,89
 roms_tools/tests/test_tiling/test_partition.py,sha256=zGxXd0LyihKk-puCUq0_rBmJMPE92r1gKleoPXRAV9g,8569
 roms_tools/tiling/partition.py,sha256=evpZ7EUTm4jOkBYo3Ub1OywmQ7KHfJEHNMmK4tRamn8,13154
-roms_tools-3.1.0.dist-info/licenses/LICENSE,sha256=yiff76E4xRioW2bHhlPpyYpstmePQBx2bF8HhgQhSsg,11318
-roms_tools-3.1.0.dist-info/METADATA,sha256=09AYKBLkEkhwwITQ6hTzX1tWMIKuMDRKKcsd67uEvgI,4875
-roms_tools-3.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-roms_tools-3.1.0.dist-info/top_level.txt,sha256=aAf4T4nYQSkay5iKJ9kmTjlDgd4ETdp9OSlB4sJdt8Y,19
-roms_tools-3.1.0.dist-info/RECORD,,
+roms_tools-3.1.1.dist-info/licenses/LICENSE,sha256=yiff76E4xRioW2bHhlPpyYpstmePQBx2bF8HhgQhSsg,11318
+roms_tools-3.1.1.dist-info/METADATA,sha256=oNudt3YdkRr4s9TVXhK-0vfjGXxYok2TSeYMPAtQ0kA,4951
+roms_tools-3.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+roms_tools-3.1.1.dist-info/top_level.txt,sha256=aAf4T4nYQSkay5iKJ9kmTjlDgd4ETdp9OSlB4sJdt8Y,19
+roms_tools-3.1.1.dist-info/RECORD,,