hestia-earth-models 0.64.11__py3-none-any.whl → 0.64.13__py3-none-any.whl

tests/models/site/test_management.py

@@ -1,152 +1,20 @@
 import json
-from unittest.mock import patch
-
+from unittest.mock import Mock, patch
 import pytest
-from hestia_earth.schema import TermTermType, SiteSiteType
+from hestia_earth.schema import SiteSiteType
 
-from hestia_earth.models.site.management import MODEL, MODEL_KEY, run, _should_run
-from tests.utils import fixtures_path
+from tests.utils import fixtures_path, fake_new_management
+from hestia_earth.models.site.management import MODEL, MODEL_KEY, run
 
-CLASS_PATH = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
+class_path = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{MODEL_KEY}"
 
-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},
-    'wildGarlicPlant': {'@type': 'Term', '@id': 'wildGarlicPlant', 'termType': TermTermType.LANDCOVER.value},
-    'animalHousing': {
-        "@type": "Term",
-        "@id": "animalHousing",
-        "name": "Animal housing",
-        "termType": TermTermType.LANDCOVER.value,
-        "units": "% area"
-    }
-}
-
-LAND_COVER_TERM_BY_SITE_TYPE = {
+_LAND_COVER_TERM_BY_SITE_TYPE = {
     SiteSiteType.ANIMAL_HOUSING.value: "animalHousing",
     SiteSiteType.CROPLAND.value: "cropland"
 }
 
 
-def lookup_side_effect(*args, **kwargs):
-    # Values taken from real lookups.
-    _ = kwargs
-    if args[0]["@id"] == "ureaKgN" and args[1] == "nitrogenContent":
-        return 45.5
-    if args[0]["@id"] == "compostKgMass" and args[1] == "ANIMAL_MANURE":
-        return False
-    return True
-
-
-@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):
-    # no cycles => do not run
-    mock_related_cycles.return_value = []
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # no products => do not run
-    mock_related_cycles.return_value = [{"products": []}]
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # with irrelevant termType => do not run
-    mock_related_cycles.return_value = [
-        {
-            "products": [
-                {"term": {"termType": TermTermType.BUILDING.value}},
-                {"term": {"termType": TermTermType.EXCRETA.value}}
-            ],
-            "startDate": "2021",
-            "endDate": "2022"
-        }
-    ]
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # products and practices but no relevant terms/termTypes => do not run
-    mock_related_cycles.return_value = [
-        {
-            "practices": [
-                {"term": {"@id": "soilAssociationOrganicStandard"}},
-                {"term": {"@id": "noTillage"}}
-            ],
-            "products": [
-                {"term": {"termType": TermTermType.BUILDING.value}},
-                {"term": {"termType": TermTermType.EXCRETA.value}}
-            ]
-        }
-    ]
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # # practices with relevant termType => run
-    mock_related_cycles.return_value = [
-        {
-            "practices": [
-                {"term": {"termType": TermTermType.WATERREGIME.value}},
-                {"term": {"termType": TermTermType.MACHINERY.value}}
-            ],
-            "startDate": "2021",
-            "endDate": "2022"
-        }
-    ]
-    should_run, *args = _should_run({})
-    assert should_run is True
-
-    # with relevant product, blank site_type => no run
-    mock_related_cycles.return_value = [
-        {
-            "products": [
-                {
-                    "term": {
-                        "termType": TermTermType.CROP.value,
-                        "@id": "genericCropProduct"
-                    },
-                    "value": [51],
-                    "startDate": "2001",
-                    "endDate": "2002"
-                }
-            ],
-            "startDate": "2021",
-            "endDate": "2022"
-        }
-    ]
-    should_run, *args = _should_run({})
-    assert should_run is False
-
-    # with relevant product and site_type => run
-    mock_related_cycles.return_value = [
-        {
-            "products": [
-                {
-                    "term": {
-                        "termType": TermTermType.CROP.value,
-                        "@id": "genericCropProduct"
-                    },
-                    "value": [51],
-                    "startDate": "2001",
-                    "endDate": "2002"
-                }
-            ],
-            "startDate": "2021",
-            "endDate": "2022"
-        }
-    ]
-    should_run, *args = _should_run({"siteType": "cropland"})
-    assert should_run is True
-    assert args[0] == [{
-        'term': TERM_BY_ID['genericCropPlant'],
-        'value': 100,
-        'endDate': '2022',
-        'startDate': '2021'
-    }]
-
-
 @pytest.mark.parametrize(
     "test_name,fixture_path",
     [
@@ -167,23 +35,22 @@ def test_should_run(mock_related_cycles, *args):
         #   - 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]
-        ("Site Type", f"{fixtures_folder}/inputs/site_type")
+        ("Site Type", f"{fixtures_folder}/inputs/site_type"),
+        ("Multiple products but only 1 with landCover id", f"{fixtures_folder}/multiple-products"),
     ]
 )
 @patch(
-    f"{CLASS_PATH}.get_landCover_term_id_from_site_type",
-    side_effect=lambda site_type: LAND_COVER_TERM_BY_SITE_TYPE[site_type]
+    f"{class_path}.get_landCover_term_id_from_site_type",
+    side_effect=lambda site_type: _LAND_COVER_TERM_BY_SITE_TYPE[site_type]
 )
