cloudnetpy 1.49.9__py3-none-any.whl → 1.87.3__py3-none-any.whl

cloudnetpy/model_evaluation/tests/unit/test_plotting.py

@@ -1,34 +1,35 @@
 import pytest
 
 from cloudnetpy.model_evaluation.plotting import plotting as pl
+from cloudnetpy.model_evaluation.plotting.plot_meta import PlotMeta
 
 MODEL = "ecmwf"
-
-
-class VariableInfo:
-    def __init__(self):
-        self.name = "Product"
+VARIABLE_INFO = PlotMeta(
+    name="Product",
+    cbar="rainbow",
+    plot_range=(0, 1),
+    plot_scale="linear",
+    plot_type="mesh",
+)
 
 
 @pytest.mark.parametrize("key", ["cf_V", "cf_A", "cf_V_adv", "cf_A_adv"])
-def test_get_cf_title(key):
-    var = VariableInfo()
+def test_get_cf_title(key) -> None:
     field_name = key + "_" + MODEL
     value = "Product, Volume"
     if "A" in key:
         value = "Product, Area"
-    x = pl._get_cf_title(field_name, var)
+    x = pl._get_cf_title(field_name, VARIABLE_INFO)
     assert x == value
 
 
 @pytest.mark.parametrize("key", ["cf_V", "cf_A", "cf_V_adv", "cf_A_adv"])
-def test_get_cf_title_cycle(key):
-    var = VariableInfo()
+def test_get_cf_title_cycle(key) -> None:
     field_name = key + "_" + MODEL + "_001"
     value = "Product, Volume"
     if "A" in key:
         value = "Product, Area"
-    x = pl._get_cf_title(field_name, var)
+    x = pl._get_cf_title(field_name, VARIABLE_INFO)
     assert x == value
 
 
@@ -43,10 +44,9 @@ def test_get_cf_title_cycle(key):
         ("iwc_rain_adv", "Product with rain"),
     ],
 )
-def test_get_iwc_title(key, value):
-    var = VariableInfo()
+def test_get_iwc_title(key, value) -> None:
     field_name = key + "_" + MODEL
-    x = pl._get_iwc_title(field_name, var)
+    x = pl._get_iwc_title(field_name, VARIABLE_INFO)
     assert x == value
 
 
@@ -61,42 +61,38 @@ def test_get_iwc_title(key, value):
         ("iwc_rain_adv", "Product with rain"),
     ],
 )
-def test_get_iwc_title_cycle(key, value):
-    var = VariableInfo()
+def test_get_iwc_title_cycle(key, value) -> None:
     field_name = key + "_" + MODEL + "_001"
-    x = pl._get_iwc_title(field_name, var)
+    x = pl._get_iwc_title(field_name, VARIABLE_INFO)
     assert x == value
 
 
-def test_get_product_title():
-    var = VariableInfo()
+def test_get_product_title() -> None:
     value = "Product"
-    x = pl._get_product_title(var)
+    x = pl._get_product_title(VARIABLE_INFO)
     assert x == value
 
 
-def test_get_product_title_cycle():
-    var = VariableInfo()
+def test_get_product_title_cycle() -> None:
     value = "Product"
-    x = pl._get_product_title(var)
+    x = pl._get_product_title(VARIABLE_INFO)
     assert x == value
 
 
 @pytest.mark.parametrize(
-    "key, title", [("lwc", "Product"), ("lwc_adv", "Product (Advection time)")]
+    "key, title",
+    [("lwc", "Product"), ("lwc_adv", "Product (Advection time)")],
 )
-def test_get_stat_titles(key, title):
+def test_get_stat_titles(key, title) -> None:
     field_name = key + "_" + MODEL
-    var = VariableInfo()
-    x = pl._get_stat_titles(field_name, key, var)
+    x = pl._get_stat_titles(field_name, key, VARIABLE_INFO)
     assert x == title
 
 
 @pytest.mark.parametrize("key", ["cf_V", "cf_A", "cf_V_adv", "cf_A_adv"])
