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

cloudnetpy/model_evaluation/tests/unit/test_model_products.py

@@ -1,7 +1,7 @@
 import netCDF4
 import numpy as np
-import numpy.testing as testing
 import pytest
+from numpy import testing
 
 from cloudnetpy.model_evaluation.products.model_products import ModelManager
 
@@ -14,31 +14,31 @@ PRODUCT = "iwc"
     "cycle, model, answer",
     [("test_file_12-23", "icon", "_12-23"), ("test_file", "ecmwf", "")],
 )
-def test_read_cycle_name(cycle, model, answer, model_file):
+def test_read_cycle_name(cycle, model, answer, model_file) -> None:
     obj = ModelManager(str(model_file), model, OUTPUT_FILE, PRODUCT)
     x = obj._read_cycle_name(cycle)
     assert x == answer
 
 
-def test_get_cf(model_file):
+def test_get_cf(model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj._get_cf()
-    assert f"{MODEL}_cf" in obj.data.keys()
+    assert f"{MODEL}_cf" in obj.data
 
 
-def test_get_iwc(model_file):
+def test_get_iwc(model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj._get_iwc()
-    assert f"{MODEL}_iwc" in obj.data.keys()
+    assert f"{MODEL}_iwc" in obj.data
 
 
-def test_get_lwc(model_file):
+def test_get_lwc(model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, "lwc")
     obj._get_lwc()
-    assert f"{MODEL}_lwc" in obj.data.keys()
+    assert f"{MODEL}_lwc" in obj.data
 
 
-def test_read_config(model_file):
+def test_read_config(model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     var = obj.get_model_var_names(("p",))
     assert "pressure" in var
@@ -47,7 +47,7 @@ def test_read_config(model_file):
 
 
 @pytest.mark.parametrize("key", ["pressure", "temperature"])
-def test_set_variables(key, model_file):
+def test_set_variables(key, model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     var = obj.getvar(key)
     x = netCDF4.Dataset(model_file).variables[key]
@@ -55,41 +55,43 @@ def test_set_variables(key, model_file):
 
 
 @pytest.mark.parametrize("p, T, q", [(1, 2, 3), (20, 40, 80), (0.3, 0.6, 0.9)])
-def test_calc_water_content(p, T, q, model_file):
+def test_calc_water_content(p, T, q, model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     x = q * p / (287 * T)
     testing.assert_almost_equal(x, obj._calc_water_content(q, p, T))
 
 
 @pytest.mark.parametrize(
-    "key", ["time", "level", "horizontal_resolution", "latitude", "longitude"]
+    "key",
+    ["time", "level", "horizontal_resolution", "latitude", "longitude"],
 )
-def test_add_common_variables_false(key, model_file):
+def test_add_common_variables_false(key, model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj._is_file = False
     obj._add_variables()
-    assert key in obj.data.keys()
+    assert key in obj.data
 
 
 @pytest.mark.parametrize(
-    "key", ["time", "level", "horizontal_resolution", "latitude", "longitude"]
+    "key",
+    ["time", "level", "horizontal_resolution", "latitude", "longitude"],
 )
-def test_add_common_variables_true(key, model_file, regrid_file):
+def test_add_common_variables_true(key, model_file, regrid_file) -> None:
     obj = ModelManager(str(model_file), MODEL, regrid_file, PRODUCT)
     obj._is_file = True
     obj._add_variables()
-    assert key not in obj.data.keys()
+    assert key not in obj.data
 
 
 @pytest.mark.parametrize("key", ["height", "forecast_time"])
-def test_add_cycle_variables_no_products(key, model_file):
+def test_add_cycle_variables_no_products(key, model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     obj._is_file = False
     obj._add_variables()
-    assert f"{MODEL}_{key}" in obj.data.keys()
+    assert f"{MODEL}_{key}" in obj.data
 
 
-def test_cut_off_extra_levels(model_file):
+def test_cut_off_extra_levels(model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     data = np.array([np.arange(100), np.arange(100)])
     compare = np.array([np.arange(88), np.arange(88)])
@@ -97,7 +99,7 @@ def test_cut_off_extra_levels(model_file):
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_calculate_wind_speed(model_file):
+def test_calculate_wind_speed(model_file) -> None:
     obj = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     u = obj.getvar("uwind")
     v = obj.getvar("vwind")

cloudnetpy/model_evaluation/tests/unit/test_observation_products.py

@@ -1,48 +1,47 @@
-from datetime import datetime
+from datetime import datetime, timezone
 
 import numpy as np
-import numpy.ma as ma
-import numpy.testing as testing
 import pytest
+from numpy import ma, testing
 
 from cloudnetpy.model_evaluation.products.product_resampling import ObservationManager
-from cloudnetpy.products.product_tools import CategorizeBits
+from cloudnetpy.products.product_tools import CategorizeBits, CategoryBits
 
 PRODUCT = "iwc"
 
 
 class CatBits:
-    def __init__(self):
-        self.category_bits = {
-            "droplet": np.asarray([[1, 0, 1, 1, 1, 1], [0, 1, 1, 1, 0, 0]], dtype=bool),
-            "falling": np.asarray([[0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 1, 1]], dtype=bool),
-            "cold": np.asarray([[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 0, 1]], dtype=bool),
-            "melting": np.asarray([[1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0]], dtype=bool),
-            "aerosol": np.asarray([[1, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0]], dtype=bool),
-            "insect": np.asarray([[1, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0]], dtype=bool),
-        }
-
-
-def test_get_date(obs_file):
+    def __init__(self) -> None:
+        self.category_bits = CategoryBits(
+            droplet=np.asarray([[1, 0, 1, 1, 1, 1], [0, 1, 1, 1, 0, 0]], dtype=bool),
+            falling=np.asarray([[0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 1, 1]], dtype=bool),
+            freezing=np.asarray([[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 0, 1]], dtype=bool),
+            melting=np.asarray([[1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 0, 0]], dtype=bool),
+            aerosol=np.asarray([[1, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0]], dtype=bool),
+            insect=np.asarray([[1, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0]], dtype=bool),
+        )
+
+
+def test_get_date(obs_file) -> None:
     obj = ObservationManager(PRODUCT, str(obs_file))
-    date = datetime(2019, 5, 23, 0, 0, 0)
+    date = datetime(2019, 5, 23, 0, 0, 0, tzinfo=timezone.utc)
     assert obj._get_date() == date
 
 
 @pytest.mark.parametrize("key", ["iwc", "lwc", "cf"])
-def test_generate_product(key, obs_file):
+def test_generate_product(key, obs_file) -> None:
     obj = ObservationManager(key, str(obs_file))
     obj._generate_product()
-    assert key in obj.data.keys()
+    assert key in obj.data
 
 
-def test_add_height(obs_file):
+def test_add_height(obs_file) -> None:
     obj = ObservationManager(PRODUCT, str(obs_file))
     obj._generate_product()
-    assert "height" in obj.data.keys()
+    assert "height" in obj.data
 
 
-def test_generate_cf(obs_file):
+def test_generate_cf(obs_file) -> None:
     obj = ObservationManager("cf", str(obs_file))
     x = obj._generate_cf()
     compare = ma.array(
@@ -53,13 +52,13 @@ def test_generate_cf(obs_file):
             [0, 0, 0, 1],
             [1, 0, 0, 0],
             [0, 0, 0, 0],
-        ]
+        ],
     )
     compare[~obj._rain_index(), :] = ma.masked
     testing.assert_array_almost_equal(compare, x)
 
 
-def test_basic_cloud_mask(obs_file):
+def test_basic_cloud_mask(obs_file) -> None:
     cat = CategorizeBits(str(obs_file))
     obj = ObservationManager("cf", str(obs_file))
     x = obj._classify_basic_mask(cat.category_bits)
@@ -71,12 +70,12 @@ def test_basic_cloud_mask(obs_file):
             [0, 0, 0, 1],
             [0, 0, 6, 6],
             [7, 2, 0, 7],
-        ]
+        ],
     )
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_mask_cloud_bits(obs_file):
+def test_mask_cloud_bits(obs_file) -> None:
     cat = CategorizeBits(str(obs_file))
     obj = ObservationManager("cf", str(obs_file))
     mask = obj._classify_basic_mask(cat.category_bits)
@@ -89,41 +88,41 @@ def test_mask_cloud_bits(obs_file):
             [0, 0, 0, 1],
             [0, 0, 0, 0],
             [0, 0, 0, 0],
-        ]
+        ],
     )
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_basic_cloud_mask_all_values(obs_file):
+def test_basic_cloud_mask_all_values(obs_file) -> None:
     cat = CatBits()
     obj = ObservationManager("cf", str(obs_file))
