hestia-earth-models 0.61.7__py3-none-any.whl → 0.62.0__py3-none-any.whl

tests/models/ipcc2019/test_organicCarbonPerHa_utils.py

@@ -0,0 +1,75 @@
+from pytest import mark
+
+from hestia_earth.models.ipcc2019.organicCarbonPerHa_utils import (
+    format_bool, format_bool_list, format_enum, format_number, format_number_list, IpccSoilCategory
+)
+
+
+@mark.parametrize(
+    "value, expected",
+    [
+        (True, "True"),
+        (False, "False"),
+        ([], "False"),
+        ("str", "True"),
+        (None, "False")
+    ],
+    ids=["True", "False", "list", "str", "None"]
+)
+def test_format_bool(value, expected):
+    assert format_bool(value) == expected
+
+
+@mark.parametrize(
+    "value, expected",
+    [
+        ([True, True, False], "True True False"),
+        ([], "None"),
+        (["Yes", "No", ""], "True True False"),
+        (None, "None")
+    ],
+    ids=["list", "empty list", "list[str]", "None"]
+)
+def test_format_bool_list(value, expected):
+    assert format_bool_list(value) == expected
+
+
+@mark.parametrize(
+    "value, expected",
+    [
+        (IpccSoilCategory.WETLAND_SOILS, IpccSoilCategory.WETLAND_SOILS.value),
+        ("str", "None"),
+        (None, "None")
+    ],
+    ids=["Enum", "str", "None"]
+)
+def test_format_enum(value, expected):
+    assert format_enum(value) == expected
+
+
+@mark.parametrize(
+    "value, expected",
+    [
+        (3.141592653, "3.1"),
+        (0, "0.0"),
+        ("20", "None"),
+        (None, "None")
+    ],
+    ids=["float", "zero", "str", "None"]
+)
+def test_format_number(value, expected):
+    assert format_number(value) == expected
+
+
+@mark.parametrize(
+    "value, expected",
+    [
+        ([3.14, 31.4, 314], "3.1 31.4 314.0"),
+        ([], "None"),
+        (["Yes", "No", ""], "None None None"),
+        (None, "None")
+    ],
+    ids=["list", "empty list", "list[str]", "None"]
+)
+def test_format_number_list(value, expected):
+    assert format_number_list(value) == expected

tests/models/ipcc2019/test_pastureGrass.py

@@ -50,22 +50,6 @@ def test_run(*args):
     assert value == expected
 
 
-@patch(f"{class_path_utils}.download_hestia", side_effect=fake_download_hestia)
-@patch("hestia_earth.models.utils.property.download_hestia", side_effect=fake_download_hestia)
-@patch(f"{class_path}.get_wool_terms", return_value=WOOL_TERMS)
-@patch(f"hestia_earth.models.{MODEL}.utils.get_milkYield_terms", return_value=MILK_YIELD_TERMS)
-@patch(f"{class_path}._new_input", side_effect=fake_new_input)
-def test_run_with_feed(*args):
-    with open(f"{fixtures_folder}/with-feed/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/with-feed/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected
-
-
 @patch(f"{class_path_utils}.download_hestia", side_effect=fake_download_hestia)
 @patch("hestia_earth.models.utils.property.download_hestia", side_effect=fake_download_hestia)
 @patch(f"{class_path}.get_wool_terms", return_value=WOOL_TERMS)

tests/models/site/test_organicCarbonPerHa.py

@@ -5,7 +5,7 @@ from unittest.mock import patch
 from tests.utils import fixtures_path, fake_new_measurement
 
 from hestia_earth.models.site.organicCarbonPerHa import (
-    MODEL, TERM_ID, run, _cdf, _c_to_depth, _get_most_relevant_soc_node, _get_last_date, _should_run_calculation_group
+    MODEL, TERM_ID, run, _cdf, _c_to_depth, _get_most_relevant_soc_node, _get_last_date
 )
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
@@ -14,6 +14,8 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 SUBFOLDERS = [
     "calculate-single",
     "calculate-multiple",
+    "calculate-multiple-with-existing-soc-measurements",  # Closes #823
+    "calculate-multiple-with-multiple-methods",  # Closes #823
     "rescale-single",
     "rescale-multiple",
     "calculate-and-rescale"
@@ -82,17 +84,6 @@ def test_get_most_relevant_soc_node(nodes, expected_id):
     assert _get_most_relevant_soc_node(nodes).get("@id") == expected_id
 
 
-@patch(f"{class_path}.find_term_match")
-def test_should_run_measurements(mock_find):
-    # no measurement => no run
-    mock_find.return_value = {}
-    assert _should_run_calculation_group([]) is False
-
-    # with measurement => run
-    mock_find.return_value = {'value': [10], 'depthUpper': 0, 'depthLower': 10}
-    assert _should_run_calculation_group([]) is True
-
-
 @mark.parametrize("subfolder", SUBFOLDERS)
 @patch(f"{class_path}.get_source", return_value={})
 @patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)

tests/models/site/test_soilMeasurement.py

@@ -135,23 +135,11 @@ def test_harmonise_measurements(measurements_list, returns_dict, expected_value)
         )
     ]
 )