-def test_get_cf_title_stat(key):
+def test_get_cf_title_stat(key) -> None:
     field_name = key + "_" + MODEL
-    var = VariableInfo()
-    x = pl._get_cf_title_stat(field_name, var)
+    x = pl._get_cf_title_stat(field_name, VARIABLE_INFO)
     value = "Product volume"
     if "A" in key:
         value = "Product area"
@@ -111,15 +107,13 @@ def test_get_cf_title_stat(key):
         ("iwc_rain", "Product with rain"),
     ],
 )
-def test_get_iwc_title_stat(key, value):
+def test_get_iwc_title_stat(key, value) -> None:
     field_name = key + "_" + MODEL
-    var = VariableInfo()
-    x = pl._get_iwc_title_stat(field_name, var)
+    x = pl._get_iwc_title_stat(field_name, VARIABLE_INFO)
     assert x == value
 
 
 @pytest.mark.parametrize("key", ["lwc"])
-def test_get_product_title_stat(key):
-    var = VariableInfo()
-    x = pl._get_product_title_stat(var)
+def test_get_product_title_stat(key) -> None:
+    x = pl._get_product_title_stat(VARIABLE_INFO)
     assert x == "Product"

cloudnetpy/model_evaluation/tests/unit/test_statistical_methods.py

@@ -8,7 +8,7 @@ PRODUCT_cf = ["cf", "ECMWF", "Cloud fraction"]
 PRODUCT_iwc = ["iwc", "ECMWF", "Ice water content"]
 
 
-def test_relative_error():
+def test_relative_error() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     observation = ma.array([[3, 2, 5, 4], [4, 6, 8, 4]])
     x, _ = sts.relative_error(model, observation)
@@ -16,29 +16,35 @@ def test_relative_error():
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_relative_error_mask():
+def test_relative_error_mask() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 1, 10, 1]])
     model.mask = np.array([[0, 0, 0, 1], [0, 1, 0, 1]])
     observation = ma.array([[1, 2, 5, 4], [4, 6, 8, 1]])
     observation.mask = np.array([[1, 0, 0, 1], [0, 0, 0, 1]])
     x, _ = sts.relative_error(model, observation)
     compare = ma.array(
-        [[ma.masked, 0.0, -60.0, ma.masked], [-50.0, -83.33, 25.0, ma.masked]]
+        [
+            ma.array([-99, 0.0, -60.0, -99], mask=[True, False, False, True]),
+            ma.array([-50.0, -83.33, 25.0, -99], mask=[False, False, False, True]),
+        ],
     )
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_relative_error_nan():
+def test_relative_error_nan() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     observation = ma.array([[3, 2, 5, np.nan], [4, np.nan, 8, 4]])
     x, _ = sts.relative_error(model, observation)
     compare = ma.array(
-        [[-66.67, 0.0, -60.0, ma.masked], [-50.0, ma.masked, 25.0, -75.0]]
+        [
+            ma.array([-66.67, 0.0, -60.0, -99], mask=[False, False, False, True]),
+            ma.array([-50.0, -99, 25.0, -75.0], mask=[False, True, False, False]),
+        ],
     )
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_absolute_error():
+def test_absolute_error() -> None:
     model = ma.array([[0.1, 0.2, 0.2, 0.3], [0.2, 0.4, 1.0, 0.0]])
     observation = ma.array([[0.2, 0.2, 0.1, 0.4], [0.4, 0.6, 0.8, 0.2]])
     x, _ = sts.absolute_error(model, observation)
@@ -46,27 +52,35 @@ def test_absolute_error():
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_absolute_error_nan():
+def test_absolute_error_nan() -> None:
     model = ma.array([[0.1, 0.2, 0.2, 0.3], [0.2, 0.4, 1.0, 0.0]])
     observation = ma.array([[0.2, np.nan, 0.1, 0.4], [np.nan, 0.6, 0.8, 0.2]])
     x, _ = sts.absolute_error(model, observation)
