cloudnetpy 1.55.20__py3-none-any.whl → 1.55.22__py3-none-any.whl

cloudnetpy/model_evaluation/tests/unit/test_grid_methods.py

@@ -39,16 +39,16 @@ PRODUCT = "iwc"
         ("lwc", ("lwc_ecmwf", "lwc_ecmwf", "lwc_adv_ecmwf")),
     ],
 )
-def test_generate_regrid_product(model_file, obs_file, product, variables):
+def test_generate_regrid_product(model_file, obs_file, product, variables) -> None:
     obs = ObservationManager(product, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, product)
     ProductGrid(model, obs)
     for var in variables:
-        assert var in model.data.keys()
+        assert var in model.data
 
 
 @pytest.mark.parametrize("key, value", [("iwc", 3), ("lwc", 1), ("cf", 2)])
-def test_get_method_storage(key, value, model_file, obs_file):
+def test_get_method_storage(key, value, model_file, obs_file) -> None:
     obs = ObservationManager(key, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, key)
     obj = ProductGrid(model, obs)
@@ -57,7 +57,7 @@ def test_get_method_storage(key, value, model_file, obs_file):
 
 
 @pytest.mark.parametrize("key, value", [("iwc", 3), ("lwc", 1), ("cf", 2)])
-def test_get_method_storage_adv(key, value, model_file, obs_file):
+def test_get_method_storage_adv(key, value, model_file, obs_file) -> None:
     obs = ObservationManager(key, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, key)
     obj = ProductGrid(model, obs)
@@ -66,34 +66,34 @@ def test_get_method_storage_adv(key, value, model_file, obs_file):
 
 
 @pytest.mark.parametrize("name", ["cf_V", "cf_A"])
