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

tests/models/site/test_management.py

@@ -5,6 +5,7 @@ import pytest
 from hestia_earth.schema import TermTermType
 
 from hestia_earth.models.site.management import MODEL, MODEL_KEY, run, _should_run
+from hestia_earth.models.utils.blank_node import condense_nodes
 from tests.utils import fixtures_path
 
 CLASS_PATH = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
@@ -14,7 +15,8 @@ TERM_BY_ID = {
     'genericCropPlant': {'@type': 'Term', '@id': 'genericCropPlant', 'termType': TermTermType.LANDCOVER.value},
     'wheatPlant': {'@type': 'Term', '@id': 'wheatPlant', 'termType': TermTermType.LANDCOVER.value},
     'oatPlant': {'@type': 'Term', '@id': 'oatPlant', 'termType': TermTermType.LANDCOVER.value},
-    'agatiTree': {'@type': 'Term', '@id': 'agatiTree', 'termType': TermTermType.LANDCOVER.value}
+    'agatiTree': {'@type': 'Term', '@id': 'agatiTree', 'termType': TermTermType.LANDCOVER.value},
+    'wildGarlicPlant': {'@type': 'Term', '@id': 'wildGarlicPlant', 'termType': TermTermType.LANDCOVER.value},
 }
 
 
@@ -28,6 +30,152 @@ def lookup_side_effect(*args, **kwargs):
     return True
 
 
+@pytest.mark.parametrize(
+    "test_name,input_nodes,expected_output_nodes",
+    [
+        (
+            "No match",
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2003", "endDate": "2004", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [2]},
+            ],
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2003", "endDate": "2004", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [2]},
+            ],
+        ),
+        (
+            "No continuity",
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2004", "endDate": "2005", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+            ],
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2004", "endDate": "2005", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+            ],
+        ),
+        (
+            "No continuity (multiple values differ)",
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]},
+                {"startDate": "2003", "endDate": "2004", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 30]},
+            ],
+            [
+                {"startDate": "2001", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]},
+                {"startDate": "2003", "endDate": "2004", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 30]},
+            ],
+        ),
+        (
+            "2->1 condense (YYYY dates)",
+            [
+                {"startDate": "2001", "endDate": "2001", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]},
+                {"startDate": "2002", "endDate": "2002", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2002-12-31", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [10, 20]}
+            ],
+        ),
+        (
+            "4->2 condense (YYYY-MM dates)",
+            [
+                {"startDate": "2001-01", "endDate": "2001-12", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2002-01", "endDate": "2002-03", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2002-03-31", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]}
+            ],
+        ),
+        (
+            "2->1 condense (YYYY-MM-DD dates)",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-12-31", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+                {"startDate": "2002-01-01", "endDate": "2002-05-04", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2002-05-04", "term": {"@id": "treeNutTree", "units": "% area"},
+                 "value": [2]}
+            ],
+        ),
+        (
+            "3->1 condense",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2002-01-01", "endDate": "2002-10-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2002-11-01", "endDate": "2004-04-05", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2004-04-05", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]}
+            ],
+        ),
+        (
+            "3->2 partial condense",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2012-02-01", "endDate": "2012-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2002-01-01", "endDate": "2003-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2003-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]},
+                {"startDate": "2012-02-01", "endDate": "2012-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [9]}
+            ],
+        ),
+        (
+            "7->2 multi-condense",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-11-30", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2012-02-01", "endDate": "2012-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2001-12-01", "endDate": "2001-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2002-01-01", "endDate": "2002-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2013-01-01", "endDate": "2013-05-20", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2002-12-31", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]},
+                {"startDate": "2012-02-01", "endDate": "2013-05-20", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [7]}
+            ],
+        ),
+    ]
+)
+def test_condense_nodes(test_name, input_nodes, expected_output_nodes):
+    assert condense_nodes(input_nodes) == expected_output_nodes
+
+
 @patch(f"{CLASS_PATH}.download_hestia", side_effect=lambda id, *args: TERM_BY_ID[id])
 @patch(f"{CLASS_PATH}.related_cycles")
 def test_should_run(mock_related_cycles, *args):
@@ -121,7 +269,19 @@ def test_should_run(mock_related_cycles, *args):
         ("Example 1", f"{fixtures_folder}/inputs/example1"),
         ("Example 2", f"{fixtures_folder}/inputs/example2"),
         ("Example 3", f"{fixtures_folder}/inputs/example3"),
