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

roms_tools/tests/test_analysis/test_roms_output.py

@@ -1,10 +1,13 @@
-import pytest
-from pathlib import Path
-import xarray as xr
-import numpy as np
-import os
 import logging
+import os
 from datetime import datetime
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pytest
+import xarray as xr
+
 from roms_tools import Grid, ROMSOutput
 from roms_tools.download import download_test_data
 
@@ -16,7 +19,6 @@ except ImportError:
 
 @pytest.fixture
 def roms_output_from_restart_file(use_dask):
-
     fname_grid = Path(download_test_data("epac25km_grd.nc"))
     grid = Grid.from_file(fname_grid)
 
@@ -30,7 +32,6 @@ def roms_output_from_restart_file(use_dask):
 
 @pytest.fixture
 def roms_output_from_restart_file_adjusted_for_zeta(use_dask):
-
     fname_grid = Path(download_test_data("epac25km_grd.nc"))
     grid = Grid.from_file(fname_grid)
 
@@ -43,14 +44,29 @@ def roms_output_from_restart_file_adjusted_for_zeta(use_dask):
     )
 
 
+@pytest.fixture
+def roms_output_from_restart_file_with_straddling_grid(use_dask):
+    # Make fake grid that straddles the dateline and that has consistent sizes with test data below
+    grid = Grid(
+        nx=8, ny=13, center_lon=0, center_lat=60, rot=32, size_x=244, size_y=365
+    )
+
+    return ROMSOutput(
+        grid=grid,
+        path=Path(download_test_data("eastpac25km_rst.19980106000000.nc")),
+        use_dask=use_dask,
+    )
+
+
 @pytest.mark.parametrize(
     "roms_output_fixture",
     [
         "roms_output_from_restart_file",
         "roms_output_from_restart_file_adjusted_for_zeta",
+        "roms_output_from_restart_file_with_straddling_grid",
     ],
 )
-def test_load_model_output_file(roms_output_fixture, use_dask, request):
+def test_load_model_output_file(roms_output_fixture, request):
     roms_output = request.getfixturevalue(roms_output_fixture)
 
     assert isinstance(roms_output.ds, xr.Dataset)