-    x = obj._classify_basic_mask(cat.category_bits)
+    x = obj._classify_basic_mask(cat.category_bits)  # type: ignore
     compare = np.array([[8, 7, 6, 1, 3, 1], [0, 1, 7, 5, 2, 4]])
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_mask_cloud_bits_all_values(obs_file):
+def test_mask_cloud_bits_all_values(obs_file) -> None:
     cat = CatBits()
     obj = ObservationManager("cf", str(obs_file))
-    mask = obj._classify_basic_mask(cat.category_bits)
+    mask = obj._classify_basic_mask(cat.category_bits)  # type: ignore
     x = obj._mask_cloud_bits(mask)
     compare = np.array([[0, 0, 0, 1, 1, 1], [0, 1, 0, 1, 0, 1]])
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_check_rainrate(obs_file):
+def test_check_rainrate(obs_file) -> None:
     obj = ObservationManager("cf", str(obs_file))
     x = obj._check_rainrate()
     assert x is True
 
 
-def test_get_rainrate_threshold(obs_file):
+def test_get_rainrate_threshold(obs_file) -> None:
     obj = ObservationManager("cf", str(obs_file))
     x = obj._get_rainrate_threshold()
     assert x == 8
 
 
-def test_rain_index(obs_file):
+def test_rain_index(obs_file) -> None:
     obj = ObservationManager("cf", str(obs_file))
     x = obj._rain_index()
     compare = np.array([0, 0, 0, 1, 0, 1], dtype=bool)