-@patch(f"{class_path}.get_lookup_value")
-def test_should_run(mock_get_lookup, test_name, site, expected_should_run):
-    mock_get_lookup.return_value = True
-    model_key = "clayContent"
-    should_run, *args = _should_run(site=site, model_key=model_key)
+def test_should_run(test_name, site, expected_should_run):
+    should_run, *args = _should_run(site)
     assert should_run == expected_should_run, test_name
 
 
-def lookup_side_effect(*args, **kwargs):
-    _ = kwargs
-    if args[0]["@id"] == "soilPh" and args[1] == "depthSensitive":
-        return False
-    elif args[0]["@id"] in {"baseSaturation", "soilDepth", "rainfallHourly"}:
-        return False
-    return True
-
-
 @pytest.mark.parametrize(
     "test_name",
     [
@@ -165,10 +153,7 @@ def lookup_side_effect(*args, **kwargs):
     ]
 )
 @patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
-@patch(f"{class_path}.get_lookup_value")
-def test_run(mock_lookup, mock_new_measurement, test_name):
-    mock_lookup.side_effect = lookup_side_effect
-
+def test_run(mock_new_measurement, test_name):
     with open(f"{fixtures_folder}/{test_name}/site.jsonld", encoding='utf-8') as f:
         site = json.load(f)
 

tests/models/utils/test_array_builders.py