@@ -197,7 +213,8 @@ def test_compute_depth_coordinates(use_dask):
 
 def test_missing_zeta_gets_raised(use_dask):
     """Test that a ValueError is raised when `zeta` is missing from the dataset and
-    `adjust_depth_for_sea_surface_height` is enabled."""
+    `adjust_depth_for_sea_surface_height` is enabled.
+    """
     # Load the grid
     fname_grid = Path(download_test_data("epac25km_grd.nc"))
     grid = Grid.from_file(fname_grid)
@@ -269,14 +286,14 @@ def test_that_coordinates_are_added(use_dask):
     [
         "roms_output_from_restart_file",
         "roms_output_from_restart_file_adjusted_for_zeta",
+        "roms_output_from_restart_file_with_straddling_grid",
     ],
 )
-def test_plot_on_native_model_grid(roms_output_fixture, use_dask, request):
+def test_plot_on_native_model_grid(roms_output_fixture, request):
     roms_output = request.getfixturevalue(roms_output_fixture)
 
     for include_boundary in [False, True]:
         for depth_contours in [False, True]:
-
             # 3D fields
             for var_name in ["temp", "u", "v"]:
                 kwargs = {
@@ -333,21 +350,32 @@ def test_plot_on_native_model_grid(roms_output_fixture, use_dask, request):
             roms_output.plot("zeta", time=1, eta=1, **kwargs)
             roms_output.plot("zeta", time=1, xi=1, **kwargs)
 
+    # Test that passing a matplotlib.axes.Axes works
+    fig, ax = plt.subplots(1, 1)
+    roms_output.plot(var_name="temp", time=1, s=-1, ax=ax)
+    roms_output.plot(var_name="temp", time=1, depth=1000, ax=ax)
+    roms_output.plot(var_name="temp", time=1, eta=1, ax=ax)
+    roms_output.plot(var_name="temp", time=1, eta=1, xi=1, ax=ax)
+    roms_output.plot(var_name="temp", time=1, s=-1, eta=1, ax=ax)
+    roms_output.plot(var_name="temp", time=1, depth=1000, eta=1, ax=ax)
+    roms_output.plot(var_name="zeta", time=1, ax=ax)
+    roms_output.plot(var_name="zeta", time=1, eta=1, ax=ax)
+
 
 @pytest.mark.parametrize(
-    "roms_output_fixture",
+    "roms_output_fixture, lat, lon",
     [
-        "roms_output_from_restart_file",
-        "roms_output_from_restart_file_adjusted_for_zeta",
+        ("roms_output_from_restart_file", 9, -128),
+        ("roms_output_from_restart_file_adjusted_for_zeta", 9, -128),
+        ("roms_output_from_restart_file_with_straddling_grid", 60, 0),
     ],
 )
 @pytest.mark.skipif(xesmf is None, reason="xesmf required")
-def test_plot_on_lat_lon(roms_output_fixture, use_dask, request):
+def test_plot_on_lat_lon(roms_output_fixture, lat, lon, request):
     roms_output = request.getfixturevalue(roms_output_fixture)
 
     for include_boundary in [False, True]:
         for depth_contours in [False, True]:
-
             # 3D fields
             for var_name in ["temp", "u", "v"]:
                 kwargs = {
@@ -357,59 +385,66 @@ def test_plot_on_lat_lon(roms_output_fixture, use_dask, request):
                 roms_output.plot(
                     var_name,
                     time=1,
-                    lat=9,
-                    lon=-128,
+                    lat=lat,
+                    lon=lon,
                     **kwargs,
                 )
                 roms_output.plot(
                     var_name,
                     time=1,
-                    lat=9,
+                    lat=lat,
                     **kwargs,
                 )
                 roms_output.plot(
                     var_name,
                     time=1,
-                    lat=9,
+                    lat=lat,
                     s=-1,
                     **kwargs,
                 )
                 roms_output.plot(
                     var_name,
                     time=1,
-                    lat=9,
+                    lat=lat,
                     depth=1000,
                     **kwargs,
                 )
                 roms_output.plot(
                     var_name,
                     time=1,
-                    lon=-128,
+                    lon=lon,
                     **kwargs,
                 )
                 roms_output.plot(
                     var_name,
                     time=1,
-                    lon=-128,
+                    lon=lon,
                     s=-1,
                     **kwargs,
                 )
                 roms_output.plot(
                     var_name,
                     time=1,
-                    lon=-128,
+                    lon=lon,
                     depth=1000,
                     **kwargs,
                 )
 
             # 2D fields
-            roms_output.plot("zeta", time=1, lat=9, **kwargs)
-            roms_output.plot("zeta", time=1, lon=-128, **kwargs)
+            roms_output.plot("zeta", time=1, lat=lat, **kwargs)
+            roms_output.plot("zeta", time=1, lon=lon, **kwargs)
 
+    # Test that passing a matplotlib.axes.Axes works
+    fig, ax = plt.subplots(1, 1)
+    roms_output.plot(var_name="temp", time=1, lat=lat, lon=lon, ax=ax)
+    roms_output.plot(var_name="temp", time=1, lat=lat, ax=ax)
+    roms_output.plot(var_name="temp", time=1, lat=lat, s=-1, ax=ax)
+    roms_output.plot(var_name="temp", time=1, lat=lat, depth=1000, ax=ax)
+    roms_output.plot(var_name="zeta", time=1, lat=lat, ax=ax)
 
-def test_plot_errors(roms_output_from_restart_file, use_dask):
-    """Test error conditions for the ROMSOutput.plot() method."""
 
+def test_plot_errors(roms_output_from_restart_file):
+    """Test error conditions for the ROMSOutput.plot() method."""
     # Invalid time index
     with pytest.raises(ValueError, match="Invalid time index"):
         roms_output_from_restart_file.plot("temp", time=10, s=-1)
@@ -481,7 +516,6 @@ def test_plot_errors(roms_output_from_restart_file, use_dask):
 
 
 def test_figure_gets_saved(roms_output_from_restart_file, tmp_path):
-
     filename = tmp_path / "figure.png"
     roms_output_from_restart_file.plot("temp", time=0, depth=1000, save_path=filename)
 
@@ -489,41 +523,75 @@ def test_figure_gets_saved(roms_output_from_restart_file, tmp_path):
     filename.unlink()
 
 
+@pytest.mark.parametrize(
+    "roms_output_fixture",
+    [
+        "roms_output_from_restart_file",
+        "roms_output_from_restart_file_adjusted_for_zeta",
+        "roms_output_from_restart_file_with_straddling_grid",
+    ],
+)
 @pytest.mark.skipif(xesmf is None, reason="xesmf required")
-def test_regrid_all_variables(roms_output_from_restart_file):
-    ds_regridded = roms_output_from_restart_file.regrid()
+def test_regrid_all_variables(roms_output_fixture, request):
+    roms_output = request.getfixturevalue(roms_output_fixture)
+    ds_regridded = roms_output.regrid()
     assert isinstance(ds_regridded, xr.Dataset)
-    assert set(ds_regridded.data_vars).issubset(
-        set(roms_output_from_restart_file.ds.data_vars)
-    )
+    assert set(ds_regridded.data_vars).issubset(set(roms_output.ds.data_vars))
     assert "lon" in ds_regridded.coords
     assert "lat" in ds_regridded.coords
     assert "depth" in ds_regridded.coords
     assert "time" in ds_regridded.coords
 
 
+@pytest.mark.parametrize(
+    "roms_output_fixture",
+    [
+        "roms_output_from_restart_file",
+        "roms_output_from_restart_file_adjusted_for_zeta",
+        "roms_output_from_restart_file_with_straddling_grid",
+    ],
+)
 @pytest.mark.skipif(xesmf is None, reason="xesmf required")
-def test_regrid_specific_variables(roms_output_from_restart_file):
+def test_regrid_specific_variables(roms_output_fixture, request):
+    roms_output = request.getfixturevalue(roms_output_fixture)
     var_names = ["temp", "salt"]
-    ds_regridded = roms_output_from_restart_file.regrid(var_names=var_names)
+    ds_regridded = roms_output.regrid(var_names=var_names)
     assert isinstance(ds_regridded, xr.Dataset)
     assert set(ds_regridded.data_vars) == set(var_names)
 
-    ds = roms_output_from_restart_file.regrid(var_names=[])
+    ds = roms_output.regrid(var_names=[])
     assert ds is None
 
 
+@pytest.mark.parametrize(
+    "roms_output_fixture",
+    [
+        "roms_output_from_restart_file",
+        "roms_output_from_restart_file_adjusted_for_zeta",
+        "roms_output_from_restart_file_with_straddling_grid",
+    ],
+)
 @pytest.mark.skipif(xesmf is None, reason="xesmf required")
-def test_regrid_missing_variable_raises_error(roms_output_from_restart_file):
+def test_regrid_missing_variable_raises_error(roms_output_fixture, request):
+    roms_output = request.getfixturevalue(roms_output_fixture)
     with pytest.raises(
         ValueError, match="The following variables are not found in the dataset"
     ):
-        roms_output_from_restart_file.regrid(var_names=["fake_variable"])
+        roms_output.regrid(var_names=["fake_variable"])
 
 
+@pytest.mark.parametrize(
+    "roms_output_fixture",
+    [
+        "roms_output_from_restart_file",
+        "roms_output_from_restart_file_adjusted_for_zeta",
+        "roms_output_from_restart_file_with_straddling_grid",
+    ],
+)
 @pytest.mark.skipif(xesmf is None, reason="xesmf required")
-def test_regrid_with_custom_horizontal_resolution(roms_output_from_restart_file):
-    ds_regridded = roms_output_from_restart_file.regrid(horizontal_resolution=0.1)
+def test_regrid_with_custom_horizontal_resolution(roms_output_fixture, request):
+    roms_output = request.getfixturevalue(roms_output_fixture)
+    ds_regridded = roms_output.regrid(horizontal_resolution=0.1)
     assert isinstance(ds_regridded, xr.Dataset)
     assert "lon" in ds_regridded.coords
     assert "lat" in ds_regridded.coords
@@ -532,12 +600,21 @@ def test_regrid_with_custom_horizontal_resolution(roms_output_from_restart_file)
     assert np.allclose(ds_regridded.lat.diff(dim="lat"), 0.1, atol=1e-4)
 
 
+@pytest.mark.parametrize(
+    "roms_output_fixture",
+    [
+        "roms_output_from_restart_file",
+        "roms_output_from_restart_file_adjusted_for_zeta",
+        "roms_output_from_restart_file_with_straddling_grid",
+    ],
+)
 @pytest.mark.skipif(xesmf is None, reason="xesmf required")
-def test_regrid_with_custom_depth_levels(roms_output_from_restart_file):
+def test_regrid_with_custom_depth_levels(roms_output_fixture, request):
+    roms_output = request.getfixturevalue(roms_output_fixture)
     depth_levels = xr.DataArray(
         np.linspace(0, 500, 51), dims=["depth"], attrs={"units": "m"}
     )
-    ds_regridded = roms_output_from_restart_file.regrid(depth_levels=depth_levels)
+    ds_regridded = roms_output.regrid(depth_levels=depth_levels)
     assert isinstance(ds_regridded, xr.Dataset)
     assert "depth" in ds_regridded.coords
     np.allclose(ds_regridded.depth, depth_levels, atol=0.0)

roms_tools/tests/test_regrid.py

@@ -1,6 +1,7 @@
-import pytest
 import numpy as np
+import pytest
 import xarray as xr
+
 from roms_tools.regrid import VerticalRegridToROMS
 
 try:
@@ -10,12 +11,13 @@ except ImportError:
 
 from roms_tools.regrid import LateralRegridFromROMS
 
+
 # Lateral regridding
 @pytest.mark.skipif(xesmf is None, reason="xesmf required")
 def test_lateral_regrid_with_curvilinear_grid():
     """Test that LateralRegridFromROMS regrids data correctly from a curvilinear ROMS
