hestia-earth-models 0.64.2__py3-none-any.whl → 0.64.3__py3-none-any.whl

tests/models/ipcc2019/test_aboveGroundBiomass.py

@@ -0,0 +1,182 @@
+import json
+from numpy.typing import NDArray
+from os.path import isfile
+from pytest import mark
+from unittest.mock import MagicMock, patch
+
+from hestia_earth.models.ipcc2019.aboveGroundBiomass import (
+    _is_lcc_event, _rescale_category_cover, _should_run, MODEL, run, TERM_ID
+)
+from hestia_earth.models.ipcc2019.aboveGroundBiomass_utils import BiomassCategory, sample_constant
+
+from tests.utils import fake_new_measurement, fixtures_path
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+utils_path = f"hestia_earth.models.{MODEL}.{TERM_ID}_utils"
+term_path = "hestia_earth.models.utils.term"
+property_path = "hestia_earth.models.utils.property"
+
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+_ITERATIONS = 1000
+
+
+def _load_fixture(path: str, default=None):
+    if isfile(path):
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+    return default
+
+
+def _fake_calc_descriptive_stats(arr: NDArray, *_args, **_kwargs):
+    return {"value": [round(row[0], 6) for row in arr]}
+
+
+# subfolder, should_run
+PARAMS_SHOULD_RUN = [
+    ("forest-to-cropland", True),
+    ("forest-to-cropland-greater-than-100", True),
+    ("forest-to-cropland-less-than-100", True),
+    ("forest-to-cropland-lcc-q2", True),
+    ("forest-to-cropland-lcc-q3", True),
+    ("forest-to-cropland-lcc-q4", True),
+    ("forest-to-orchard", True),
+    ("forest-to-orchard-with-backup-factors", True),
+    ("forest-to-orchard-with-in-category-lcc", True),
+    ("historical-land-cover-mix", True),
+    ("historical-argentina-pasture", True),
+    ("historical-brazil-maize", True),
+    ("perennial-to-grassland-with-pasture-condition", True)
+]
+IDS_SHOULD_RUN = [p[0] for p in PARAMS_SHOULD_RUN]
+
+
+@mark.parametrize("subfolder, should_run", PARAMS_SHOULD_RUN, ids=IDS_SHOULD_RUN)
+def test_should_run(subfolder: str, should_run: bool):
+    folder = f"{fixtures_folder}/{subfolder}"
+
+    site = _load_fixture(f"{folder}/site.jsonld", {})
+
+    result, *_ = _should_run(site)
+    assert result == should_run
+
+
+def test_should_run_no_data():
+    SITE = {}
+    EXPECTED = False
+
+    result, *_ = _should_run(SITE)
+    assert result == EXPECTED
+
+
+PARAMS_RUN = [subfolder for subfolder, should_run in PARAMS_SHOULD_RUN if should_run]
+
+
+@mark.parametrize("subfolder", PARAMS_RUN)
+@patch(f"{class_path}.calc_descriptive_stats", side_effect=_fake_calc_descriptive_stats)
+@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
+@patch(f"{utils_path}._get_sample_func", return_value=sample_constant)
+def test_run(
+    _get_sample_func_mock: MagicMock,
+    _new_measurement_mock: MagicMock,
+    _calc_descriptive_stats_mock: MagicMock,
+    subfolder: str
+):
+    folder = f"{fixtures_folder}/{subfolder}"
+
+    site = _load_fixture(f"{folder}/site.jsonld", {})
+    expected = _load_fixture(f"{folder}/result.jsonld", [])
+
+    with patch(f"{class_path}._ITERATIONS", _ITERATIONS):
+        result = run(site)
+
+    assert result == expected
+
+
+# subfolder
+PARAMS_RUN_WITH_STATS = [
+    "forest-to-cropland-with-stats",
+    "forest-to-orchard-with-in-category-lcc-with-stats",
+    "historical-land-cover-mix-with-stats"
+]
+
+
+@mark.parametrize("subfolder", PARAMS_RUN_WITH_STATS)
+@patch(f"{class_path}._new_measurement", side_effect=fake_new_measurement)
+def test_run_with_stats(
+    _new_measurement_mock: MagicMock,
+    subfolder: str
+):
+    folder = f"{fixtures_folder}/{subfolder}"
+
+    site = _load_fixture(f"{folder}/site.jsonld", {})
+    expected = _load_fixture(f"{folder}/result.jsonld", [])
+
+    with patch(f"{class_path}._ITERATIONS", _ITERATIONS):
+        result = run(site)
+
+    assert result == expected
+
+
+# input, expected
+PARAMS_RESCALE_CATEGORY_COVER = [
+    (
+        {BiomassCategory.ANNUAL_CROPS: 90},
+        {BiomassCategory.ANNUAL_CROPS: 90, BiomassCategory.OTHER: 10}
+    ),
+    (
+        {BiomassCategory.OTHER: 90},
+        {BiomassCategory.OTHER: 100}
+    ),
+    (
+        {BiomassCategory.ANNUAL_CROPS: 60, BiomassCategory.VINE: 60},
+        {BiomassCategory.ANNUAL_CROPS: 50, BiomassCategory.VINE: 50}
+    ),
+    (
+        {BiomassCategory.NATURAL_FOREST: 100},
+        {BiomassCategory.NATURAL_FOREST: 100}
+    )
+]
+IDS_RESCALE_CATEGORY_COVER = ["fill", "fill w/ other", "squash", "do nothing"]
+
+
+@mark.parametrize("input, expected", PARAMS_RESCALE_CATEGORY_COVER, ids=IDS_RESCALE_CATEGORY_COVER)
+def test_rescale_category_cover(input: dict, expected: dict):
+    assert _rescale_category_cover(input) == expected
+
+
+# a, b, expected
+PARAMS_IS_LCC_EVENT = [
+    (
+        {
+            "appleTree": 33.333,
+            "pearTree": 33.333,
+            BiomassCategory.ANNUAL_CROPS: 33.334,
+        },
+        {
+            "appleTree": 33.33333,
+            "pearTree": 33.33333,
+            BiomassCategory.ANNUAL_CROPS: 33.33334,
+        },
+        True
+    ),
+    (
+        {
+            "appleTree": 33.3333,
+            "pearTree": 33.3333,
+            BiomassCategory.ANNUAL_CROPS: 33.3334,
+        },
+        {
+            "appleTree": 33.33333,
+            "pearTree": 33.33333,
+            BiomassCategory.ANNUAL_CROPS: 33.33334,
+        },
+        False
+    )
+]
+IDS_IS_LCC_EVENT = ["True", "False"]
+
+
+@mark.parametrize("a, b, expected", PARAMS_IS_LCC_EVENT, ids=IDS_IS_LCC_EVENT)
+def test_is_lcc_event(a: dict, b: dict, expected: bool):
+    assert _is_lcc_event(a, b) is expected