-def test_cf_method_storage(name, model_file, obs_file):
+def test_cf_method_storage(name, model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     x, y = obj._cf_method_storage()
-    assert name in x.keys()
+    assert name in x
 
 
 @pytest.mark.parametrize("name", ["cf_V_adv", "cf_A_adv"])
-def test_cf_method_storage_adv(name, model_file, obs_file):
+def test_cf_method_storage_adv(name, model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     x, y = obj._cf_method_storage()
-    assert name in y.keys()
+    assert name in y
 
 
 @pytest.mark.parametrize("name", ["iwc", "iwc_att", "iwc_rain"])
-def test_iwc_method_storage(name, model_file, obs_file):
+def test_iwc_method_storage(name, model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     x, y = obj._iwc_method_storage()
-    assert name in x.keys()
+    assert name in x
 
 
 @pytest.mark.parametrize("name", ["iwc_adv", "iwc_att_adv", "iwc_rain_adv"])
-def test_iwc_method_storage_adv(name, model_file, obs_file):
+def test_iwc_method_storage_adv(name, model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -101,7 +101,7 @@ def test_iwc_method_storage_adv(name, model_file, obs_file):
     assert name in y
 
 
-def test_product_method_storage(model_file, obs_file):
+def test_product_method_storage(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -109,7 +109,7 @@ def test_product_method_storage(model_file, obs_file):
     assert "lwc" in x
 
 
-def test_product_method_storage_adv(model_file, obs_file):
+def test_product_method_storage_adv(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -117,7 +117,7 @@ def test_product_method_storage_adv(model_file, obs_file):
     assert "lwc_adv" in y
 
 
-def test_regrid_cf_area(model_file, obs_file):
+def test_regrid_cf_area(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -128,18 +128,7 @@ def test_regrid_cf_area(model_file, obs_file):
     assert x[0, 0] == 0.75
 
 
-# def test_regrid_cf_none(model_file, obs_file):
-#     obs = ObservationManager(PRODUCT, str(obs_file))
-#     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
-#     obj = ProductGrid(model, obs)
-#     data = np.array([])
-#     d = {"cf_A": np.zeros((1, 1))}
-#     d = obj._regrid_cf(d, 0, 0, data)
-#     x = d["cf_A"]
-#     assert np.isnan(x[0, 0])
-
-
-def test_regrid_cf_area_masked(model_file, obs_file):
+def test_regrid_cf_area_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -151,7 +140,7 @@ def test_regrid_cf_area_masked(model_file, obs_file):
     assert round(x[0, 0], 3) == 0.667
 
 
-def test_regrid_cf_area_all_masked(model_file, obs_file):
+def test_regrid_cf_area_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -163,7 +152,7 @@ def test_regrid_cf_area_all_masked(model_file, obs_file):
     testing.assert_equal(x, np.nan)
 
 
-def test_regrid_cf_area_nan(model_file, obs_file):
+def test_regrid_cf_area_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -174,7 +163,7 @@ def test_regrid_cf_area_nan(model_file, obs_file):
     assert x[0, 0] == 0.75
 
 
-def test_regrid_cf_area_all_nan(model_file, obs_file):
+def test_regrid_cf_area_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -184,7 +173,7 @@ def test_regrid_cf_area_all_nan(model_file, obs_file):
             [np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan],
-        ]
+        ],
     )
     d = {"cf_A": np.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
@@ -194,7 +183,7 @@ def test_regrid_cf_area_all_nan(model_file, obs_file):
     testing.assert_equal(x, np.nan)
 
 
-def test_regrid_cf_volume(model_file, obs_file):
+def test_regrid_cf_volume(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -205,7 +194,7 @@ def test_regrid_cf_volume(model_file, obs_file):
     assert x[0, 0] == 0.5
 
 
-def test_regrid_cf_volume_nan(model_file, obs_file):
+def test_regrid_cf_volume_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -216,7 +205,7 @@ def test_regrid_cf_volume_nan(model_file, obs_file):
     assert x[0, 0] == 0.5
 
 
-def test_regrid_cf_volume_all_nan(model_file, obs_file):
+def test_regrid_cf_volume_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -226,7 +215,7 @@ def test_regrid_cf_volume_all_nan(model_file, obs_file):
             [np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan],
-        ]
+        ],
     )
     d = {"cf_V": np.zeros((1, 1))}
     d = obj._regrid_cf(d, 0, 0, data)
@@ -234,7 +223,7 @@ def test_regrid_cf_volume_all_nan(model_file, obs_file):
     testing.assert_equal(x, np.nan)
 
 
-def test_regrid_cf_volume_masked(model_file, obs_file):
+def test_regrid_cf_volume_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -246,7 +235,7 @@ def test_regrid_cf_volume_masked(model_file, obs_file):
     assert round(x[0, 0], 3) == 0.444
 
 
-def test_regrid_cf_volume_all_masked(model_file, obs_file):
+def test_regrid_cf_volume_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -258,7 +247,7 @@ def test_regrid_cf_volume_all_masked(model_file, obs_file):
     testing.assert_equal(x, np.nan)
 
 
-def test_reshape_data_to_window(model_file, obs_file):
+def test_reshape_data_to_window(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -283,7 +272,7 @@ def test_reshape_data_to_window(model_file, obs_file):
             [5, 6, 7, 8],
             [55, 66, 77, 88],
             [555, 666, 777, 888],
-        ]
+        ],
     )
     x = obj._reshape_data_to_window(ind, xnd, ynd)
     compare = np.array([[1, 2], [11, 22], [111, 222]])
@@ -291,7 +280,7 @@ def test_reshape_data_to_window(model_file, obs_file):
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_reshape_data_to_window_middle(model_file, obs_file):
+def test_reshape_data_to_window_middle(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -316,7 +305,7 @@ def test_reshape_data_to_window_middle(model_file, obs_file):
             [5, 6, 7, 8],
             [55, 66, 77, 88],
             [555, 666, 777, 888],
-        ]
+        ],
     )
     x = obj._reshape_data_to_window(ind, xnd, ynd)
     compare = np.array([[222, 333], [6, 7], [66, 77]])
@@ -324,7 +313,7 @@ def test_reshape_data_to_window_middle(model_file, obs_file):
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_reshape_data_to_window_empty(model_file, obs_file):
+def test_reshape_data_to_window_empty(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -336,7 +325,7 @@ def test_reshape_data_to_window_empty(model_file, obs_file):
             0,
             0,
             0,
-        ]
+        ],
     )
     ynd = np.array([0, 0, 0, 0])
     ind = np.array([1, 1, 0, 0], dtype=bool)
@@ -344,7 +333,7 @@ def test_reshape_data_to_window_empty(model_file, obs_file):
     assert x is None
 
 