-@patch(f"{CLASS_PATH}.download_hestia", side_effect=lambda term_id, *args: TERM_BY_ID[term_id])
-@patch(f"{CLASS_PATH}.related_cycles")
-@patch(f"{CLASS_PATH}._get_lookup_with_debug", side_effect=lookup_side_effect)
+@patch(f"{class_path}._new_management", side_effect=fake_new_management)
+@patch(f"{class_path}.related_cycles")
 def test_run(
-        mock_get_lookup_with_debug,
-        mock_related_cycles,
-        mock_download,
-        mock_land_cover_lookup,
-        test_name,
-        fixture_path
+        mock_related_cycles: Mock,
+        mock_new_management: Mock,
+        mock_land_cover_lookup: Mock,
+        test_name: str,
+        fixture_path: str
 ):
     with open(f"{fixture_path}/cycles.jsonld", encoding='utf-8') as f:
         cycles = json.load(f)
@@ -200,4 +67,4 @@ def test_run(
         expected = json.load(f)
 
     result = run(site)
-    assert result == expected
+    assert result == expected, test_name

tests/models/utils/test_blank_node.py

@@ -24,7 +24,8 @@ from hestia_earth.models.utils.blank_node import (
     GroupNodesByYearMode,
     split_node_by_dates,
     _most_recent_nodes,
-    _shallowest_node
+    _shallowest_node,
+    validate_start_date_end_date
 )
 
 
@@ -184,6 +185,19 @@ def test_condense_nodes():
                  "value": [7]}
             ],
         ),
+        (
+            "same-blank-nodes-sum",
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-11-30", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [50]},
+                {"startDate": "2001-01-01", "endDate": "2001-11-30", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [50]}
+            ],
+            [
+                {"startDate": "2001-01-01", "endDate": "2001-11-30", "term": {"@id": "bananaPlant", "units": "% area"},
+                 "value": [100]}
+            ]
+        )
     ]
 )
 def test_condense_nodes_(test_name, input_nodes, expected_output_nodes):
@@ -872,6 +886,18 @@ def test_group_nodes_by_year_missing_dates():
     assert result == EXPECTED
 
 