@@ -0,0 +1,253 @@
+from numpy import array
+from numpy.testing import assert_array_equal
+from numpy.typing import NDArray
+from pytest import mark
+
+from hestia_earth.models.utils.array_builders import (
+    avg_run_in_columnwise, avg_run_in_rowwise, discrete_uniform_1d, discrete_uniform_2d, gen_seed, grouped_avg,
+    normal_1d, normal_2d, plus_minus_uncertainty_to_normal_1d, plus_minus_uncertainty_to_normal_2d,
+    repeat_1d_array_as_columns, repeat_array_as_columns, repeat_array_as_rows, repeat_single, triangular_1d,
+    triangular_2d, truncated_normal_1d, truncated_normal_2d
+)
+
+SEED = 0
+SHAPE = (1000, 1000)
+
+
+def assert_rows_identical(arr: NDArray):
+    """
+    Covert array to a set to remove repeated rows and check that number remaining rows is 1.
+    """
+    assert len(set(map(tuple, arr))) == 1
+
+
+def assert_rows_unique(arr: NDArray):
+    """
+    Covert array to a set to remove repeated rows and check that number remaining rows is the same as the number of
+    original rows.
+    """
+    assert len(set(map(tuple, arr))) == len(arr)
+
+
+def assert_elements_between(arr: NDArray, min: float, max: float):
+    assert ((min <= arr) & (arr <= max)).all()
+
+
+PARAMS_REPEAT_SINGLE = [
+    (3.14159, None, 3.14159),
+    (3.14159, bool, True),
+    (True, None, True),
+    (True, float, 1)
+]
+
+IDS_REPEAT_SINGLE = [
+    f"{type(value).__name__}{f' -> {dtype.__name__}' if dtype else ''}" for value, dtype, _ in PARAMS_REPEAT_SINGLE
+]
+
+
+@mark.parametrize(
+    "value, dtype, expected_element",
+    [(3.14159, None, 3.14159), (3.14159, bool, True), (True, None, True), (True, float, 1)],
+    ids=IDS_REPEAT_SINGLE
+)
+def test_repeat_single(value, dtype, expected_element):
+    SHAPE = (3, 3)
+    EXPECTED = array([
+        [expected_element, expected_element, expected_element],
+        [expected_element, expected_element, expected_element],
+        [expected_element, expected_element, expected_element]
+    ])
+    result = repeat_single(SHAPE, value, dtype=dtype)
+    assert_array_equal(result, EXPECTED)
+
+
+def test_repeat_array_as_columns():
+    INPUT = array([
+        [1, 2, 3],
+        [4, 5, 6]
+    ])
+    EXPECTED = array([
+        [1, 2, 3, 1, 2, 3],
+        [4, 5, 6, 4, 5, 6]
+    ])
+    result = repeat_array_as_columns(2, INPUT)
+    assert_array_equal(result, EXPECTED)
+
+
+def test_repeat_array_as_rows():
+    INPUT = array([
+        [1, 2, 3],
+        [4, 5, 6]
+    ])
+    EXPECTED = array([
+        [1, 2, 3],
+        [4, 5, 6],
+        [1, 2, 3],
+        [4, 5, 6]
+    ])
+    result = repeat_array_as_rows(2, INPUT)
+    assert_array_equal(result, EXPECTED)
+
+
+def test_repeat_1d_array_as_columns():
+    INPUT = array([1, 2, 3])
+    EXPECTED = array([
+        [1, 1, 1],
+        [2, 2, 2],
+        [3, 3, 3]
+    ])
+    result = repeat_1d_array_as_columns(3, INPUT)
+    assert_array_equal(result, EXPECTED)
+
+
+def test_discrete_uniform_1d():
+    MIN, MAX = -100, 100
+    result = discrete_uniform_1d(SHAPE, MIN, MAX, seed=SEED)
+    assert_rows_identical(result)
+    assert_elements_between(result, MIN, MAX)
+    assert result.shape == SHAPE
+
+
+def test_discrete_uniform_2d():
+    MIN, MAX = -100, 100
+    result = discrete_uniform_2d(SHAPE, MIN, MAX, seed=SEED)
+    assert_rows_unique(result)
+    assert_elements_between(result, MIN, MAX)
+    assert result.shape == SHAPE
+
+
+def test_discrete_triangular_1d():
+    LOW, HIGH = -100, 100
+    MODE = -50
+    result = triangular_1d(SHAPE, LOW, HIGH, MODE, seed=SEED)
+    assert_rows_identical(result)
+    assert_elements_between(result, LOW, HIGH)
+    assert result.shape == SHAPE
+
+
+def test_discrete_triangular_2d():
+    LOW, HIGH = -100, 100
+    MODE = 50
+    result = triangular_2d(SHAPE, LOW, HIGH, MODE, seed=SEED)
+    assert_rows_unique(result)
+    assert_elements_between(result, LOW, HIGH)
+    assert result.shape == SHAPE
+
+
+def test_normal_1d():
+    MEAN = 0
+    SD = 50
+    result = normal_1d(SHAPE, MEAN, SD, seed=SEED)
+    assert_rows_identical(result)
+    assert result.shape == SHAPE
+
+
+def test_normal_2d():
+    MEAN = 0
+    SD = 50
+    result = normal_2d(SHAPE, MEAN, SD, seed=SEED)
+    assert_rows_unique(result)
+    assert result.shape == SHAPE
+
+
+def test_truncated_normal_1d():
+    MEAN = 0
+    SD = 50
+    LOW, HIGH = -50, 50
+    result = truncated_normal_1d(SHAPE, MEAN, SD, LOW, HIGH, seed=SEED)
+    assert_rows_identical(result)
+    assert_elements_between(result, LOW, HIGH)
+    assert result.shape == SHAPE
+
+
+def test_truncated_normal_2d():
+    MEAN = 0
+    SD = 50
+    LOW, HIGH = -50, 50
+    result = truncated_normal_2d(SHAPE, MEAN, SD, LOW, HIGH, seed=SEED)
+    assert_rows_unique(result)
+    assert_elements_between(result, LOW, HIGH)
+    assert result.shape == SHAPE
+
+
+def test_plus_minus_uncertainty_to_normal_1d():
+    MEAN = 10
+    UNCERTAINTY = 10
+    CONFIDENCE_INTERVAL = 95
+    result = plus_minus_uncertainty_to_normal_1d(SHAPE, MEAN, UNCERTAINTY, CONFIDENCE_INTERVAL)
+    assert_rows_identical(result)
+    assert result.shape == SHAPE
+
+
+def test_plus_minus_uncertainty_to_normal_2d():
+    MEAN = 10
+    UNCERTAINTY = 10
+    CONFIDENCE_INTERVAL = 95
+    result = plus_minus_uncertainty_to_normal_2d(SHAPE, MEAN, UNCERTAINTY, CONFIDENCE_INTERVAL)
+    assert_rows_unique(result)
+    assert result.shape == SHAPE
+
+
+def test_grouped_avg():
+    INPUT = array([
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+        [10, 11, 12],
+        [13, 14, 15],
+        [16, 17, 18]
+    ])
+    EXPECTED = array([
+        [4, 5, 6],
+        [13, 14, 15]
+    ])
+    result = grouped_avg(INPUT, n=3)
+    assert_array_equal(result, EXPECTED)
+
+
+def test_avg_run_in_columnwise():
+    INPUT = array([
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+        [10, 11, 12],
+        [13, 14, 15],
+        [16, 17, 18]
+    ])
+    EXPECTED = array([
+        [4, 5, 6],
+        [10, 11, 12],
+        [13, 14, 15],
+        [16, 17, 18]
+    ])
+    result = avg_run_in_columnwise(INPUT, n=3)
+    assert_array_equal(result, EXPECTED)
+
+
+def test_avg_run_in_rowwise():
+    INPUT = array([
+        [1, 2, 3, 4, 5],
+        [6, 7, 8, 9, 10],
+        [11, 12, 13, 14, 15]
+    ])
+    EXPECTED = array([
+        [2, 4, 5],
+        [7, 9, 10],
+        [12, 14, 15]
+    ])
+    result = avg_run_in_rowwise(INPUT, n=3)
+    assert_array_equal(result, EXPECTED)
+
+
+def test_gen_seed():
+    NODE = {"@id": "site"}
+    EXPECTED = 2926675914
+    result = gen_seed(NODE)
+    assert result == EXPECTED
+
+
+def test_gen_seed_no_id():
+    NODE = {}
+    EXPECTED = 2140941220
+    result = gen_seed(NODE)
+    assert result == EXPECTED