-    grid."""
-
+    grid.
+    """
     # Define ROMS curvilinear grid dimensions
     eta_rho, xi_rho = 10, 20
 
@@ -55,7 +57,6 @@ def test_lateral_regrid_with_curvilinear_grid():
 @pytest.mark.skipif(xesmf is not None, reason="xesmf has to be missing")
 def test_lateral_regrid_import_error():
     """Test that LateralRegridFromROMS raises ImportError when xesmf is missing."""
-
     # Define mock ROMS curvilinear grid dimensions
     eta_rho, xi_rho = 10, 20
 
@@ -117,7 +118,6 @@ def vertical_regridder(depth_values, layer_depth_rho_values):
     ],
 )
 def test_vertical_regrid(request, depth_values, layer_depth_rho_values, temp_data):
-
     vertical_regrid = vertical_regridder(
         depth_values=depth_values, layer_depth_rho_values=layer_depth_rho_values
     )

roms_tools/tests/test_setup/test_boundary_forcing.py

@@ -1,13 +1,16 @@
-import pytest
+import logging
+import textwrap
 from datetime import datetime
-import xarray as xr
+from pathlib import Path
+
+import matplotlib.pyplot as plt
 import numpy as np
-from roms_tools import Grid, BoundaryForcing
-import textwrap
-from roms_tools.download import download_test_data
+import pytest
+import xarray as xr
+
 from conftest import calculate_data_hash