-def test_regrid_iwc(model_file, obs_file):
+def test_regrid_iwc(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -352,31 +341,33 @@ def test_regrid_iwc(model_file, obs_file):
     d = {"iwc": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc"]
     testing.assert_almost_equal(x[0, 0], 1.4)
 
 
-def test_regrid_iwc_nan(model_file, obs_file):
+def test_regrid_iwc_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
     obj._obs_data = ma.array(
-        [[1, 1, np.nan, 1], [2, np.nan, 2, 2], [3, 3, 3, 3], [4, 4, 4, np.nan]]
+        [[1, 1, np.nan, 1], [2, np.nan, 2, 2], [3, 3, 3, 3], [4, 4, 4, np.nan]],
     )
     d = {"iwc": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc"]
     testing.assert_almost_equal(x[0, 0], 1.5)
 
 
-def test_regrid_iwc_all_nan(model_file, obs_file):
+def test_regrid_iwc_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -386,19 +377,20 @@ def test_regrid_iwc_all_nan(model_file, obs_file):
             [np.nan, np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan, np.nan],
-        ]
+        ],
     )
     d = {"iwc": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc"]
     testing.assert_almost_equal(x[0, 0], np.nan)
 
 
-def test_regrid_iwc_masked(model_file, obs_file):
+def test_regrid_iwc_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -407,14 +399,15 @@ def test_regrid_iwc_masked(model_file, obs_file):
     d = {"iwc": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc"]
     testing.assert_almost_equal(x[0, 0], 1.0)
 
 
-def test_regrid_iwc_all_masked(model_file, obs_file):
+def test_regrid_iwc_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -423,14 +416,15 @@ def test_regrid_iwc_all_masked(model_file, obs_file):
     d = {"iwc": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc"]
     testing.assert_almost_equal(x[0, 0], np.nan)
 
 
-def test_regrid_iwc_none(model_file, obs_file):
+def test_regrid_iwc_none(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -438,14 +432,15 @@ def test_regrid_iwc_none(model_file, obs_file):
     d = {"iwc": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool
+        [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc"]
     testing.assert_equal(x[0, 0], np.nan)
 
 
-def test_regrid_iwc_att(model_file, obs_file):
+def test_regrid_iwc_att(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -467,7 +462,7 @@ def test_regrid_iwc_att(model_file, obs_file):
     testing.assert_almost_equal(x[0, 0], 0.018)
 
 
-def test_regrid_iwc_att_masked(model_file, obs_file):
+def test_regrid_iwc_att_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -500,7 +495,7 @@ def test_regrid_iwc_att_masked(model_file, obs_file):
     testing.assert_almost_equal(x[0, 0], 0.018)
 
 
-def test_regrid_iwc_att_all_masked(model_file, obs_file):
+def test_regrid_iwc_att_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -533,7 +528,7 @@ def test_regrid_iwc_att_all_masked(model_file, obs_file):
     testing.assert_almost_equal(x[0, 0], np.nan)
 
 
-def test_regrid_iwc_att_none(model_file, obs_file):
+def test_regrid_iwc_att_none(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -555,7 +550,7 @@ def test_regrid_iwc_att_none(model_file, obs_file):
     assert np.isnan(x[0, 0])
 
 
-def test_regrid_iwc_rain(model_file, obs_file):
+def test_regrid_iwc_rain(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -563,14 +558,15 @@ def test_regrid_iwc_rain(model_file, obs_file):
     d = {"iwc_rain": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
     testing.assert_almost_equal(x[0, 0], 2.3)
 
 
-def test_regrid_iwc_rain_nan(model_file, obs_file):
+def test_regrid_iwc_rain_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -580,19 +576,20 @@ def test_regrid_iwc_rain_nan(model_file, obs_file):
             [2, 2, 2, np.nan],
             [3, 3, 3, 3],
             [np.nan, 4, 4, np.nan],
-        ]
+        ],
     )
     d = {"iwc_rain": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
     testing.assert_almost_equal(round(x[0, 0], 3), 2.429)
 
 
-def test_regrid_iwc_rain_all_nan(model_file, obs_file):
+def test_regrid_iwc_rain_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -602,19 +599,20 @@ def test_regrid_iwc_rain_all_nan(model_file, obs_file):
             [np.nan, np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan, np.nan],
-        ]
+        ],
     )
     d = {"iwc_rain": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
     testing.assert_almost_equal(x[0, 0], np.nan)
 
 
-def test_regrid_iwc_rain_masked(model_file, obs_file):
+def test_regrid_iwc_rain_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -623,14 +621,15 @@ def test_regrid_iwc_rain_masked(model_file, obs_file):
     d = {"iwc_rain": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
     testing.assert_almost_equal(round(x[0, 0], 3), 2.143)
 
 
-def test_regrid_iwc_rain_all_masked(model_file, obs_file):
+def test_regrid_iwc_rain_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager(PRODUCT, str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj = ProductGrid(model, obs)
@@ -639,14 +638,15 @@ def test_regrid_iwc_rain_all_masked(model_file, obs_file):
     d = {"iwc_rain": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool)
     no_rain = ma.array(
-        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]], dtype=bool
+        [[0, 1, 1, 1], [0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]],
+        dtype=bool,
     )
     d = obj._regrid_iwc(d, 0, 0, ind, no_rain)
     x = d["iwc_rain"]
     testing.assert_equal(x[0, 0], np.nan)
 
 
-def test_regrid_product(model_file, obs_file):
+def test_regrid_product(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -658,7 +658,7 @@ def test_regrid_product(model_file, obs_file):
     testing.assert_almost_equal(x[0, 0], 1.4)
 
 
-def test_regrid_product_nan(model_file, obs_file):
+def test_regrid_product_nan(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -668,7 +668,7 @@ def test_regrid_product_nan(model_file, obs_file):
             [np.nan, 1, 2, 2],
             [3, 3, np.nan, 3],
             [4, np.nan, 4, 4],
-        ]
+        ],
     )
     d = {"lwc": np.zeros((1, 1))}
     ind = ma.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool)
@@ -677,7 +677,7 @@ def test_regrid_product_nan(model_file, obs_file):
     testing.assert_almost_equal(x[0, 0], 1.5)
 
 
-def test_regrid_product_all_nan(model_file, obs_file):
+def test_regrid_product_all_nan(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -687,7 +687,7 @@ def test_regrid_product_all_nan(model_file, obs_file):
             [np.nan, np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan, np.nan],
             [np.nan, np.nan, np.nan, np.nan],
-        ]
+        ],
     )
     d = {"lwc": np.zeros((1, 1))}
     ind = np.array([[0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 0], [0, 0, 0, 0]], dtype=bool)
@@ -696,7 +696,7 @@ def test_regrid_product_all_nan(model_file, obs_file):
     testing.assert_almost_equal(x[0, 0], np.nan)
 
 
-def test_regrid_product_masked(model_file, obs_file):
+def test_regrid_product_masked(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -709,7 +709,7 @@ def test_regrid_product_masked(model_file, obs_file):
     testing.assert_almost_equal(x[0, 0], 1.4)
 
 
-def test_regrid_product_all_masked(model_file, obs_file):
+def test_regrid_product_all_masked(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -722,7 +722,7 @@ def test_regrid_product_all_masked(model_file, obs_file):
     testing.assert_almost_equal(x, np.nan)
 
 
-def test_regrid_product_none(model_file, obs_file):
+def test_regrid_product_none(model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj = ProductGrid(model, obs)
@@ -735,7 +735,7 @@ def test_regrid_product_none(model_file, obs_file):
 
 
 @pytest.mark.parametrize("product", ["cf_A", "cf_V", "cf_A_adv", "cf_V_adv"])
-def test_append_data2object_cf(product, model_file, obs_file):
+def test_append_data2object_cf(product, model_file, obs_file) -> None:
     obs = ObservationManager("cf", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "cf")
     ProductGrid(model, obs)
@@ -746,7 +746,7 @@ def test_append_data2object_cf(product, model_file, obs_file):
     "product",
     ["iwc", "iwc_att", "iwc_rain", "iwc_adv", "iwc_att_adv", "iwc_rain_adv"],
 )
-def test_append_data2object_iwc(product, model_file, obs_file):
+def test_append_data2object_iwc(product, model_file, obs_file) -> None:
     obs = ObservationManager("iwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "iwc")
     ProductGrid(model, obs)
@@ -754,7 +754,7 @@ def test_append_data2object_iwc(product, model_file, obs_file):
 
 
 @pytest.mark.parametrize("product", ["lwc", "lwc_adv"])
-def test_append_data2object_lwc(product, model_file, obs_file):
+def test_append_data2object_lwc(product, model_file, obs_file) -> None:
     obs = ObservationManager("lwc", str(obs_file))
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     ProductGrid(model, obs)