tests/models/utils/test_blank_node.py

@@ -21,7 +21,8 @@ from hestia_earth.models.utils.blank_node import (
     get_node_value,
     group_nodes_by_year,
     group_nodes_by_year_and_month,
-    GroupNodesByYearMode
+    GroupNodesByYearMode,
+    split_node_by_dates
 )
 
 
@@ -1017,33 +1018,67 @@ def test_group_nodes_by_year_multiple_values_and_dates(mock_parse, system_dateti
             "2001-02",
             "2002-03",
             "2003-01"
+        ],
+        "sd": [
+            0.8, 0.9, 1.0, 0.9, 0.8
+        ],
+        "observations": [
+            100, 100, 100, 100, 100
         ]
     }]
 
     EXPECTED = {
-        2000: [{
-            "dates": ["2000-01", "2000-06"],
-            "fraction_of_node_duration": 0.32475598935226263,
-            "fraction_of_group_duration": 1.0,
-            "value": [1, 2]
-        }],
+        2000: [
+            {
+                "dates": ["2000-01"],
+                "fraction_of_node_duration": 1.0,
+                "fraction_of_group_duration": 0.08469945355191257,
+                "value": [1],
+                "sd": [0.8],
+                "observations": [
+                    100
+                ]
+            },
+            {
+                "dates": ["2000-06"],
+                "fraction_of_node_duration": 1.0,
+                "fraction_of_group_duration": 0.08196721311475409,
+                "value": [2],
+                "sd": [0.9],
+                "observations": [
+                    100
+                ]
+            }
+        ],
         2001: [{
             "dates": ["2001-02"],
-            "fraction_of_node_duration": 0.323868677905945,
-            "fraction_of_group_duration": 1.0,
-            "value": [3]
+            "fraction_of_node_duration": 1.0,
+            "fraction_of_group_duration": 0.07671232876712329,
+            "value": [3],
+            "sd": [1.0],
+            "observations": [
+                100
+            ]
         }],
         2002: [{
             "dates": ["2002-03"],
-            "fraction_of_node_duration": 0.323868677905945,
-            "fraction_of_group_duration": 1.0,
-            "value": [4]
+            "fraction_of_node_duration": 1.0,
+            "fraction_of_group_duration": 0.08493150684931507,
+            "value": [4],
+            "sd": [0.9],
+            "observations": [
+                100
+            ]
         }],
         2003: [{
             "dates": ["2003-01"],
-            "fraction_of_node_duration": 0.027506654835847383,
+            "fraction_of_node_duration": 1.0,
             "fraction_of_group_duration": 0.08493150684931507,
-            "value": [5]
+            "value": [5],
+            "sd": [0.8],
+            "observations": [
+                100
+            ]
         }]
     }
 