-        ("Example 4", f"{fixtures_folder}/inputs/example4")
+        ("Example 4", f"{fixtures_folder}/inputs/example4"),
+        ("Condense Nodes", f"{fixtures_folder}/inputs/condense_nodes")
+        # Expected:
+        #   - appleTree (81) x 3 condenses 2020-03-01 to 2021-02-15
+        #   - animalManureUsed (true) x 2 condenses 2001-04-01 to 2001-12-31
+        #   - treeNutTree, lebbekTree (82) does not condense [different terms]
+        #   - organicFertiliserUsed (true|false) does not condense [different values]
+        #   - glassOrHighAccessibleCover (83) does not condense [different date ranges (overlapping)]
+        #   - durianTree (84) does not condense [different date ranges (disjoint)]
+        #   - irrigatedSurfaceIrrigationContinuouslyFlooded (85) does not condense ["%" units]
+        #   - sassafrasTree (86) x 2 condenses 2001-01-01 to 2004-12-31
+        #   - bananaPlant (87) does not condense [non-consecutive years]
+        #   - durianTree (89) does not condense [dates overwritten See 808]
     ]
 )
 @patch(f"{CLASS_PATH}.download_hestia", side_effect=lambda id, *args: TERM_BY_ID[id])

tests/models/utils/test_blank_node.py

@@ -12,13 +12,10 @@ from hestia_earth.models.utils.blank_node import (
     _get_datestr_format,
     _run_required,
     _run_model_required,
-    _should_run_array_treatment,
-    ArrayTreatment,
     cumulative_nodes_match,
     DatestrFormat,
     DatestrGapfillMode,
     DatetimeRange,
-    get_node_value,
     group_nodes_by_year,
     group_nodes_by_year_and_month,
     GroupNodesByYearMode,
@@ -63,282 +60,6 @@ def test_run_model_required():
     })
 
 
