hestia-earth-models 0.61.7__py3-none-any.whl → 0.61.8__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/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_descriptive_stats.py

@@ -0,0 +1,134 @@
+from numpy import array, inf
+from numpy.testing import assert_almost_equal
+from pytest import mark
+
+from hestia_earth.schema import MeasurementStatsDefinition
+
+from hestia_earth.models.utils.descriptive_stats import (
+    _calc_confidence_level, calc_confidence_level_monte_carlo, calc_descriptive_stats, calc_precision_monte_carlo,
+    calc_required_iterations_monte_carlo, calc_z_critical
+)
+
+# confidence_level, n_sided, z_critical
+CONFIDENCE_INTERVAL_PARAMS = [
+    # 1 sided
+    (0, 1, -inf),
+    (50, 1, 0),
+    (80, 1, 0.8416),
+    (90, 1, 1.2816),
+    (95, 1, 1.6449),
+    (99, 1, 2.3263),
+    (100, 1, inf),
+    # 2 sided
+    (0, 2, 0),
+    (50, 2, 0.6745),
+    (80, 2, 1.2816),
+    (90, 2, 1.6449),
+    (95, 2, 1.9600),
+    (99, 2, 2.5758),
+    (100, 2, inf)
+]
+
+
+@mark.parametrize(
+    "confidence_level, n_sided, z_critical",
+    CONFIDENCE_INTERVAL_PARAMS,
+    ids=[f"z={z}, n={n}" for _, n, z in CONFIDENCE_INTERVAL_PARAMS]
+)
+def test_calc_confidence_level(confidence_level, n_sided, z_critical):
+    result = _calc_confidence_level(z_critical, n_sided=n_sided)
+    assert_almost_equal(result, confidence_level, decimal=2)
+
+
+@mark.parametrize(
+    "confidence_level, n_sided, z_critical",
+    CONFIDENCE_INTERVAL_PARAMS,
+    ids=[f"conf={conf}, n={n}" for conf, n, _ in CONFIDENCE_INTERVAL_PARAMS]
+)
+def test_calc_z_critical(confidence_level, n_sided, z_critical):
+    result = calc_z_critical(confidence_level, n_sided=n_sided)
+    assert_almost_equal(result, z_critical, decimal=4)
+
+
+# confidence_level, n_iterations, precision, sd
+MONTE_CARLO_PARAMS = [
+    (95, 80767, 0.01, 1.45),
+    (95, 1110, 0.01, 0.17),
+    (99, 1917, 0.01, 0.17),
+    (50, 102, 100.18, 1500)
+]
+
+
+@mark.parametrize(
+    "confidence_level, n_iterations, precision, sd",
+    MONTE_CARLO_PARAMS,
+    ids=[f"n={n}, prec={prec}, sd={sd}" for _, n, prec, sd in MONTE_CARLO_PARAMS]
+)
+def test_calc_confidence_level_monte_carlo(confidence_level, n_iterations, precision, sd):
+    result = calc_confidence_level_monte_carlo(n_iterations, precision, sd,)
+    assert_almost_equal(result, confidence_level, decimal=2)
+
+
+@mark.parametrize(
+    "confidence_level, n_iterations, precision, sd",
+    MONTE_CARLO_PARAMS,
+    ids=[f"conf={conf}, prec={prec}, sd={sd}" for conf, _, prec, sd in MONTE_CARLO_PARAMS]
+)
+def test_calc_required_iterations_monte_carlo(confidence_level, n_iterations, precision, sd):
+    result = calc_required_iterations_monte_carlo(confidence_level, precision, sd)
+    assert result == n_iterations
+
+
+@mark.parametrize(
+    "confidence_level, n_iterations, precision, sd",
+    MONTE_CARLO_PARAMS,
+    ids=[f"conf={conf}, n={n}, sd={sd}" for conf, n, _, sd in MONTE_CARLO_PARAMS]
+)
+def test_calc_precision_monte_carlo(confidence_level, n_iterations, precision, sd):
+    result = calc_precision_monte_carlo(confidence_level, n_iterations, sd)
+    assert_almost_equal(result, precision, decimal=2)
+
+
+EXPECTED_FLATTENED = {
+    "value": [5],
+    "sd": [2.581989],
+    "min": [1],
+    "max": [9],
+    "statsDefinition": "simulated",
+    "observations": [9]
+}
+
+EXPECTED_COLUMNWISE = {
+    "value": [4, 5, 6],
+    "sd": [2.44949, 2.44949, 2.44949],
+    "min": [1, 2, 3],
+    "max": [7, 8, 9],
+    "statsDefinition": "simulated",
+    "observations": [3, 3, 3]
+}
+
+EXPECTED_ROWWISE = {
+    "value": [2, 5, 8],
+    "sd": [0.816497, 0.816497, 0.816497],
+    "min": [1, 4, 7],
+    "max": [3, 6, 9],
+    "statsDefinition": "simulated",
+    "observations": [3, 3, 3]
+}
+
+
+@mark.parametrize(
+    "axis, expected",
+    [(None, EXPECTED_FLATTENED), (0, EXPECTED_COLUMNWISE), (1, EXPECTED_ROWWISE)],
+    ids=["flattened", "columnwise", "rowwise"]
+)
+@mark.parametrize("stats_definition", [MeasurementStatsDefinition.SIMULATED, "simulated"], ids=["Enum", "str"])
+def test_calc_descriptive_stats(stats_definition, axis, expected):
+    ARR = array([
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9]
+    ])
+
+    result = calc_descriptive_stats(ARR, stats_definition, axis=axis)
+    assert result == expected