@@ -1134,3 +1169,107 @@ def test_group_nodes_by_year_and_month(mock_parse, system_datetime):
 
     result = group_nodes_by_year_and_month(MANAGEMENT)
     assert result == EXPECTED
+
+
+# node, expected
+PARAMS_SPLIT_NODE = [
+    (
+        {},
+        [{}]
+    ),
+    (
+        {"value": [1, 2, 3], "dates": ["2000"]},
+        [{"value": [1, 2, 3], "dates": ["2000"]}]
+    ),
+    (
+        {"value": [1, 2, 3], "startDate": "2000", "endDate": "2001"},
+        [{"value": [1, 2, 3], "startDate": "2000", "endDate": "2001"}]
+    ),
+    (
+        {"value": 1, "startDate": "2000", "endDate": "2001"},
+        [{"value": 1, "startDate": "2000", "endDate": "2001"}]
+    ),
+    (
+        {"value": None},
+        [{"value": None}]
+    ),
+    (
+        {"value": [1, 2, 3], "dates": ["2000", "2001", "2002"]},
+        [
+            {"value": [1], "dates": ["2000"]},
+            {"value": [2], "dates": ["2001"]},
+            {"value": [3], "dates": ["2002"]}
+        ]
+    ),
+    (
+        {
+            "value": [1, 2],
+            "dates": ["2000", "2001"],
+            "sd": [0.816496, 0.816496],
+            "min": [0, 1],
+            "max": [2, 3],
+            "observations": [3, 3]
+        },
+        [
+            {
+                "value": [1],
+                "dates": ["2000"],
+                "sd": [0.816496],
+                "min": [0],
+                "max": [2],
+                "observations": [3]
+            },
+            {
+                "value": [2],
+                "dates": ["2001"],
+                "sd": [0.816496],
+                "min": [1],
+                "max": [3],
+                "observations": [3]
+            }
+        ]
+    ),
+    (
+        {
+            "value": [1, 2],
+            "dates": ["2000", "2001"],
+            "sd": [0.816496, 0.816496],
+            "min": [0, 1],
+            "max": [2, 3],
+            "observations": [3]
+        },
+        [
+            {
+                "value": [1],
+                "dates": ["2000"],
+                "sd": [0.816496],
+                "min": [0],
+                "max": [2],
+                "observations": [3]
+            },
+            {
+                "value": [2],
+                "dates": ["2001"],
+                "sd": [0.816496],
+                "min": [1],
+                "max": [3],
+                "observations": [3]
+            }
+        ]
+    )
+]
+IDS_SPLIT_NODE = [
+    "no split -> empty node",
+    "no split -> not enough dates",  # len(value) and len(dates) MUST match
+    "no split -> startDate & endDate",
+    "no split -> non-iterable value",  # i.e., on a Management or Animal node.
+    "no split -> null value",  # i.e., on a Animal node where value is not required.
+    "value & dates",
+    "descriptive statistics",
+    "descriptive statistics w/ bad key"  # if descriptive statistic keys have wrong length, don't split them
+]
+
+
+@mark.parametrize("node, expected", PARAMS_SPLIT_NODE, ids=IDS_SPLIT_NODE)
+def test_split_node_by_dates(node, expected):
+    assert split_node_by_dates(node) == expected