Merge branch 'RC_v1.6.0' of https://github.com/tobac-project/tobac into xarray_notebook_update

Author: w-k-jones

tobac/merge_split.py

@@ -185,7 +185,12 @@ def merge_split_MEST(
     if PBC_flag in ["hdim_1", "hdim_2", "both"]:
         # Note that we multiply by dxy to get the distances in spatial coordinates
         dist_func = build_distance_function(
-            min_h1 * dxy, max_h1 * dxy, min_h2 * dxy, max_h2 * dxy, PBC_flag, is_3D
+            min_h1 * dxy if min_h1 is not None else None,
+            max_h1 * dxy if max_h1 is not None else None,
+            min_h2 * dxy if min_h2 is not None else None,
+            max_h2 * dxy if max_h2 is not None else None,
+            PBC_flag,
+            is_3D,
         )
         cell_start_tree = BallTree(
             cell_start_locations, metric="pyfunc", func=dist_func

tobac/tests/test_analysis_spatial.py

@@ -20,7 +20,10 @@
 from tobac.utils.datetime import to_cftime, to_datetime64
 
 
-def test_calculate_distance():
+def test_calculate_distance_xy():
+    """
+    Test for tobac.analysis.spatial.calculate_distance with cartesian coordinates
+    """
     test_features = pd.DataFrame(
         {
             "feature": [1, 2],
@@ -36,6 +39,13 @@ def test_calculate_distance():
 
     assert calculate_distance(test_features.iloc[0], test_features.iloc[1]) == 1000
 
+
+def test_calculate_distance_latlon():
+    """
+    Test for tobac.analysis.spatial.calculate_distance with latitude/longitude
+    coordinates
+    """
+
     test_features = pd.DataFrame(
         {
             "feature": [1, 2],
@@ -53,6 +63,27 @@ def test_calculate_distance():
         test_features.iloc[0], test_features.iloc[1]
     ) == pytest.approx(1.11e5, rel=1e4)
 
+
+def test_calculate_distance_latlon_wrong_order():
+    """
+    Test for tobac.analysis.spatial.calculate_distance with latitude/longitude
+    coordinates provided in the wrong order. When lat/lon are provided with
+    standard naming the function should detect this and switch their order to
+    ensure that haversine distances are calculated correctly.
+    """
+
+    test_features = pd.DataFrame(
+        {
+            "feature": [1, 2],
+            "frame": [0, 0],
+            "time": [
+                datetime(2000, 1, 1),
+                datetime(2000, 1, 1),
+            ],
+            "longitude": [0, 1],
+            "latitude": [0, 0],
+        }
+    )
     # Test that if latitude and longitude coord names are given in the wrong order, then they are swapped:
     # (expectation is hdim1=y=latitude, hdim2=x=longitude, doesn't matter for x/y but does matter for lat/lon)
     assert calculate_distance(
@@ -64,14 +95,16 @@ def test_calculate_distance():
     ) == pytest.approx(1.11e5, rel=1e4)
 
 
-def test_calculate_distance_errors():
-    # Test invalid method_distance
+def test_calculate_distance_error_invalid_method():
+    """Test invalid method_distance"""
     with pytest.raises(ValueError, match="method_distance invalid*"):
         calculate_distance(
             pd.DataFrame(), pd.DataFrame(), method_distance="invalid_method_distance"
         )
 
-    # Test no horizontal coordinates"
+
+def test_calculate_distance_error_no_coords():
+    """Test no horizontal coordinates in input dataframe"""
     test_features = pd.DataFrame(
         {
             "feature": [1, 2],
@@ -86,7 +119,9 @@ def test_calculate_distance_errors():
     with pytest.raises(ValueError):
         calculate_distance(test_features.iloc[0], test_features.iloc[1])
 
-    # Test dataframes with mismatching coordinates:
+
+def test_calculate_distance_error_mismatched_coords():
+    """Test dataframes with mismatching coordinates"""
     with pytest.raises(ValueError, match="Discovered coordinates*"):
         calculate_distance(
             pd.DataFrame(
@@ -109,7 +144,9 @@ def test_calculate_distance_errors():
             ),
         )
 
-    # Test invalid method:
+
+def test_calculate_distance_error_no_method():
+    """Test hdim1_coord/hdim2_coord specified but no method_distance"""
     test_features = pd.DataFrame(
         {
             "feature": [1, 2],
@@ -122,30 +159,31 @@ def test_calculate_distance_errors():
             "projection_y_coordinate": [0, 0],
         }
     )
-    with pytest.raises(ValueError):
-        calculate_distance(
-            test_features.iloc[0],
-            test_features.iloc[1],
-            method_distance="invalid_method",
-        )
 
-    # Test hdim1_coord/hdim2_coord specified but no method_distance
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="method_distance parameter must*"):
         calculate_distance(
             test_features.iloc[0],
             test_features.iloc[1],
             hdim1_coord="projection_y_coordinate",
         )
 
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="method_distance parameter must*"):
         calculate_distance(
             test_features.iloc[0],
             test_features.iloc[1],
             hdim2_coord="projection_x_coordinate",
         )
 
 
-def test_calculate_velocity_individual_xy():
+@pytest.mark.parametrize(
+    "x_coord, y_coord",
+    [("x", "y"), ("projection_x_coordinate", "projection_y_coordinate")],
+)
+def test_calculate_velocity_individual_xy(x_coord, y_coord):
+    """
+    Test calculate_velocity_individual gives the correct result for a single
+    track woth different x/y coordinate names
+    """
     test_features = pd.DataFrame(
         {
             "feature": [1, 2],
@@ -154,8 +192,8 @@ def test_calculate_velocity_individual_xy():
                 datetime(2000, 1, 1, 0, 0),
                 datetime(2000, 1, 1, 0, 10),
             ],
-            "projection_x_coordinate": [0, 6000],
-            "projection_y_coordinate": [0, 0],
+            x_coord: [0, 6000],
+            y_coord: [0, 0],
         }
     )
 
@@ -164,29 +202,40 @@ def test_calculate_velocity_individual_xy():
         == 10
     )
 
+
+@pytest.mark.parametrize(
+    "lat_coord, lon_coord", [("lat", "lon"), ("latitude", "longitude")]
+)
+def test_calculate_velocity_individual_latlon(lat_coord, lon_coord):
+    """
+    Test calculate_velocity_individual gives the correct result for a single
+    track woth different lat/lon coordinate names
+    """
     test_features = pd.DataFrame(
         {
             "feature": [1, 2],
-            "frame": [0, 1],
+            "frame": [0, 0],
             "time": [
                 datetime(2000, 1, 1, 0, 0),
                 datetime(2000, 1, 1, 0, 10),
             ],
-            "x": [0, 6000],
-            "y": [0, 0],
+            lon_coord: [0, 1],
+            lat_coord: [0, 0],
         }
     )
 
-    assert (
-        calculate_velocity_individual(test_features.iloc[0], test_features.iloc[1])
-        == 10
-    )
+    assert calculate_velocity_individual(
+        test_features.iloc[0], test_features.iloc[1]
+    ) == pytest.approx(1.11e5 / 600, rel=1e2)
 
 
 @pytest.mark.parametrize(
     "time_format", ("datetime", "datetime64", "proleptic_gregorian", "360_day")
 )
 def test_calculate_velocity(time_format):
+    """
+    Test velocity calculation using different time formats
+    """
     test_features = pd.DataFrame(
         {
             "feature": [1, 2, 3, 4],

tobac/tests/test_datetime.py

@@ -9,6 +9,7 @@
 
 
 def test_to_cftime():
+    """Test conversion of datetime types to cftime calendars"""
     test_dates = [
         "2000-01-01",
         "2000-01-01 00:00:00",
@@ -34,8 +35,24 @@ def test_to_cftime():
             2000, 1, 1
         )
 
+    # Test array-like input
+    for date in test_dates:
+        assert datetime_utils.to_cftime([date], "standard")[0] == cftime.datetime(
+            2000, 1, 1
+        )
+        assert datetime_utils.to_cftime([date], "gregorian")[
+            0
+        ] == cftime.DatetimeGregorian(2000, 1, 1)
+        assert datetime_utils.to_cftime([date], "360_day")[0] == cftime.Datetime360Day(
+            2000, 1, 1
+        )
+        assert datetime_utils.to_cftime([date], "365_day")[0] == cftime.DatetimeNoLeap(
+            2000, 1, 1
+        )
+
 
 def test_to_timestamp():
+    """Test conversion of various datetime types to pandas timestamps"""
     test_dates = [
         "2000-01-01",
         "2000-01-01 00:00:00",
@@ -52,8 +69,13 @@ def test_to_timestamp():
     for date in test_dates:
         assert datetime_utils.to_timestamp(date) == pd.to_datetime("2000-01-01")
 
+    # Test array input
+    for date in test_dates:
+        assert datetime_utils.to_timestamp([date])[0] == pd.to_datetime("2000-01-01")
+
 
 def test_to_datetime():
+    """Test conversion of various datetime types to python datetime"""
     test_dates = [
         "2000-01-01",
         "2000-01-01 00:00:00",
@@ -70,8 +92,13 @@ def test_to_datetime():
     for date in test_dates:
         assert datetime_utils.to_datetime(date) == datetime(2000, 1, 1)
 
+    # Test array input
+    for date in test_dates:
+        assert datetime_utils.to_datetime([date])[0] == datetime(2000, 1, 1)
+
 
 def test_to_datetime64():
+    """Test conversion of various datetime types to numpy datetime64"""
     test_dates = [
         "2000-01-01",
         "2000-01-01 00:00:00",
@@ -90,8 +117,15 @@ def test_to_datetime64():
             "2000-01-01 00:00:00.000000000"
         )
 
+    # Test array input
+    for date in test_dates:
+        assert datetime_utils.to_datetime64([date])[0] == np.datetime64(
+            "2000-01-01 00:00:00.000000000"
+        )
+
 
 def test_to_datestr():
+    """Test conversion of various datetime types to ISO format datestring"""
     test_dates = [
         "2000-01-01",
         "2000-01-01 00:00:00",
@@ -113,6 +147,9 @@ def test_to_datestr():
 
 
 def test_to_datestr_array():
+    """Test conversion of arrays of various datetime types to ISO format
+    datestring
+    """
     test_dates = [
         "2000-01-01",
         "2000-01-01 00:00:00",
@@ -132,6 +169,7 @@ def test_to_datestr_array():
 
 
 def test_match_datetime_format():
+    """Test match_datetime_format for various datetime-like combinations"""
     test_dates = [
         "2000-01-01T00:00:00.000000000",
         datetime(2000, 1, 1),
@@ -149,6 +187,9 @@ def test_match_datetime_format():
 
 
 def test_match_datetime_format_array():
+    """Test match_datetime_format for various datetime-like combinations with
+    array input
+    """
     test_dates = [
         "2000-01-01T00:00:00.000000000",
         datetime(2000, 1, 1),
@@ -168,6 +209,8 @@ def test_match_datetime_format_array():
 
 
 def test_match_datetime_format_error():
-    # Test that if a non datetime-like object is provided as tagert a ValueError is raised:
-    with pytest.raises(ValueError):
+    """Test that if a non datetime-like object is provided as target to
+    match_datetime_format that a ValueError is raised:
+    """
+    with pytest.raises(ValueError, match="Target is not a valid datetime*"):
         datetime_utils.match_datetime_format(datetime(2000, 1, 1), 1.5)

tobac/tests/test_feature_detection.py

@@ -874,6 +874,9 @@ def test_feature_detection_preserve_datetime_3d():
 
 
 def test_feature_detection_360_day_calendar():
+    """Tests that datetime format and feature detection work correctly with
+    cftime 360-day calendars
+    """
     test_dset_size = (50, 50)
     test_hdim_1_pt = 20.0
     test_hdim_2_pt = 20.0

tobac/tests/test_generators.py

@@ -13,6 +13,7 @@
 
 
 def test_field_and_features_over_time():
+    """Test iterating over field_and_features_over_time generator"""
     test_data = xr.DataArray(
         np.zeros([2, 10, 10]),
         dims=("time", "y", "x"),
@@ -56,6 +57,9 @@ def test_field_and_features_over_time():
 
 
 def test_field_and_features_over_time_time_padding():
+    """Test the time_padding functionality of field_and_features_over_time
+    generator
+    """
     test_data = xr.DataArray(
         np.zeros([1, 10, 10]),
         dims=("time", "y", "x"),
@@ -104,6 +108,7 @@ def test_field_and_features_over_time_time_padding():
 
 
 def test_field_and_features_over_time_cftime():
+    """Test field_and_features_over_time when given cftime datetime formats"""
     test_data = xr.DataArray(
         np.zeros([2, 10, 10]),
         dims=("time", "y", "x"),
@@ -153,6 +158,9 @@ def test_field_and_features_over_time_cftime():
 
 
 def test_field_and_features_over_time_time_var_name():
+    """Test field_and_features_over_time generator works correctly with a time
+    coordinate name other than "time"
+    """
     # Test non-standard time coord name:
     test_data = xr.DataArray(
         np.zeros([2, 10, 10]),
@@ -180,6 +188,10 @@ def test_field_and_features_over_time_time_var_name():
 
 
 def test_field_and_features_over_time_time_var_name_error():
+    """Test that field_and_features_over_time generator raises the correct
+    error when the name of the time coordinates do not match between the given
+    data and dataframe
+    """
     # Test if time_var_name not in dataarray:
     test_data = xr.DataArray(
         np.zeros([2, 10, 10]),
@@ -199,7 +211,7 @@ def test_field_and_features_over_time_time_var_name_error():
         }
     )
 
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="time not present in input field*"):
         next(generators.field_and_features_over_time(test_data, test_features))
 
     # Test if time var name not in dataframe:
@@ -221,5 +233,5 @@ def test_field_and_features_over_time_time_var_name_error():
         }
     )
 
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="time not present in input feature*"):
         next(generators.field_and_features_over_time(test_data, test_features))