@@ -131,13 +130,13 @@ def test_rain_index(obs_file):
 
 
 @pytest.mark.parametrize("key", ["iwc", "iwc_att", "iwc_rain"])
-def test_generate_iwc_masks(key, obs_file):
+def test_generate_iwc_masks(key, obs_file) -> None:
     obj = ObservationManager(PRODUCT, str(obs_file))
     obj._generate_iwc_masks()
-    assert key in obj.data.keys()
+    assert key in obj.data
 
 
-def test_get_rain_iwc(obs_file):
+def test_get_rain_iwc(obs_file) -> None:
     obj = ObservationManager("iwc", str(obs_file))
     iwc_status = obj.getvar("iwc_retrieval_status")
     x = np.zeros(iwc_status.shape)
@@ -148,7 +147,7 @@ def test_get_rain_iwc(obs_file):
     testing.assert_array_almost_equal(x, compare[:])
 
 
-def test_mask_iwc_att(obs_file):
+def test_mask_iwc_att(obs_file) -> None:
     obj = ObservationManager("iwc", str(obs_file))
     iwc = obj.getvar("iwc")
     iwc_status = obj.getvar("iwc_retrieval_status")

cloudnetpy/model_evaluation/tests/unit/test_plot_tools.py

@@ -4,58 +4,59 @@ from numpy import ma, testing
 from cloudnetpy.model_evaluation.plotting import plot_tools as plt
 
 