-    compare = ma.array([[10.0, ma.masked, -10.0, 10.0], [ma.masked, 20.0, -20.0, 20.0]])
+    compare = ma.array(
+        [
+            ma.array([10.0, -99, -10.0, 10.0], mask=[False, True, False, False]),
+            ma.array([-99, 20.0, -20.0, 20.0], mask=[True, False, False, False]),
+        ],
+    )
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_absolute_error_mask():
+def test_absolute_error_mask() -> None:
     model = ma.array([[0.1, 0.2, 0.2, 0.3], [0.2, 0.4, 1.0, 0.0]])
     model.mask = np.array([[0, 0, 0, 1], [0, 1, 0, 1]])
     observation = ma.array([[0.2, 0.2, 0.1, 0.4], [0.4, 0.6, 0.8, 0.2]])
     observation.mask = np.array([[0, 0, 0, 0], [0, 1, 0, 0]])
     x, _ = sts.absolute_error(model, observation)
     compare = ma.array(
-        [[10.0, 0.0, -10.0, ma.masked], [20.0, ma.masked, -20.0, ma.masked]]
+        [
+            ma.array([10.0, 0.0, -10.0, -99], mask=[False, False, False, True]),
+            ma.array([20.0, -99, -20.0, -99], mask=[False, True, False, True]),
+        ],
     )
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_combine_masked_indices():
+def test_combine_masked_indices() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     observation = ma.array([[3, 2, 5, 4], [4, 6, 8, 4]])
     x, y = sts.combine_masked_indices(model, observation)
@@ -76,49 +90,72 @@ def test_combine_masked_indices():
     testing.assert_array_almost_equal(y, compare_o)
 
 
-def test_combine_masked_indices_min():
+def test_combine_masked_indices_min() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     observation = ma.array([[3, 2, 5, 4], [4, 6, 8, 4]])
     x, y = sts.combine_masked_indices(model, observation)
-    compare_m = ma.array([[ma.masked, 2, 2, 3], [2, 4, 10, ma.masked]])
-    compare_o = ma.array([[ma.masked, 2, 5, 4], [4, 6, 8, ma.masked]])
+
+    compare_m = ma.array(
+        [
+            ma.array([-99, 2, 2, 3], mask=[True, False, False, False]),
+            ma.array([2, 4, 10, -99], mask=[True, False, False, True]),
+        ],
+    )
+    compare_o = ma.array(
+        [
+            ma.array([-99, 2, 5, 4], mask=[True, False, False, False]),
+            ma.array([4, 6, 8, -99], mask=[True, False, False, True]),
+        ],
+    )
+
     testing.assert_array_almost_equal(x, compare_m)
     testing.assert_array_almost_equal(y, compare_o)
 
 
-def test_combine_masked_indices_mask():
+def test_combine_masked_indices_mask() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     model.mask = ma.array([[1, 0, 0, 0], [0, 0, 0, 1]])
     observation = ma.array([[3, 2, 1, 4], [4, 6, 8, 4]])
     observation.mask = ma.array([[0, 1, 1, 0], [1, 0, 0, 0]])
     x, y = sts.combine_masked_indices(model, observation)
     model = ma.array(
-        [[ma.masked, ma.masked, ma.masked, 3], [ma.masked, 4, 10, ma.masked]]
+        [
+            ma.array([-99, -99, -99, 3], mask=[True, True, True, False]),
+            ma.array([-99, 4, 10, -99], mask=[True, False, False, True]),
+        ],
     )
     observation = ma.array(
-        [[ma.masked, ma.masked, ma.masked, 4], [ma.masked, 6, 8, ma.masked]]
+        [
+            ma.array([-99, -99, -99, 4], mask=[True, True, True, False]),
+            ma.array([-99, 6, 8, -99], mask=[True, False, False, True]),
+        ],
     )
     testing.assert_array_almost_equal(x, model)
     testing.assert_array_almost_equal(y, observation)
 
 
-def test_combine_masked_indices_nan():
+def test_combine_masked_indices_nan() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     observation = ma.array([[np.nan, 2, 5, 4], [4, 6, np.nan, 4]])
     x, y = sts.combine_masked_indices(model, observation)