+def test_group_nodes_by_year_incorrect_dates():
+
+    NODES = [
+        {"value": [0], "endDate": "2000-09-14", "startDate": "2000-09-15"},
+    ]
+
+    EXPECTED = {}
+
+    result = group_nodes_by_year(NODES, mode=GroupNodesByYearMode.START_AND_END_DATE)
+    assert result == EXPECTED
+
+
 @mark.parametrize(
     "system_datetime",
     [
@@ -1176,3 +1202,33 @@ def test_shallowest_measurement():
         expected = json.load(f)
 
     assert _shallowest_node(measurements) == expected
+
+
+@mark.parametrize(
+    "node, expected",
+    [
+        (
+            {"startDate": "2000", "endDate": "2001"},
+            True
+        ),
+        (
+            {"startDate": "2001", "endDate": "2000"},
+            False
+        ),
+        (
+            {"startDate": "2000-01-01T00:00:00", "endDate": "2000-01-01T00:00:00"},
+            False
+        ),
+        (
+            {"endDate": "2000"},
+            True
+        ),
+        (
+            {},
+            True
+        ),
+    ],
+    ids=["correct", "reversed", "equal", "no start date", "no start date, no end date"])
+def test_validate_start_date_end_date(node: dict, expected: bool):
+    # Closes #972
+    assert validate_start_date_end_date(node) == expected

tests/models/utils/test_emission.py

@@ -4,7 +4,7 @@ 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, min_emission_method_tier
+from hestia_earth.models.utils.emission import _new_emission, min_emission_method_tier
 
 class_path = 'hestia_earth.models.utils.emission'
 
@@ -27,11 +27,6 @@ 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",
     [

tests/models/utils/test_site.py

@@ -1,7 +1,8 @@
-from unittest.mock import patch
+import pytest
+from unittest.mock import Mock, patch
 from hestia_earth.schema import SiteSiteType
 
-from hestia_earth.models.utils.site import region_level_1_id, related_cycles, valid_site_type
+from hestia_earth.models.utils.site import region_level_1_id, related_cycles, valid_site_type, get_land_cover_term_id
 
 class_path = 'hestia_earth.models.utils.site'
 CYCLE = {'@id': 'id'}
@@ -30,3 +31,33 @@ def test_valid_site_type():
 
     site = {'siteType': SiteSiteType.CROPLAND.value}
     assert not valid_site_type(site, [SiteSiteType.OTHER_NATURAL_VEGETATION.value])
+
+
+_LAND_COVER_TERMS = [
+    {'@type': 'Term', 'name': 'Glass or high accessible cover', '@id': 'glassOrHighAccessibleCover'},
+    {'@type': 'Term', 'name': 'Sea or ocean', '@id': 'seaOrOcean'},
+    {'@type': 'Term', 'name': 'River or stream', '@id': 'riverOrStream'},
+    {'@type': 'Term', 'name': 'Other natural vegetation', '@id': 'otherNaturalVegetation'},
+    {'@type': 'Term', 'name': 'Food retailer', '@id': 'foodRetailer'},
+    {'@type': 'Term', 'name': 'Agri-food processor', '@id': 'agriFoodProcessor'},
+    {'@type': 'Term', 'name': 'Permanent pasture', '@id': 'permanentPasture'},
+    {'@type': 'Term', 'name': 'Animal housing', '@id': 'animalHousing'},
+    {'@type': 'Term', 'name': 'Forest', '@id': 'forest'},
+    {'@type': 'Term', 'name': 'Lake', '@id': 'lake'},
+    {'@type': 'Term', 'name': 'Pond', '@id': 'pond'},
+    {'@type': 'Term', 'name': 'Cropland', '@id': 'cropland'},
+]
+
+
+@pytest.mark.parametrize(
+    'site_type,expected_landCover_id',
+    [
+        (SiteSiteType.CROPLAND.value, 'cropland'),
+        (SiteSiteType.SEA_OR_OCEAN.value, 'seaOrOcean'),
+        (SiteSiteType.AGRI_FOOD_PROCESSOR.value, 'agriFoodProcessor'),
+        (SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value, 'glassOrHighAccessibleCover'),
+    ]
+)
+@patch(f"{class_path}.get_land_cover_siteTypes", return_value=_LAND_COVER_TERMS)
+def test_get_land_cover_term_id(mock_terms: Mock, site_type: str, expected_landCover_id: str):
+    assert get_land_cover_term_id(site_type) == expected_landCover_id, site_type

tests/models/pooreNemecek2018/test_no3ToGroundwaterSoilFlux.py

@@ -1,90 +0,0 @@
-from unittest.mock import patch
-import json
-from tests.utils import fixtures_path, fake_new_emission, FLOODED_RICE_TERMS
-
-from hestia_earth.models.pooreNemecek2018.no3ToGroundwaterSoilFlux import MODEL, TERM_ID, run, _should_run
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-@patch(f"{class_path}.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
-@patch(f"{class_path}.find_primary_product", return_value={'term': {'@id': 'product'}})
-@patch(f"{class_path}.get_crop_residue_decomposition_N_total", return_value=10)
-@patch(f"{class_path}.most_relevant_measurement_value", return_value=0)
-@patch(f"{class_path}.get_max_rooting_depth", return_value=None)
-def test_should_run(mock_rooting_depth, mock_measurement, *args):
-    # no measurements => no run
-    cycle = {}
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with measurements => no run
-    mock_measurement.return_value = 10
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # no rootingDepth => no run
-    should_run, *args = _should_run({})
-    assert not should_run
-
-    # with rootingDepth => run
-    mock_rooting_depth.return_value = 10
-    should_run, *args = _should_run({})
-    assert should_run is True
-
-
-@patch(f"{class_path}.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
-@patch(f"{class_path}.get_max_rooting_depth", return_value=0.9)
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-def test_run(*args):
-    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected
-
-
-@patch(f"{class_path}.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
-@patch(f"{class_path}.get_max_rooting_depth", return_value=0.9)
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-def test_run_with_high_conditions(*args):
-    with open(f"{fixtures_folder}/with-high-conditions/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/with-high-conditions/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected
-
-
-@patch(f"{class_path}.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
-@patch(f"{class_path}.get_max_rooting_depth", return_value=0.9)
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-def test_run_with_low_conditions(*args):
-    with open(f"{fixtures_folder}/with-low-conditions/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/with-low-conditions/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected
-
-
-@patch(f"{class_path}.get_rice_paddy_terms", return_value=FLOODED_RICE_TERMS)
-@patch(f"{class_path}.get_max_rooting_depth", return_value=0.9)
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-def test_run_with_flooded_rice(*args):
-    with open(f"{fixtures_folder}/with-flooded-rice/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/with-flooded-rice/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected

tests/models/stehfestBouwman2006/test_n2OToAirSoilFlux.py

@@ -1,41 +0,0 @@
-from unittest.mock import patch
-import json
-from tests.utils import fixtures_path, fake_new_emission
-
-from hestia_earth.models.stehfestBouwman2006.n2OToAirSoilFlux import MODEL, TERM_ID, run, _should_run, _get_value
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-@patch(f"{class_path}.find_primary_product", return_value={'@id': 'product'})
-@patch(f"{class_path}._get_crop_crouping", return_value='Cereals')
-@patch(f"{class_path}.get_crop_residue_decomposition_N_total", return_value=10)
-@patch(f"{class_path}.most_relevant_measurement_value", return_value=0)
-def test_should_run(mock_measurement, *args):
-    # no measurements => no run
-    cycle = {}
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with measurements => run
-    mock_measurement.return_value = 10
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
-
-
-def test_handle_overflow_error():
-    value = _get_value({}, [10, 10, 10, 10, 1, 'Other'], 10000000)
-    assert round(value) == 1131197
-
-
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-def test_run(*args):
-    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected

tests/models/stehfestBouwman2006/test_noxToAirSoilFlux.py

@@ -1,40 +0,0 @@
-from unittest.mock import patch
-import json
-from tests.utils import fixtures_path, fake_new_emission
-
-from hestia_earth.models.stehfestBouwman2006.noxToAirSoilFlux import MODEL, TERM_ID, run, _should_run, _get_value
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-@patch(f"{class_path}.get_crop_residue_decomposition_N_total", return_value=10)
-@patch(f"{class_path}.most_relevant_measurement_value", return_value=0)
-def test_should_run(mock_measurement, *args):
-    # no measurements => no run
-    cycle = {'inputs': [], 'measurements': []}
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with measurements => run
-    mock_measurement.return_value = 10
-    cycle['measurements'] = [{}]
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
-
-
-def test_handle_overflow_error():
-    value = _get_value({}, 1, 100, 10000000)
-    assert round(value) == 535554
-
-
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-def test_run(*args):
-    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected

tests/models/stehfestBouwman2006GisImplementation/test_noxToAirSoilFlux.py

@@ -1,33 +0,0 @@
-from unittest.mock import patch
-import json
-from tests.utils import fixtures_path, fake_new_emission
-
-from hestia_earth.models.stehfestBouwman2006GisImplementation.noxToAirSoilFlux import MODEL, TERM_ID, run, _should_run
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-@patch(f"{class_path}.get_crop_residue_decomposition_N_total", return_value=10)
-def test_should_run(*args):
-    # no country => no run
-    cycle = {'inputs': [], 'site': {}}
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with country => run
-    cycle['site'] = {'country': {'@id': 'country'}}
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
-
-
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-def test_run(*args):
-    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    value = run(cycle)
-    assert value == expected