-def test_parse_wanted_names(regrid_file):
+def test_parse_wanted_names(regrid_file) -> None:
     """nc_file: str, name: str, model: str,
     vars: list | None = None,
-    advance: bool = False"""
+    advance: bool = False
+    """
     compare = ["ecmwf_cf", "cf_ecmwf"]
     x, _ = plt.parse_wanted_names(regrid_file, "cf", "ecmwf")
     assert x == compare
 
 
-def test_parse_wanted_names_adv(regrid_file):
+def test_parse_wanted_names_adv(regrid_file) -> None:
     compare = ["ecmwf_cf", "cf_adv_ecmwf"]
     _, x_adv = plt.parse_wanted_names(regrid_file, "cf", "ecmwf")
     assert x_adv == compare
 
 
-def test_parse_wanted_names_advance_False(regrid_file):
+def test_parse_wanted_names_advance_False(regrid_file) -> None:
     compare = ["ecmwf_cf", "cf_ecmwf"]
     x, _ = plt.parse_wanted_names(regrid_file, "cf", "ecmwf", advance=False)
     assert x == compare
 
 
-def test_parse_wanted_names_advance_True(regrid_file):
+def test_parse_wanted_names_advance_True(regrid_file) -> None:
     compare = ["ecmwf_cf", "ecmwf_cf_cirrus", "ecmwf_cf_snow", "cf_ecmwf"]
     x, _ = plt.parse_wanted_names(regrid_file, "cf", "ecmwf", advance=True)
     assert x == compare
 
 
-def test_parse_wanted_names_adv_advance_True(regrid_file):
+def test_parse_wanted_names_adv_advance_True(regrid_file) -> None:
     compare = ["ecmwf_cf", "ecmwf_cf_cirrus", "ecmwf_cf_snow", "cf_adv_ecmwf"]
     _, x_adv = plt.parse_wanted_names(regrid_file, "cf", "ecmwf", advance=True)
     assert x_adv == compare
 
 
-def test_parse_wanted_names_adv_advance_False(regrid_file):
+def test_parse_wanted_names_adv_advance_False(regrid_file) -> None:
     compare = ["ecmwf_cf", "cf_adv_ecmwf"]
     _, x_adv = plt.parse_wanted_names(regrid_file, "cf", "ecmwf", advance=False)
     assert x_adv == compare
 
 
-def test_parse_wanted_names_fixed_list(regrid_file):
+def test_parse_wanted_names_fixed_list(regrid_file) -> None:
     compare = ["ecmwf_cf", "ecmwf_cf_cirrus"]
     x, _ = plt.parse_wanted_names(regrid_file, "cf", "ecmwf", variables=compare)
     assert x == compare
 
 
-def test_parse_wanted_names_adv_fixed_list(regrid_file):
+def test_parse_wanted_names_adv_fixed_list(regrid_file) -> None:
     compare = ["ecmwf_cf_cirrus", "cf_adv_ecmwf"]
     x_adv, _ = plt.parse_wanted_names(regrid_file, "cf", "ecmwf", variables=compare)
     assert x_adv == compare
 
 
-def test_sort_model2first_element():
+def test_sort_model2first_element() -> None:
     a = ["ec_i", "cf_ec_i", "cf_ec_ii", "ec_ii"]
     e = "ec"
     compare = ["ec_i", "ec_ii", "cf_ec_i", "cf_ec_ii"]
@@ -63,7 +64,7 @@ def test_sort_model2first_element():
     assert x == compare
 
 
-def test_sort_cycles_vars():
+def test_sort_cycles_vars() -> None:
     a = ["era5_cf_1-12", "era5_cf_7-18", "cf_era5_1-12", "cf_era5_7-18"]
     e = "era5"
     compare = [
@@ -74,7 +75,7 @@ def test_sort_cycles_vars():
     assert x == compare
 
 
-def test_sort_cycles_simo():
+def test_sort_cycles_simo() -> None:
     a = ["era5_cf_1-12", "era5_cf_7-18", "cf_era5_1-12", "cf_era5_7-18"]
     e = "era5"
     compare = ["1-12", "7-18"]
@@ -82,7 +83,7 @@ def test_sort_cycles_simo():
     assert y == compare
 
 
-def test_sort_cycles_vars_missing():
+def test_sort_cycles_vars_missing() -> None:
     a = ["icon_cf_12-23", "icon_cf_36-47", "cf_icon_12-23", "cf_icon_36-47"]
     e = "icon"
     compare = [
@@ -93,7 +94,7 @@ def test_sort_cycles_vars_missing():
     assert x == compare
 
 
-def test_sort_cycles_cycles_missing():
+def test_sort_cycles_cycles_missing() -> None:
     a = ["icon_cf_12-23", "icon_cf_36-47", "cf_icon_12-23", "cf_icon_36-47"]
     e = "icon"
     compare = ["12-23", "36-47"]
@@ -101,7 +102,7 @@ def test_sort_cycles_cycles_missing():
     assert y == compare
 
 
-def test_read_data_characters(regrid_file):
+def test_read_data_characters(regrid_file) -> None:
     t = np.array([[2, 2], [6, 6], [10, 10]])
     h = np.array([[0.01, 0.014], [0.008, 0.014], [0.009, 0.015]])
     data = np.array([[0, 2], [3, 6], [5, 8]])
@@ -112,7 +113,7 @@ def test_read_data_characters(regrid_file):
         testing.assert_array_almost_equal(compare[i], test[i])
 
 
-def test_mask_small_values_lwc():
+def test_mask_small_values_lwc() -> None:
     name = "lwc_lol"
     data = ma.array([[0, 1], [3, 6], [5, 8]])
     data = plt.mask_small_values(data, name)
@@ -121,7 +122,7 @@ def test_mask_small_values_lwc():
     testing.assert_array_almost_equal(data.mask, compare.mask)
 
 
-def test_mask_small_values_lwc_mask():
+def test_mask_small_values_lwc_mask() -> None:
     name = "lwc_lol"
     data = ma.array([[0, 0.000001], [3, 6], [5, 8]])
     data = plt.mask_small_values(data, name)
@@ -131,7 +132,7 @@ def test_mask_small_values_lwc_mask():
     testing.assert_array_almost_equal(data.mask, compare.mask)
 
 
-def test_mask_small_values_iwc():
+def test_mask_small_values_iwc() -> None:
     name = "iwc_lol"
     data = ma.array([[0, 1], [3, 6], [5, 8]])
     data = plt.mask_small_values(data, name)
@@ -140,7 +141,7 @@ def test_mask_small_values_iwc():
     testing.assert_array_almost_equal(data.mask, compare.mask)
 
 
-def test_mask_small_values_iwc_mask():
+def test_mask_small_values_iwc_mask() -> None:
     name = "iwc_lol"
     data = ma.array([[0, 0.00000001], [3, 6], [5, 8]])
     data = plt.mask_small_values(data, name)
@@ -150,7 +151,7 @@ def test_mask_small_values_iwc_mask():
     testing.assert_array_almost_equal(data.mask, compare.mask)
 
 
-def test_mask_small_values():
+def test_mask_small_values() -> None:
     name = "cf_lol"
     data = ma.array([[0, 1], [3, 6], [5, 8]])
     data = plt.mask_small_values(data, name)
@@ -159,7 +160,7 @@ def test_mask_small_values():
     testing.assert_array_almost_equal(data.mask, compare.mask)
 
 
-def test_mask_small_values_mask():
+def test_mask_small_values_mask() -> None:
     name = "cf_lol"
     data = ma.array([[0, -0.000001], [3, 6], [5, 8]])
     data_mask = plt.mask_small_values(data, name)
@@ -169,7 +170,7 @@ def test_mask_small_values_mask():
     testing.assert_array_equal(data_mask.mask, compare.mask)
 
 
-def test_reshape_1d2nd():
+def test_reshape_1d2nd() -> None:
     oned = np.array([1, 2, 3, 4])
     twod = np.array([[0, 0], [0, 0], [0, 0], [0, 0]])
     compare = np.array([[1, 1], [2, 2], [3, 3], [4, 4]])
@@ -177,29 +178,31 @@ def test_reshape_1d2nd():
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_create_segment_values():
+def test_create_segment_values() -> None:
     model_mask = np.array([[0, 1, 1, 0], [0, 0, 1, 0], [1, 0, 0, 0]], dtype=bool)
+    model = ma.array(np.ones(model_mask.shape), mask=model_mask)
     obs_mask = np.array([[0, 0, 0, 0], [0, 0, 1, 0], [1, 0, 1, 1]], dtype=bool)
-    x, _ = plt.create_segment_values([model_mask, obs_mask])
+    obs = ma.array(np.ones(obs_mask.shape), mask=obs_mask)
+    x = plt.create_segment_values(model, obs)
     compare = np.array([[2, 3, 3, 2], [2, 2, 0, 2], [0, 2, 1, 1]])
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_rolling_mean():
+def test_rolling_mean() -> None:
     data = np.ma.array([1, 2, 7, 4, 2, 3, 8, 5])
     x = plt.rolling_mean(data, 2)
     compare = np.array([1.5, 4.5, 5.5, 3, 2.5, 5.5, 6.5, 5])
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_rolling_mean_nan():
+def test_rolling_mean_nan() -> None:
     data = np.ma.array([1, 2, np.nan, 4, 2, np.nan, 8, 5])
     x = plt.rolling_mean(data, 2)
     compare = np.array([1.5, 2, 4, 3, 2, 8, 6.5, 5])
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_rolling_mean_mask():
+def test_rolling_mean_mask() -> None:
     data = np.ma.array([1, 2, 7, 4, 2, 3, 8, 5])
     data.mask = np.array([0, 0, 1, 0, 1, 0, 0, 1])
     x = plt.rolling_mean(data, 2)
@@ -207,7 +210,7 @@ def test_rolling_mean_mask():
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_rolling_mean_all_mask():
+def test_rolling_mean_all_mask() -> None:
     data = np.ma.array([1, 2, 7, 4, 2, 3, 8, 5])
     data.mask = np.array([0, 1, 1, 1, 1, 0, 0, 1])
     x = plt.rolling_mean(data, 2)
@@ -215,16 +218,16 @@ def test_rolling_mean_all_mask():
     testing.assert_array_almost_equal(x, compare)
 
 
-def test_change2one_dim_axes_maskY():
+def test_change2one_dim_axes_maskY() -> None:
     x = np.ma.array(
-        [[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]]
+        [[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]],
     )
     y = np.ma.array(
-        [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]
+        [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
     )
     y[1] = np.ma.masked
     data = np.ma.array(
-        [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]]
+        [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]],
     )
     x, y, data = plt.change2one_dim_axes(x, y, data)
     compare_x = np.array([1, 2, 3, 4])
@@ -233,16 +236,16 @@ def test_change2one_dim_axes_maskY():
     testing.assert_array_almost_equal(y, compare_y)
 
 
-def test_change2one_dim_axes_maskX():
+def test_change2one_dim_axes_maskX() -> None:
     x = np.ma.array(
-        [[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]]
+        [[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]],
     )
     y = np.ma.array(
-        [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]
+        [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
     )
     x[1] = np.ma.masked
     data = np.ma.array(
-        [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]]
+        [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]],
     )
     x, y, data = plt.change2one_dim_axes(x, y, data)
     compare_x = np.array([1, 2, 3, 4])
@@ -251,17 +254,17 @@ def test_change2one_dim_axes_maskX():
     testing.assert_array_almost_equal(y, compare_y)
 
 
-def test_change2one_dim_axes():
+def test_change2one_dim_axes() -> None:
     x = np.ma.array(
-        [[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]]
+        [[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]],
     )
     compare_x = np.copy(x)
     y = np.ma.array(
-        [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]
+        [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
     )
     compare_y = np.copy(y)
     data = np.ma.array(
-        [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]]
+        [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]],
     )
     x, y, data = plt.change2one_dim_axes(x, y, data)
     testing.assert_array_almost_equal(x, compare_x)