-    model = ma.array([[ma.masked, 2, 2, 3], [2, 4, ma.masked, 1]])
+    model = ma.array(
+        [
+            ma.array([-99, 2, 2, 3], mask=[True, False, False, False]),
+            ma.array([2, 4, -99, 1], mask=[False, False, True, False]),
+        ],
+    )
     testing.assert_array_almost_equal(x, model)
     testing.assert_array_almost_equal(y, observation)
 
 
-def test_calc_common_area_sum():
+def test_calc_common_area_sum() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     observation = ma.array([[3, 2, 1, 4], [4, 6, 8, 4]])
     x, _ = sts.calc_common_area_sum(model, observation)
     testing.assert_almost_equal(x, 100)
 
 
-def test_calc_common_area_sum_min():
+def test_calc_common_area_sum_min() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     model.mask = ma.array([[1, 0, 0, 0], [0, 0, 0, 1]])
     observation = ma.array([[3, 2, 1, 4], [4, 6, 8, 4]])
@@ -127,7 +164,7 @@ def test_calc_common_area_sum_min():
     testing.assert_almost_equal(x, 60.0)
 
 
-def test_calc_common_area_sum_nan():
+def test_calc_common_area_sum_nan() -> None:
     model = ma.array([[1, 2, 2, 3], [2, np.nan, 10, 1]])
     model.mask = ma.array([[1, 0, 0, 0], [0, 0, 0, 1]])
     observation = ma.array([[3, 2, 1, 4], [4, 6, np.nan, 4]])
@@ -136,7 +173,7 @@ def test_calc_common_area_sum_nan():
     testing.assert_almost_equal(x, 25.0)
 
 
-def test_calc_common_area_sum_mask():
+def test_calc_common_area_sum_mask() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     model.mask = ma.array([[1, 0, 0, 0], [0, 0, 0, 0]])
     observation = ma.array([[3, 2, 1, 4], [4, 6, 8, 4]])
@@ -145,7 +182,7 @@ def test_calc_common_area_sum_mask():
     testing.assert_almost_equal(x, 50.0)
 
 
-def test_histogram():
+def test_histogram() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     observation = ma.array([[3, 2, 1, 4], [4, 6, 8, 4]])
     compare_x = np.array([1, 2, 2, 3, 2, 4, 8, 1])
@@ -155,7 +192,7 @@ def test_histogram():
     testing.assert_array_almost_equal(y, compare_y)
 
 
-def test_histogram_mask():
+def test_histogram_mask() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     model.mask = ma.array([[1, 0, 0, 0], [0, 0, 0, 1]])
     observation = ma.array([[3, 2, 1, 4], [4, 6, 8, 4]])
@@ -167,7 +204,7 @@ def test_histogram_mask():
     testing.assert_array_almost_equal(y, compare_y)
 
 
-def test_histogram_nan():
+def test_histogram_nan() -> None:
     model = ma.array([[1, 2, 2, 3], [2, 4, 10, 1]])
     observation = ma.array([[3, np.nan, 1, 4], [np.nan, 6, np.nan, 4]])
     compare_x = np.array([1, 2, 2, 3, 2, 4, 6, 1])
@@ -177,7 +214,7 @@ def test_histogram_nan():
     testing.assert_array_almost_equal(y, compare_y)
 
 
-def test_vertical_profile():
+def test_vertical_profile() -> None:
     model = ma.array([[0, 2, 2, 3], [2, 4, 10, 1], [4, 6, 6, 8]])
     observation = ma.array([[3, 1, 1, 4], [4, 3, 8, 0], [5, 5, 3, 2]])
     x, y = sts.vertical_profile(model, observation)
@@ -187,7 +224,7 @@ def test_vertical_profile():
     testing.assert_array_almost_equal(y, observation)
 
 
-def test_vertical_profile_nan():
+def test_vertical_profile_nan() -> None:
     model = ma.array([[0, 2, 2, 3], [2, 4, 10, 1], [4, 6, 6, 8]])
     observation = ma.array([[3, 1, 1, np.nan], [np.nan, 3, 8, 0], [5, 5, 3, 2]])
     x, y = sts.vertical_profile(model, observation)