-from pathlib import Path
-import logging
+from roms_tools import BoundaryForcing, Grid
+from roms_tools.download import download_test_data
 
 
 @pytest.mark.parametrize(
@@ -21,7 +24,6 @@ import logging
 )
 def test_boundary_forcing_creation(boundary_forcing_fixture, request):
     """Test the creation of the BoundaryForcing object."""
-
     boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
     fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
@@ -56,6 +58,29 @@ def test_boundary_forcing_creation(boundary_forcing_fixture, request):
     assert hasattr(boundary_forcing.ds, "apply_2d_horizontal_fill")
 
 
+def test_boundary_forcing_creation_with_duplicates(
+    boundary_forcing: BoundaryForcing, use_dask: bool
+) -> None:
+    """Test the creation of the BoundaryForcing object with duplicates in source data
+    works as expected.
+    """
+    fname1 = Path(download_test_data("GLORYS_NA_20120101.nc"))
+    fname2 = Path(download_test_data("GLORYS_NA_20121231.nc"))
+
+    boundary_forcing_with_duplicates_in_source_data = BoundaryForcing(
+        grid=boundary_forcing.grid,
+        start_time=boundary_forcing.start_time,
+        end_time=boundary_forcing.end_time,
+        source={"name": "GLORYS", "path": [fname1, fname1, fname2]},
+        apply_2d_horizontal_fill=boundary_forcing.apply_2d_horizontal_fill,
+        use_dask=use_dask,
+    )
+
+    assert boundary_forcing.ds.identical(
+        boundary_forcing_with_duplicates_in_source_data.ds
+    )
+
+
 @pytest.mark.parametrize(
     "boundary_forcing_fixture",
     [
@@ -65,7 +90,6 @@ def test_boundary_forcing_creation(boundary_forcing_fixture, request):
 )
 def test_bgc_boundary_forcing_creation(boundary_forcing_fixture, request):
     """Test the creation of the BoundaryForcing object."""
-
     boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
     assert boundary_forcing.start_time == datetime(2021, 6, 29)
@@ -124,7 +148,6 @@ def test_bgc_boundary_forcing_creation(boundary_forcing_fixture, request):
 
 
 def test_unsuccessful_boundary_forcing_creation_with_1d_fill(use_dask):
-
     grid = Grid(
         nx=2,
         ny=2,
@@ -142,7 +165,6 @@ def test_unsuccessful_boundary_forcing_creation_with_1d_fill(use_dask):
     fname = Path(download_test_data("GLORYS_coarse_test_data.nc"))
 
     with pytest.raises(ValueError, match="consists entirely of NaNs"):
-
         BoundaryForcing(
             grid=grid,
             start_time=datetime(2021, 6, 29),
@@ -155,7 +177,6 @@ def test_unsuccessful_boundary_forcing_creation_with_1d_fill(use_dask):
     fname_bgc = download_test_data("CESM_regional_coarse_test_data_climatology.nc")
 
     with pytest.raises(ValueError, match="consists entirely of NaNs"):
-
         BoundaryForcing(
             grid=grid,
             start_time=datetime(2021, 6, 29),
@@ -231,7 +252,6 @@ def test_start_time_end_time_warning(use_dask, caplog):
 
 
 def test_boundary_divided_by_land_warning(caplog, use_dask):
-
     # Iceland intersects the western boundary of the following grid
     grid = Grid(
         nx=5, ny=5, size_x=500, size_y=500, center_lon=-10, center_lat=65, rot=0
@@ -253,7 +273,6 @@ def test_boundary_divided_by_land_warning(caplog, use_dask):
 
 
 def test_info_depth(caplog, use_dask):
-
     grid = Grid(
         nx=3,
         ny=3,
@@ -288,7 +307,6 @@ def test_info_depth(caplog, use_dask):
     caplog.clear()
 
     with caplog.at_level(logging.INFO):
-
         BoundaryForcing(
             grid=grid,
             start_time=datetime(2012, 1, 1),
@@ -305,7 +323,6 @@ def test_info_depth(caplog, use_dask):
 
 
 def test_info_fill(caplog, use_dask):
-
     grid = Grid(
         nx=3,
         ny=3,
@@ -343,7 +360,6 @@ def test_info_fill(caplog, use_dask):
     caplog.clear()
 
     with caplog.at_level(logging.INFO):
-
         BoundaryForcing(
             grid=grid,
             start_time=datetime(2012, 1, 1),
@@ -358,7 +374,6 @@ def test_info_fill(caplog, use_dask):
 
 
 def test_1d_and_2d_fill_coincide_if_no_fill(use_dask):
-
     grid = Grid(
         nx=2,
         ny=2,
@@ -398,7 +413,6 @@ def test_1d_and_2d_fill_coincide_if_no_fill(use_dask):
 
 
 def test_1d_and_2d_fill_coincide_if_no_land(use_dask):
-
     # this grid lies entirely over open ocean
     grid = Grid(nx=5, ny=5, size_x=300, size_y=300, center_lon=-5, center_lat=65, rot=0)
 
@@ -434,11 +448,9 @@ def test_1d_and_2d_fill_coincide_if_no_land(use_dask):
 def test_correct_depth_coords_adjusted_for_zeta(
     boundary_forcing_fixture, request, use_dask
 ):
-
     boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
     for direction in ["south", "east", "north", "west"]:
-
         # Test that uppermost interface coincides with sea surface height
         assert np.allclose(
             boundary_forcing.ds_depth_coords[f"interface_depth_rho_{direction}"]
@@ -457,11 +469,9 @@ def test_correct_depth_coords_adjusted_for_zeta(
     ],
 )
 def test_correct_depth_coords_zero_zeta(boundary_forcing_fixture, request, use_dask):
-
     boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
     for direction in ["south", "east", "north", "west"]:
-
         # Test that uppermost interface coincides with sea surface height
         assert np.allclose(
             boundary_forcing.ds_depth_coords[f"interface_depth_rho_{direction}"]
@@ -472,6 +482,25 @@ def test_correct_depth_coords_zero_zeta(boundary_forcing_fixture, request, use_d
         )
 
 
+def test_computed_missing_optional_fields(
+    bgc_boundary_forcing_from_unified_climatology,
+):
+    ds = bgc_boundary_forcing_from_unified_climatology.ds
+
+    # Use tight tolerances because 'DOC' and 'DOCr' can have values order 1e-6
+
+    # 'DOCr' was missing in the source data and should have been filled with a constant default value
+    for direction in ["south", "east", "north", "west"]:
+        assert np.allclose(
+            ds[f"DOCr_{direction}"].std(), 0.0, rtol=1e-10, atol=1e-10
+        ), "DOCr should be constant across space and time"
+    # 'DOC' was present in the source data and should show spatial or temporal variability
+    for direction in ["south", "east", "north", "west"]:
+        assert ds[f"DOC_{direction}"].std() > 1e-10, (
+            "DOC should vary across space and time"
+        )
+
+
 @pytest.mark.parametrize(
     "boundary_forcing_fixture",
     [
@@ -500,6 +529,11 @@ def test_boundary_forcing_plot(boundary_forcing_fixture, request):
         boundary_forcing.plot(var_name=f"vbar_{direction}")
         boundary_forcing.plot(var_name=f"ubar_{direction}")
 
+    # Test that passing a matplotlib.axes.Axes works
+    fig, ax = plt.subplots(1, 1)
+    boundary_forcing.plot(var_name=f"temp_{direction}", ax=ax)
+    boundary_forcing.plot(var_name=f"zeta_{direction}", ax=ax)
+
 
 @pytest.mark.parametrize(
     "boundary_forcing_fixture",
@@ -520,7 +554,6 @@ def test_boundary_forcing_save(boundary_forcing_fixture, request, tmp_path):
             tmp_path / file_str,
             str(tmp_path / file_str),
         ]:  # test for Path object and str
-
             # Test saving without grouping
             saved_filenames = boundary_forcing.save(filepath, group=False)
 
@@ -551,7 +584,6 @@ def test_boundary_forcing_save(boundary_forcing_fixture, request, tmp_path):
 )
 def test_bgc_boundary_forcing_plot(boundary_forcing_fixture, request):
     """Test plot method."""
-
     bgc_boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
     bgc_boundary_forcing.plot(var_name="ALK_south", layer_contours=True)
@@ -569,7 +601,6 @@ def test_bgc_boundary_forcing_plot(boundary_forcing_fixture, request):
 )
 def test_bgc_boundary_forcing_save(boundary_forcing_fixture, tmp_path, request):
     """Test save method."""
-
     bgc_boundary_forcing = request.getfixturevalue(boundary_forcing_fixture)
 
     for file_str in ["test_bf", "test_bf.nc"]:
@@ -578,7 +609,6 @@ def test_bgc_boundary_forcing_save(boundary_forcing_fixture, tmp_path, request):
             tmp_path / file_str,
             str(tmp_path / file_str),
         ]:  # test for Path object and str
-
             # Test saving without partitioning and grouping
             saved_filenames = bgc_boundary_forcing.save(filepath, group=False)
 
@@ -608,8 +638,8 @@ def test_bgc_boundary_forcing_save(boundary_forcing_fixture, tmp_path, request):
 )
 def test_roundtrip_yaml(bdry_forcing_fixture, request, tmp_path, use_dask):
     """Test that creating a BoundaryForcing object, saving its parameters to yaml file,
-    and re-opening yaml file creates the same object."""
-
+    and re-opening yaml file creates the same object.
+    """
     bdry_forcing = request.getfixturevalue(bdry_forcing_fixture)
 
     # Create a temporary filepath using the tmp_path fixture
@@ -618,7 +648,6 @@ def test_roundtrip_yaml(bdry_forcing_fixture, request, tmp_path, use_dask):
         tmp_path / file_str,
         str(tmp_path / file_str),
     ]:  # test for Path object and str
-
         bdry_forcing.to_yaml(filepath)
 
         bdry_forcing_from_file = BoundaryForcing.from_yaml(filepath, use_dask=use_dask)
@@ -630,7 +659,6 @@ def test_roundtrip_yaml(bdry_forcing_fixture, request, tmp_path, use_dask):
 
 
 def test_files_have_same_hash(boundary_forcing, tmp_path, use_dask):
-
     yaml_filepath = tmp_path / "test_yaml_.yaml"
     filepath1 = tmp_path / "test1.nc"
     filepath2 = tmp_path / "test2.nc"
@@ -716,7 +744,6 @@ def test_from_yaml_missing_boundary_forcing(tmp_path, use_dask):
         tmp_path / file_str,
         str(tmp_path / file_str),
     ]:  # test for Path object and str
-
         # Write YAML content to file
         if isinstance(yaml_filepath, Path):
             yaml_filepath.write_text(yaml_content)