tests/models/ipcc2019/test_aboveGroundBiomass_utils.py

@@ -0,0 +1,92 @@
+from pytest import mark
+
+from itertools import product
+from hestia_earth.models.ipcc2019.aboveGroundBiomass_utils import (
+    _build_col_name, _get_sample_func, assign_biomass_category, BiomassCategory, EcoClimateZone,
+    sample_biomass_equilibrium, sample_constant, sample_plus_minus_error
+)
+
+_ITERATIONS = 1000
+
+
+# kwargs, sample_func, expected_shape
+PARAMS_GET_SAMPLE_FUNC = [
+    ({"value": 1}, sample_constant),
+    ({"value": 1, "error": 10}, sample_plus_minus_error),
+]
+IDS_GET_SAMPLE_FUNC = ["constant", "+/- error"]
+
+
+@mark.parametrize("kwargs, sample_func", PARAMS_GET_SAMPLE_FUNC, ids=IDS_GET_SAMPLE_FUNC)
+def test_get_sample_func(kwargs, sample_func):
+    result = _get_sample_func(kwargs)
+    assert result == sample_func
+
+
+PARAMS_BIOMASS = [p for p in product(BiomassCategory, EcoClimateZone)]
+IDS_BIOMASS = [f"{p[0].name} + {p[1].name}" for p in PARAMS_BIOMASS]
+
+
+@mark.parametrize("biomass_category, eco_climate_zone", PARAMS_BIOMASS, ids=IDS_BIOMASS)
+def test_sample_biomass_equilibrium(biomass_category, eco_climate_zone):
+    EXPECTED_SHAPE = (1, _ITERATIONS)
+    result = sample_biomass_equilibrium(_ITERATIONS, biomass_category, eco_climate_zone)
+    assert result.shape == EXPECTED_SHAPE
+
+
+# input, expected
+PARAMS_ASSIGN_BIOMASS_CATEGORY = [
+    ("Annual crops", BiomassCategory.ANNUAL_CROPS),
+    ("Coconut", BiomassCategory.COCONUT),
+    ("Forest", BiomassCategory.FOREST),
+    ("Grassland", BiomassCategory.GRASSLAND),
+    ("Jatropha", BiomassCategory.JATROPHA),
+    ("Jojoba", BiomassCategory.JOJOBA),
+    ("Natural forest", BiomassCategory.NATURAL_FOREST),
+    ("Oil palm", BiomassCategory.OIL_PALM),
+    ("Olive", BiomassCategory.OLIVE),
+    ("Orchard", BiomassCategory.ORCHARD),
+    ("Other", BiomassCategory.OTHER),
+    ("Plantation forest", BiomassCategory.PLANTATION_FOREST),
+    ("Rubber", BiomassCategory.RUBBER),
+    ("Short rotation coppice", BiomassCategory.SHORT_ROTATION_COPPICE),
+    ("Tea", BiomassCategory.TEA),
+    ("Vine", BiomassCategory.VINE),
+    ("Woody perennial", BiomassCategory.WOODY_PERENNIAL),
+    ("Miscellaneous value", None)
+]
+IDS_ASSIGN_BIOMASS_CATEGORY = [p[0] for p in PARAMS_ASSIGN_BIOMASS_CATEGORY]
+
+
+@mark.parametrize("input, expected", PARAMS_ASSIGN_BIOMASS_CATEGORY, ids=IDS_ASSIGN_BIOMASS_CATEGORY)
+def test_assign_biomass_category(input: str, expected: BiomassCategory):
+    assert assign_biomass_category(input) == expected
+
+
+# input, expected
+PARAMS_BUILD_COLUMN_NAME = [
+    (BiomassCategory.ANNUAL_CROPS, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_ANNUAL_CROPS"),
+    (BiomassCategory.COCONUT, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_COCONUT"),
+    (BiomassCategory.FOREST, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_FOREST"),
+    (BiomassCategory.GRASSLAND, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_GRASSLAND"),
+    (BiomassCategory.JATROPHA, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_JATROPHA"),
+    (BiomassCategory.JOJOBA, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_JOJOBA"),
+    (BiomassCategory.NATURAL_FOREST, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_NATURAL_FOREST"),
+    (BiomassCategory.OIL_PALM, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OIL_PALM"),
+    (BiomassCategory.OLIVE, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OLIVE"),
+    (BiomassCategory.ORCHARD, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_ORCHARD"),
+    (BiomassCategory.OTHER, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER"),
+    (BiomassCategory.PLANTATION_FOREST, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_PLANTATION_FOREST"),
+    (BiomassCategory.RUBBER, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_RUBBER"),
+    (BiomassCategory.SHORT_ROTATION_COPPICE, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_SHORT_ROTATION_COPPICE"),
+    (BiomassCategory.TEA, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_TEA"),
+    (BiomassCategory.VINE, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_VINE"),
+    (BiomassCategory.WOODY_PERENNIAL, "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_WOODY_PERENNIAL"),
+    ("Miscellaneous value", "AG_BIOMASS_EQUILIBRIUM_KG_C_HECTARE_OTHER")
+]
+IDS_BUILD_COLUMN_NAME = [p[0] for p in PARAMS_BUILD_COLUMN_NAME]
+
+
+@mark.parametrize("input, expected", PARAMS_BUILD_COLUMN_NAME, ids=IDS_BUILD_COLUMN_NAME)
+def test_build_col_name(input: BiomassCategory, expected: str):
+    assert _build_col_name(input) == expected

tests/models/ipcc2019/test_organicCarbonPerHa_tier_1_utils.py

@@ -5,10 +5,11 @@ from numpy.testing import assert_array_almost_equal
 from pytest import mark
 from unittest.mock import MagicMock, patch
 
+from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone
 from hestia_earth.models.ipcc2019.organicCarbonPerHa import MODEL, TERM_ID
 from hestia_earth.models.ipcc2019.organicCarbonPerHa_utils import (
-    EcoClimateZone, IpccCarbonInputCategory, IpccLandUseCategory, IpccManagementCategory,
-    IpccSoilCategory, sample_constant, sample_plus_minus_error, sample_plus_minus_uncertainty
+    IpccCarbonInputCategory, IpccLandUseCategory, IpccManagementCategory, IpccSoilCategory, sample_constant,
+    sample_plus_minus_error, sample_plus_minus_uncertainty
 )
 from hestia_earth.models.ipcc2019.organicCarbonPerHa_tier_1_utils import (
     _assign_ipcc_carbon_input_category, _assign_ipcc_land_use_category, _assign_ipcc_management_category,

tests/models/ipcc2019/test_pastureGrass.py

@@ -27,11 +27,11 @@ TERMS_BY_ID = {
         ]
     },
     'energyContentHigherHeatingValue': {'units': 'MJ / kg'},
-    'energyDigestibilityRuminants': {'units': '%'},
+    'energyDigestibilityRuminants': {'units': '%'}
 }
 
 
-def fake_download_hestia(term_id: str, *args): return TERMS_BY_ID[term_id]
+def fake_download_hestia(term_id: str, *args): return TERMS_BY_ID.get(term_id, {})
 
 
 @patch(f"{class_path_utils}.download_hestia", side_effect=fake_download_hestia)

tests/models/poschEtAl2008/test_terrestrialEutrophicationPotentialAccumulatedExceedance.py

@@ -0,0 +1,44 @@
+import json
+from unittest.mock import patch
+
+from hestia_earth.models.poschEtAl2008.terrestrialEutrophicationPotentialAccumulatedExceedance import MODEL, TERM_ID, \
+    run
+from tests.utils import fixtures_path, fake_new_indicator
+
+class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(*args):
+    with open(f"{fixtures_folder}/impact-assessment.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}._new_indicator", side_effect=fake_new_indicator)
+def test_lookup_to_bad_country(*args):
+    with open(f"{fixtures_folder}/impact-assessment.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+    cycle['country']['@id'] = "example-land-not-real"
+
+    value = run(cycle)
+    assert value['value'] is None
+
+
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_lookup_no_term_type(*args):
+    """
+    We currently do not filter out bad termTypes so this is expected behavior.
+    """
+    with open(f"{fixtures_folder}/impact-assessment.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+    del cycle['emissionsResourceUse'][0]['term']['termType']
+
+    value = run(cycle)
+    assert value['value'] == 7.47

tests/models/utils/test_ecoClimateZone.py

@@ -0,0 +1,152 @@
+from pytest import mark
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+from hestia_earth.models.utils.ecoClimateZone import (
+    _eco_climate_zone_node_value_to_enum, EcoClimateZone, get_eco_climate_zone_value,
+    get_ecoClimateZone_lookup_grouped_value
+)
+
+class_path = "hestia_earth.models.utils.ecoClimateZone"
+
+# value, expected
+PARAMS_TO_ENUM = [
+    (0, None),
+    (1, EcoClimateZone.WARM_TEMPERATE_MOIST),
+    (2, EcoClimateZone.WARM_TEMPERATE_DRY),
+    (3, EcoClimateZone.COOL_TEMPERATE_MOIST),
+    (4, EcoClimateZone.COOL_TEMPERATE_DRY),
+    (5, EcoClimateZone.POLAR_MOIST),
+    (6, EcoClimateZone.POLAR_DRY),
+    (7, EcoClimateZone.BOREAL_MOIST),
+    (8, EcoClimateZone.BOREAL_DRY),
+    (9, EcoClimateZone.TROPICAL_MONTANE),
+    (10, EcoClimateZone.TROPICAL_WET),
+    (11, EcoClimateZone.TROPICAL_MOIST),
+    (12, EcoClimateZone.TROPICAL_DRY),
+    (13, None),
+    ("string", None),
+    (None, None)
+]
+IDS_TO_ENUM = [str(input_) for input_, _ in PARAMS_TO_ENUM]
+
+
+@mark.parametrize("value, expected", PARAMS_TO_ENUM, ids=IDS_TO_ENUM)
+def test_eco_climate_zone_node_value_to_enum(value, expected):
+    assert _eco_climate_zone_node_value_to_enum(value) == expected
+
+
+# node, as_enum, expected
+PARAMS_GET_ECZ_VALUE = [
+    (
+        {
+            "@type": "Site",
+            "measurements": [
+                {
+                    "@type": "Measurement",
+                    "term": {
+                        "@type": "Term",
+                        "@id": "ecoClimateZone"
+                    },
+                    "value": [2],
+                }
+            ]
+        },
+        False,
+        2
+    ),
+    (
+        {
+            "@type": "Site",
+            "measurements": [
+                {
+                    "@type": "Measurement",
+                    "term": {
+                        "@type": "Term",
+                        "@id": "ecoClimateZone"
+                    },
+                    "value": [2],
+                }
+            ]
+        },
+        True,
+        EcoClimateZone.WARM_TEMPERATE_DRY
+    ),
+    (
+        {
+            "@type": "Cycle",
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {
+                        "@type": "Measurement",
+                        "term": {
+                            "@type": "Term",
+                            "@id": "ecoClimateZone"
+                        },
+                        "value": [2],
+                    }
+                ]
+            }
+        },
+        False,
+        2
+    ),
+    (
+        {
+            "@type": "Cycle",
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {
+                        "@type": "Measurement",
+                        "term": {
+                            "@type": "Term",
+                            "@id": "ecoClimateZone"
+                        },
+                        "value": [2],
+                    }
+                ]
+            }
+        },
+        True,
+        EcoClimateZone.WARM_TEMPERATE_DRY
+    ),
+    ({}, False, None),
+    ({}, True, None),
+]
+IDS_GET_ECZ_VALUE = [
+    "site", "site as enum",
+    "cycle", "cycle as enum",
+    "other", "other as enum"
+]
+
+
+@mark.parametrize("node, as_enum, expected", PARAMS_GET_ECZ_VALUE, ids=IDS_GET_ECZ_VALUE)
+def test_get_eco_climate_zone_value(node, as_enum, expected):
+    assert get_eco_climate_zone_value(node, as_enum=as_enum) == expected
+
+
+# lookup_return_value, expected
+PARAMS_LOOKUP_GROUPED = [
+    ("1", None),
+    ("-", None),
+    ("", None),
+    ("value:1", {"value": 1}),
+    ("value:-1", {"value": -1}),
+    ("value:1;sd:0.5", {"value": 1, "sd": 0.5})
+]
+IDS_LOOKUP_GROUPED = [p[0] for p in PARAMS_LOOKUP_GROUPED]
+
+
+@mark.parametrize("lookup_return_value, expected", PARAMS_LOOKUP_GROUPED, ids=IDS_LOOKUP_GROUPED)
+@patch(f"{class_path}.download_lookup", return_value=None)
+@patch(f"{class_path}._get_single_table_value")
+def test_get_ecoClimateZone_lookup_grouped_value(
+    get_single_table_value_mock: MagicMock,
+    _download_lookup_mock: MagicMock,
+    lookup_return_value: str,
+    expected: Any
+):
+    get_single_table_value_mock.return_value = lookup_return_value
+    assert get_ecoClimateZone_lookup_grouped_value(1, "TEST") == expected