@@ -197,14 +234,14 @@ def test_vertical_profile_nan():
     testing.assert_array_almost_equal(y, observation)
 
 
-def test_vertical_profile_mask():
+def test_vertical_profile_mask() -> None:
     model = ma.array([[0, 2, 2, 3], [2, 4, 10, 1], [4, 6, 6, 8]])
     model.mask = ma.array([[1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
     observation = ma.array([[3, 1, 1, 4], [4, 3, 8, 0], [5, 5, 3, 2]])
     observation.mask = ma.array([[0, 1, 0, 0], [0, 1, 0, 1], [0, 1, 0, 0]])
     x, y = sts.vertical_profile(model, observation)
     model = ma.array([3, 4, 6, 5.5])
-    observation = ma.array([4, ma.masked, 4, 3])
+    observation = ma.array([4, -99, 4, 3], mask=[False, True, False, False])
     testing.assert_array_almost_equal(x, model)
     testing.assert_array_almost_equal(y, observation)
 
@@ -216,6 +253,6 @@ def test_vertical_profile_mask():
         ("vertical", ("ECMWF", "Cloud fraction")),
     ],
 )
-def test_day_stat_title(method, title):
+def test_day_stat_title(method, title) -> None:
     x = sts.day_stat_title(method, PRODUCT_cf)
     assert x == title

cloudnetpy/model_evaluation/tests/unit/test_tools.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 import numpy as np
 import pytest
@@ -12,61 +12,62 @@ OUTPUT_FILE = "/"
 PRODUCT = "iwc"
 
 
-def test_model_file_list():
+def test_model_file_list() -> None:
     name = "ec"
     models = ["00_ec_1", "00_ec_2", "00_ec_3"]
     tools.check_model_file_list(name, models)
 
 
-@pytest.mark.xfail(raises=AttributeError)
-def test_model_file_list_fail():
+def test_model_file_list_fail() -> None:
     name = "ec"
     models = ["00_ec_1", "ac_1", "00_ec_2", "00_ec_3"]
-    tools.check_model_file_list(name, models)
+    with pytest.raises(AttributeError):
+        tools.check_model_file_list(name, models)
 
 
-def test_time2datetime():
+def test_time2datetime() -> None:
     time_list = np.array(range(10))
-    d = datetime(2020, 4, 7, 0, 0, 0)
+    d = datetime(2020, 4, 7, 0, 0, 0, tzinfo=timezone.utc)
     x = tools.time2datetime(time_list, d)
     compare = [
-        datetime(2020, 4, 7, 0, 0, 0) + timedelta(hours=1 * x) for x in range(0, 10)
+        datetime(2020, 4, 7, 0, 0, 0, tzinfo=timezone.utc) + timedelta(hours=1 * x)
+        for x in range(10)
     ]
     assert all(a == b for a, b in zip(x, compare))
 
 
-def test_rebin_edges():
+def test_rebin_edges() -> None:
     data = np.array([1, 3, 6, 10, 15, 21, 28])
     compare = np.array([-1, 2, 4.5, 8, 12.5, 18, 24.5, 35])
     x = tools.rebin_edges(data)
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_calculate_advection_time_hour(model_file):
+def test_calculate_advection_time_hour(model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     h = obj.resolution_h
-    v = ma.array([[1, 2, 3], [2, 3, 4], [3, 4, 5]])
+    v = np.array([[1, 2, 3], [2, 3, 4], [3, 4, 5]])
     s = 1
     compare = h * 1000 / v / 60**2
     compare[compare > 1 / s] = 1 / s
     compare = np.asarray([[timedelta(hours=float(t)) for t in tt] for tt in compare])
-    x = tools.calculate_advection_time(int(h), v, s)
+    x = tools.calculate_advection_time(int(h), ma.masked_array(v), s)
     assert x.all() == compare.all()
 
 
-def test_calculate_advection_time_10min(model_file):
+def test_calculate_advection_time_10min(model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     h = obj.resolution_h
-    v = ma.array([[1, 2, 3], [2, 3, 4], [3, 4, 5]])
+    v = np.array([[1, 2, 3], [2, 3, 4], [3, 4, 5]])
     s = 6
     compare = h * 1000 / v / 60**2
     compare[compare > 1 / s] = 1 / s
     compare = np.asarray([[timedelta(hours=float(t)) for t in tt] for tt in compare])
-    x = tools.calculate_advection_time(int(h), v, s)
+    x = tools.calculate_advection_time(int(h), ma.masked_array(v), s)
     assert x.all() == compare.all()
 
 
-def test_get_1d_indices():
+def test_get_1d_indices() -> None:
     w = (1, 5)
     d = ma.array([0, 1, 2, 3, 4, 5, 6, 7])
     compare = ma.array([0, 1, 1, 1, 1, 0, 0, 0])
@@ -74,37 +75,43 @@ def test_get_1d_indices():
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_get_1d_indices_mask():
+def test_get_1d_indices_mask() -> None:
     w = (1, 5)
     d = ma.array([0, 1, 2, 3, 4, 5, 6, 7])
     m = np.array([0, 0, 1, 0, 0, 1, 0, 1], dtype=bool)
     x = tools.get_1d_indices(w, d, m)
     d[m] = ma.masked
-    compare = ma.array([0, 1, ma.masked, 1, 1, ma.masked, 0, ma.masked])
+    compare = ma.array(
+        [0, 1, -99, 1, 1, -99, 0, -99],
+        mask=[False, False, True, False, False, True, False, True],
+    )
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_get_adv_indices():
+def test_get_adv_indices() -> None:
     mt = 3
     at = 4
     d = ma.array([0, 1, 2, 3, 4, 5, 6, 7])
-    compare = ma.array([0, 1, 1, 1, 1, 0, 0, 0], dtype=bool)
+    compare: ma.MaskedArray = ma.array([0, 1, 1, 1, 1, 0, 0, 0], dtype=bool)
     x = tools.get_adv_indices(mt, at, d)
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_get_adv_indices_mask():
+def test_get_adv_indices_mask() -> None:
     mt = 3
     at = 4
-    d = ma.array([0, 1, 2, 3, 4, 5, 6, 7])
-    m = ma.array([0, 0, 1, 0, 0, 1, 0, 1], dtype=bool)
+    d: ma.MaskedArray = ma.array([0, 1, 2, 3, 4, 5, 6, 7])
+    m: ma.MaskedArray = ma.array([0, 0, 1, 0, 0, 1, 0, 1], dtype=bool)
     x = tools.get_adv_indices(mt, at, d, m)
     d[m] = ma.masked
-    compare = ma.array([0, 1, ma.masked, 1, 1, ma.masked, 0, 0])
+    compare = ma.array(
+        [0, 1, -99, 1, 1, -99, 0, 0],
+        mask=[False, False, True, False, False, True, False, False],
+    )
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_obs_windows_size():
+def test_obs_windows_size() -> None:
     i = np.array([0, 0, 1, 1, 1, 1, 0], dtype=bool)
     j = np.array([0, 1, 1, 1, 0, 0, 0], dtype=bool)
     x = tools.get_obs_window_size(i, j)
@@ -112,7 +119,7 @@ def test_obs_windows_size():
     testing.assert_almost_equal(x, (4, 3))
 
 
-def test_obs_windows_size_none():
+def test_obs_windows_size_none() -> None:
     i = np.array([0, 0, 1, 1, 1, 1, 0], dtype=bool)
     j = np.array([0, 0, 0, 0, 0, 0, 0], dtype=bool)
     x = tools.get_obs_window_size(i, j)

cloudnetpy/model_evaluation/utils.py

@@ -1,5 +1,6 @@
 import os
+from os import PathLike
 
 
-def file_exists(file_path: str):
+def file_exists(file_path: str | PathLike) -> bool:
     return os.path.isfile(file_path) and os.path.getsize(file_path) > 0