-# --- test should_run_array_treatment ---
-
-
-def test_should_run_array_treatment_true():
-    VALUE = [24, 87, 34, 12]
-    assert _should_run_array_treatment(VALUE) is True
-
-
-def test_should_run_array_treatment_false_empty_list():
-    VALUE = []
-    assert _should_run_array_treatment(VALUE) is False
-
-
-def test_should_run_array_treatment_false_not_iterable():
-    VALUE = 1
-    assert _should_run_array_treatment(VALUE) is False
-
-
-# --- test get_node_value ---
-
-
-FULL_TILLAGE_AS_PRACTICE = {
-    "@type": "Practice",
-    "term": {
-        "@type": "Term",
-        "@id": "fullTillage"
-    },
-    "value": [50, 50, 60, 70]
-}
-
-FULL_TILLAGE_AS_MANAGEMENT = {
-    "@type": "Management",
-    "term": {
-        "@type": "Term",
-        "@id": "fullTillage"
-    },
-    "value": 100
-}
-
-EXPECTED_EMPTY_LIST = 0
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_list_reduce_default(*args):
-    """
-    Should return the reduced value of the value list using the array treatment specified in the term lookup
-    (or ArrayTreatment.FIRST if no lookup value available).
-
-    The lookup array treatment for `fullTillage` is `first`, therefore a return value of `50` is expected.
-    """
-    EXPECTED = 50
-    result = get_node_value(FULL_TILLAGE_AS_PRACTICE)
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_list_reduce_mean(*args):
-    """
-    Should return the mean value of the value list.
-
-    `statistics.mean` function is used here.
-    """
-    EXPECTED = 57.5
-    result = get_node_value(
-        FULL_TILLAGE_AS_PRACTICE, array_treatment=ArrayTreatment.MEAN
-    )
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_list_reduce_mode(*args):
-    """
-    Should return the mode value of the value list.
-
-    `statistics.mode` function is used here.
-    """
-    EXPECTED = 50
-    result = get_node_value(
-        FULL_TILLAGE_AS_PRACTICE, array_treatment=ArrayTreatment.MODE
-    )
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_list_reduce_sum(*args):
-    """
-    Should return the sum value of the value list.
-    """
-    EXPECTED = 230
-    result = get_node_value(
-        FULL_TILLAGE_AS_PRACTICE, array_treatment=ArrayTreatment.SUM
-    )
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_list_reduce_first(*args):
-    """
-    Should return the first value of the value list.
-    """
-    EXPECTED = 50
-    result = get_node_value(
-        FULL_TILLAGE_AS_PRACTICE, array_treatment=ArrayTreatment.FIRST
-    )
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_list_reduce_last(*args):
-    """
-    Should return the last value of the value list.
-    """
-    EXPECTED = 70
-    result = get_node_value(
-        FULL_TILLAGE_AS_PRACTICE, array_treatment=ArrayTreatment.LAST
-    )
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_list_bools_reduce_mean(*args):
-    """
-    If value is list of bools, the `satistics.mean` interprets them as integers (0 or 1),
-    therefore number is returned.
-    """
-    EXPECTED = 1/3
-    NODE = {"value": [False, False, True]}
-    result = get_node_value(
-        NODE, array_treatment=ArrayTreatment.MEAN
-    )
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_list_bools_reduce_mode(*args):
-    """
-    If value is list of bools, the `satistics.mode` interprets them as bools and returns the most
-    common bool value as expected.
-    """
-    EXPECTED = False
-    NODE = {"value": [False, False, True]}
-    result = get_node_value(
-        NODE, array_treatment=ArrayTreatment.MODE
-    )
-    assert result == EXPECTED
-    assert isinstance(result, bool)
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_list_bools_reduce_sum(*args):
-    """
-    If value is list of bools, the built-in `sum` interprets them as integers (0 or 1),
-    therefore number is returned.
-    """
-    EXPECTED = 1
-    NODE = {"value": [False, False, True]}
-    result = get_node_value(
-        NODE, array_treatment=ArrayTreatment.SUM
-    )
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_empty_list_reduce_default(*args):
-    """
-    Empty list return as 0 if keyword arg `reduce_value_list` = `True`.
-    """
-    NODE = {"value": []}
-    result = get_node_value(NODE)
-    assert result == EXPECTED_EMPTY_LIST
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_empty_list_reduce_mean(*args):
-    """
-    Empty list return as 0 if keyword arg `reduce_value_list` = `True`.
-    """
-    NODE = {"value": []}
-    result = get_node_value(
-        NODE, array_treatment=ArrayTreatment.MEAN
-    )
-    assert result == EXPECTED_EMPTY_LIST
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_empty_list_reduce_mode(*args):
-    """
-    Empty list return as 0 if keyword arg `reduce_value_list` = `True`.
-    """
-    NODE = {"value": []}
-    result = get_node_value(
-        NODE, array_treatment=ArrayTreatment.MODE
-    )
-    assert result == EXPECTED_EMPTY_LIST
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_empty_list_reduce_sum(*args):
-    """
-    Empty list return as 0 if keyword arg `reduce_value_list` = `True`.
-    """
-    NODE = {"value": []}
-    result = get_node_value(
-        NODE, array_treatment=ArrayTreatment.SUM
-    )
-    assert result == EXPECTED_EMPTY_LIST
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_empty_list_reduce_first(*args):
-    """
-    Empty list return as 0 if keyword arg `reduce_value_list` = `True`.
-    """
-    NODE = {"value": []}
-    result = get_node_value(
-        NODE, array_treatment=ArrayTreatment.FIRST
-    )
-    assert result == EXPECTED_EMPTY_LIST
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_empty_list_reduce_last(*args):
-    """
-    Empty list return as 0 if keyword arg `reduce_value_list` = `True`.
-    """
-    NODE = {"value": []}
-    result = get_node_value(
-        NODE, array_treatment=ArrayTreatment.LAST
-    )
-    assert result == EXPECTED_EMPTY_LIST
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_float(*args):
-    """
-    Non-list values are returned directly, even if if keyword arg `reduce_value_list` = `True`.
-    """
-    EXPECTED = 100
-    result = get_node_value(FULL_TILLAGE_AS_MANAGEMENT)
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_bool_true(*args):
-    """
-    Non-list values are returned directly, even if if keyword arg `reduce_value_list` = `True`.
-    """
-    EXPECTED = True
-    NODE = {"value": True}
-    result = get_node_value(NODE)
-    assert result == EXPECTED
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_bool_false(*args):
-    """
-    Non-list values are returned directly, even if if keyword arg `reduce_value_list` = `True`.
-    """
-    EXPECTED = False
-    NODE = {"value": False}
-    result = get_node_value(NODE)
-    assert result == EXPECTED
-    assert isinstance(result, bool)
-
-
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.FIRST)
-def test_get_node_value_no_value(*args):
-    """
-    Missing values are returned as 0.
-    """
-    EXPECTED = 0
-    NODE = {}
-    result = get_node_value(NODE)
-    assert result == EXPECTED
-
-
 # --- test cumulative_nodes_match ---
 
 
@@ -370,7 +91,6 @@ CROP_RESIDUE_NODES = [
 ]
 
 
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.MEAN)
 def test_cumulative_nodes_match_true(*args):
     result = cumulative_nodes_match(
         lambda node: node.get("term", {}).get("@id") in [
@@ -382,7 +102,6 @@ def test_cumulative_nodes_match_true(*args):
     assert result is True
 
 
-@patch(f"{class_path}._retrieve_array_treatment", return_value=ArrayTreatment.MEAN)
 def test_cumulative_nodes_match_false(*args):
     result = cumulative_nodes_match(
         lambda node: node.get("term", {}).get("@id") in ["aboveGroundCropResidueLeftOnField"],

tests/models/utils/test_lookup.py

@@ -0,0 +1,10 @@
+from hestia_earth.models.utils.lookup import is_siteType_allowed
+
+
+def test_is_siteType_allowed():
+    term = {'@id': 'pastureGrass', 'termType': 'landUseManagement'}
+    site = {'@type': 'Site', 'siteType': 'cropland'}
+    assert not is_siteType_allowed(site, term)
+
+    cycle = {'otherSites': [{'@type': 'Site', 'siteType': 'permanent pasture'}]}
+    assert is_siteType_allowed(cycle, term) is True