tests/models/utils/test_emission.py

@@ -1,7 +1,10 @@
+from pytest import mark
 from unittest.mock import patch
 
+from hestia_earth.schema import EmissionMethodTier
+
 from tests.utils import TERM
-from hestia_earth.models.utils.emission import _new_emission, is_in_system_boundary
+from hestia_earth.models.utils.emission import _new_emission, is_in_system_boundary, min_emission_method_tier
 
 class_path = 'hestia_earth.models.utils.emission'
 
@@ -27,3 +30,50 @@ def test_new_emission(*args):
 def test_is_in_system_boundary():
     assert is_in_system_boundary('ch4ToAirCropResidueBurning') is True
     assert is_in_system_boundary('codToWaterInputsProduction') is False
+
+
+@mark.parametrize(
+    "input, expected",
+    [
+        (
+            (
+                EmissionMethodTier.TIER_1,
+                EmissionMethodTier.TIER_2,
+                EmissionMethodTier.TIER_3
+            ),
+            EmissionMethodTier.TIER_1
+        ),
+        (
+            [
+                EmissionMethodTier.TIER_1,
+                EmissionMethodTier.TIER_2,
+                EmissionMethodTier.TIER_3
+            ],
+            EmissionMethodTier.TIER_1
+        ),
+        (
+            [], EmissionMethodTier.NOT_RELEVANT
+        ),
+        (
+            (
+                EmissionMethodTier.TIER_1.value,
+                EmissionMethodTier.TIER_2.value,
+                EmissionMethodTier.TIER_3.value
+            ),
+            EmissionMethodTier.TIER_1
+        ),
+        (
+            [
+                EmissionMethodTier.TIER_1.value,
+                EmissionMethodTier.TIER_2.value,
+                EmissionMethodTier.TIER_3.value
+            ],
+            EmissionMethodTier.TIER_1
+        ),
+
+    ],
+    ids=["Enum", "list[Enum]", "None", "str", "list[str]"]
+)
+def test_min_emission_method_tier(input, expected):
+    result = min_emission_method_tier(input)
+    assert result == expected

tests/models/utils/test_measurement.py

@@ -1,9 +1,14 @@
-from unittest.mock import patch
 import json
+from pytest import mark
+from unittest.mock import patch
+
+from hestia_earth.schema import MeasurementMethodClassification
+
 from tests.utils import fixtures_path, TERM
 
 from hestia_earth.models.utils.measurement import (
-    _new_measurement, most_relevant_measurement_value, _most_recent_measurements, _shallowest_measurement
+    _new_measurement, most_relevant_measurement_value, _most_recent_measurements, _shallowest_measurement,
+    min_measurement_method_classification
 )
 
 class_path = 'hestia_earth.models.utils.measurement'
@@ -83,3 +88,50 @@ def test_shallowest_measurement():
         expected = json.load(f)
 
     assert _shallowest_measurement(measurements) == expected
+
+
+@mark.parametrize(
+    "input, expected",
+    [
+        (
+            (
+                MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+                MeasurementMethodClassification.TIER_2_MODEL,
+                MeasurementMethodClassification.TIER_1_MODEL
+            ),
+            MeasurementMethodClassification.TIER_1_MODEL
+        ),
+        (
+            [
+                MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+                MeasurementMethodClassification.TIER_2_MODEL,
+                MeasurementMethodClassification.TIER_1_MODEL
+            ],
+            MeasurementMethodClassification.TIER_1_MODEL
+        ),
+        (
+            [], MeasurementMethodClassification.UNSOURCED_ASSUMPTION
+        ),
+        (
+            (
+                MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT.value,
+                MeasurementMethodClassification.TIER_2_MODEL.value,
+                MeasurementMethodClassification.TIER_1_MODEL.value
+            ),
+            MeasurementMethodClassification.TIER_1_MODEL
+        ),
+        (
+            [
+                MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT.value,
+                MeasurementMethodClassification.TIER_2_MODEL.value,
+                MeasurementMethodClassification.TIER_1_MODEL.value
+            ],
+            MeasurementMethodClassification.TIER_1_MODEL
+        ),
+
+    ],
+    ids=["Enum", "list[Enum]", "None", "str", "list[str]"]
+)
+def test_min_measurement_method_classification(input, expected):
+    result = min_measurement_method_classification(input)
+    assert result == expected