hestia-earth-models 0.73.0__tar.gz → 0.73.2__tar.gz

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.73.0
+Version: 0.73.2
 Summary: HESTIA's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: HESTIA Team

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/akagiEtAl2011/utils.py

@@ -1,8 +1,9 @@
 from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils import multiply_values
 from hestia_earth.models.utils.emission import _new_emission
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.cropResidue import get_crop_residue_burnt_value
 from . import MODEL
 
@@ -25,7 +26,8 @@ def _run(term_id: str, product_value: list):
     term = {'termType': TermTermType.EMISSION.value, '@id': term_id}
     factor = get_lookup_value(term, LOOKUP_NAME)
     factor_sd = get_lookup_value(term, LOOKUP_NAME + '-sd')
-    return [_emission(term_id, value * factor, value * factor_sd)]
+    emission_value = multiply_values([value, factor])
+    return [] if emission_value is None else [_emission(term_id, emission_value, multiply_values([value, factor_sd]))]
 
 
 def _should_run(term_id: str, cycle: dict):

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -1,4 +1,5 @@
 from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.lookup import download_lookup, _get_single_table_value, column_name
 from hestia_earth.utils.tools import safe_parse_float
 
@@ -6,7 +7,7 @@ from hestia_earth.models.log import logRequirements, debugMissingLookup, logShou
 from hestia_earth.models.utils import sum_values, multiply_values
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.impact_assessment import (
-    convert_value_from_cycle, emission_value, get_product, get_site, get_region_id
+    convert_value_from_cycle, get_product, get_site, get_region_id
 )
 from hestia_earth.models.utils.input import sum_input_impacts
 from hestia_earth.models.utils.lookup import get_region_lookup_value
@@ -64,8 +65,8 @@ def _get_factor_from_basinId(site: dict, aware_id: str):
     return safe_parse_float(value, default=None)
 
 
-def _get_factor_from_region(impact_assessment: dict, site: dict):
-    region_id = get_region_id(impact_assessment)
+def _get_factor_from_region(impact_assessment: dict, fresh_water: dict, site: dict):
+    region_id = get_region_id(impact_assessment, fresh_water)
     site_type = site.get('siteType')
     lookup_name = 'region-aware-factors.csv'
     lookup_suffix = 'unspecified' if not site_type else ('irri' if site_type in IRRIGATED_SITE_TYPES else 'non_irri')
@@ -77,23 +78,23 @@ def _get_factor_from_region(impact_assessment: dict, site: dict):
 def run(impact_assessment: dict):
     cycle = impact_assessment.get('cycle', {})
     product = get_product(impact_assessment)
-    fresh_water = emission_value(impact_assessment, 'freshwaterWithdrawalsDuringCycle')
+    fresh_water = find_term_match(impact_assessment.get('emissionsResourceUse', []), 'freshwaterWithdrawalsDuringCycle')
     site = get_site(impact_assessment)
     aware_id = site.get(AWARE_KEY)
     factor = (
         _get_factor_from_basinId(site, aware_id) if aware_id else None
-    ) or _get_factor_from_region(impact_assessment, site)
+    ) or _get_factor_from_region(impact_assessment, fresh_water, site)
     inputs_value = convert_value_from_cycle(
         impact_assessment, product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
     )
 
     value = sum_values([
-        multiply_values([fresh_water, factor]),
+        multiply_values([fresh_water.get('value'), factor]),
         inputs_value
     ])
 
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
-                    fresh_water=fresh_water,
+                    fresh_water=fresh_water.get('value'),
                     aware_id=aware_id,
                     factor=factor,
                     inputs_value=inputs_value)

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/cache_sites.py

@@ -132,10 +132,14 @@ def _run(sites: list, years: list = [], years_only: bool = False):
     rasters = list_rasters(years=years, years_only=years_only)
     vectors = [] if years_only else list_vectors(sites)
     filtered_data, sites_no_run = _group_sites(sites, not years_only)
-    return flatten([
-        _run_values(filtered_data.get(param_type), param_type, rasters, vectors, years)
-        for param_type in [e for e in ParamType] if len(filtered_data.get(param_type)) > 0
-    ] + _run_values(sites_no_run, years=years))
+    return flatten(
+        [
+            _run_values(filtered_data.get(param_type), param_type, rasters, vectors, years)
+            for param_type in [e for e in ParamType] if len(filtered_data.get(param_type)) > 0
+        ] + (
+            _run_values(sites_no_run, years=years) if sites_no_run else []
+        )
+    )
 
 
 def _run_by_years(sites: list, years: list, batch_size: int):

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandTransformation.py

@@ -1,8 +1,10 @@
+from hestia_earth.utils.model import find_term_match
+
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils import sum_values, multiply_values
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.impact_assessment import (
-    convert_value_from_cycle, emission_value, get_product, get_site
+    convert_value_from_cycle, get_product, get_site
 )
 from hestia_earth.models.utils.input import sum_input_impacts
 from .utils import get_region_factor
@@ -56,26 +58,27 @@ def _indicator(value: float):
     return indicator
 
 
-def _value(impact_assessment: dict, term_id: str):
-    value = emission_value(impact_assessment, term_id)
-    debugValues(impact_assessment, model=MODEL, term=TERM_ID, node=term_id, value=value, coefficient=1)
-    return value
-
-
 def _run(impact_assessment: dict):
     cycle = impact_assessment.get('cycle', {})
     product = get_product(impact_assessment)
-    landTransformation = _value(impact_assessment, _TRANSFORMATION_TERM_ID)
-    region_factor = get_region_factor(TERM_ID, impact_assessment, _LOOKUP_SUFFIX, 'medium_intensity')
+    landTransformation = find_term_match(impact_assessment.get('emissionsResourceUse', []), _TRANSFORMATION_TERM_ID)
+    debugValues(impact_assessment, model=MODEL, term=TERM_ID,
+                node=_TRANSFORMATION_TERM_ID,
+                value=landTransformation.get('value'),
+                coefficient=1)
+
+    region_factor = get_region_factor(
+        TERM_ID, impact_assessment, _LOOKUP_SUFFIX, 'medium_intensity', blank_node=landTransformation
+    )
     inputs_value = convert_value_from_cycle(
         impact_assessment, product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
     )
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
-                    landTransformation=landTransformation,
+                    landTransformation=landTransformation.get('value'),
                     region_factor=region_factor,
                     inputs_value=inputs_value)
     value = sum_values([
-        multiply_values([landTransformation, region_factor]),
+        multiply_values([landTransformation.get('value'), region_factor]),
         inputs_value
     ])
     return _indicator(value) if value is not None else None

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/chaudharyBrooks2018/utils.py

@@ -13,10 +13,12 @@ def _lookup_value(term_id: str, lookup_name: str, col_match: str, col_val: str,
     return value
 
 
-def get_region_factor(term_id: str, impact_assessment: dict, lookup_suffix: str, group_key: str = None):
+def get_region_factor(
+    term_id: str, impact_assessment: dict, lookup_suffix: str, group_key: str = None, blank_node: dict = None
+):
     site = get_site(impact_assessment)
     ecoregion = site.get('ecoregion')
-    country_id = get_country_id(impact_assessment)
+    country_id = get_country_id(impact_assessment, blank_node=blank_node)
     site_type = site.get('siteType')
 
     lookup_prefix = 'ecoregion' if ecoregion else 'region' if country_id else None

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/config/Cycle.json

@@ -27,17 +27,9 @@
       "stage": 1
     },
     {
-      "key": "practices",
-      "model": "hestia",
-      "value": "croppingIntensity",
-      "runStrategy": "add_blank_node_if_missing",
-      "mergeStrategy": "list",
-      "stage": 1
-    },
-    {
-      "key": "practices",
-      "model": "geospatialDatabase",
-      "value": "croppingIntensity",
+      "key": "inputs",
+      "model": "faostat2018",
+      "value": "seed",
       "runStrategy": "add_blank_node_if_missing",
       "mergeStrategy": "list",
       "stage": 1
@@ -100,6 +92,22 @@
         "stage": 1
       }
     ],
+    {
+      "key": "practices",
+      "model": "hestia",
+      "value": "croppingIntensity",
+      "runStrategy": "add_blank_node_if_missing",
+      "mergeStrategy": "list",
+      "stage": 1
+    },
+    {
+      "key": "practices",
+      "model": "geospatialDatabase",
+      "value": "croppingIntensity",
+      "runStrategy": "add_blank_node_if_missing",
+      "mergeStrategy": "list",
+      "stage": 1
+    },
     [
       {
         "key": "practices",
@@ -321,14 +329,6 @@
       "stage": 1
     },
     [
-      {
-        "key": "practices",
-        "model": "hestia",
-        "value": "longFallowRatio",
-        "runStrategy": "add_blank_node_if_missing",
-        "mergeStrategy": "list",
-        "stage": 1
-      },
       {
         "key": "practices",
         "model": "hestia",
@@ -467,24 +467,22 @@
         "stage": 1
       }
     ],
-    [
-      {
-        "key": "inputs",
-        "model": "faostat2018",
-        "value": "seed",
-        "runStrategy": "add_blank_node_if_missing",
-        "mergeStrategy": "list",
-        "stage": 1
-      },
-      {
-        "key": "inputs",
-        "model": "pooreNemecek2018",
-        "value": "saplingsDepreciatedAmountPerCycle",
-        "runStrategy": "add_blank_node_if_missing",
-        "mergeStrategy": "list",
-        "stage": 1
-      }
-    ],
+    {
+      "key": "practices",
+      "model": "hestia",
+      "value": "longFallowRatio",
+      "runStrategy": "add_blank_node_if_missing",
+      "mergeStrategy": "list",
+      "stage": 1
+    },
+    {
+      "key": "inputs",
+      "model": "pooreNemecek2018",
+      "value": "saplingsDepreciatedAmountPerCycle",
+      "runStrategy": "add_blank_node_if_missing",
+      "mergeStrategy": "list",
+      "stage": 1
+    },
     {
       "key": "completeness",
       "model": "cycle",

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/config/Site.json

@@ -65,30 +65,6 @@
         "mergeStrategy": "list",
         "stage": 1
       },
-      {
-        "key": "measurements",
-        "model": "hestia",
-        "value": "brackishWater",
-        "runStrategy": "add_blank_node_if_missing",
-        "mergeStrategy": "list",
-        "stage": 1
-      },
-      {
-        "key": "measurements",
-        "model": "hestia",
-        "value": "freshWater",
-        "runStrategy": "add_blank_node_if_missing",
-        "mergeStrategy": "list",
-        "stage": 1
-      },
-      {
-        "key": "measurements",
-        "model": "hestia",
-        "value": "salineWater",
-        "runStrategy": "add_blank_node_if_missing",
-        "mergeStrategy": "list",
-        "stage": 1
-      },
       {
         "key": "measurements",
         "model": "hestia",
@@ -470,6 +446,32 @@
         "stage": 2
       }
     ],
+    [
+      {
+        "key": "measurements",
+        "model": "hestia",
+        "value": "brackishWater",
+        "runStrategy": "add_blank_node_if_missing",
+        "mergeStrategy": "list",
+        "stage": 1
+      },
+      {
+        "key": "measurements",
+        "model": "hestia",
+        "value": "freshWater",
+        "runStrategy": "add_blank_node_if_missing",
+        "mergeStrategy": "list",
+        "stage": 1
+      },
+      {
+        "key": "measurements",
+        "model": "hestia",
+        "value": "salineWater",
+        "runStrategy": "add_blank_node_if_missing",
+        "mergeStrategy": "list",
+        "stage": 1
+      }
+    ],
     [
       {
         "key": "defaultMethodClassification",

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/cycle/completeness/electricityFuel.py

@@ -2,7 +2,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 
 from hestia_earth.models.log import logRequirements, log_as_table
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from . import MODEL
 

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/cycle/completeness/freshForage.py

@@ -4,7 +4,7 @@ from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements
 from hestia_earth.models.utils import is_from_model
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/cycle/input/hestiaAggregatedData.py

@@ -4,8 +4,7 @@ from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils.crop import valid_site_type
-from hestia_earth.models.utils.blank_node import get_lookup_value
-from hestia_earth.models.utils.term import get_generic_crop, download_term
+from hestia_earth.models.utils.term import get_lookup_value, get_generic_crop, download_term
 from hestia_earth.models.utils.aggregated import (
     should_link_input_to_impact, link_inputs_to_impact, find_closest_impact, aggregated_end_date
 )

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/cycle/product/economicValueShare.py

@@ -2,7 +2,7 @@ from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.cycle import unique_currencies
 from .utils import lookup_share
 from .. import MODEL

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/environmentalFootprintV3_1/environmentalFootprintSingleOverallScore.py

@@ -4,7 +4,7 @@ from hestia_earth.utils.tools import list_sum
 from typing import List, Optional, Tuple
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table, debugValues
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.lookup import _node_value
 from . import MODEL

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/environmentalFootprintV3_1/soilQualityIndexLandOccupation.py

@@ -60,17 +60,17 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     ]
 
     found_land_occupation_indicators = [{
-        'area-by-year': _node_value(land_occupation_indicator),
-        'area-unit': land_occupation_indicator.get('term', {}).get("units"),
-        'land-cover-id': land_occupation_indicator.get('landCover', {}).get("@id"),
-        'country-id': get_country_id(impact_assessment),
-        'area-by-year-is-valid': _node_value(land_occupation_indicator) is not None and _node_value(
-            land_occupation_indicator) > 0,
-        'area-unit-is-valid': land_occupation_indicator.get('term', {}).get("units") == "m2*year",
-        'used-country': fallback_country(get_country_id(impact_assessment), [LOOKUP]),
-        'pef-grouping': get_pef_grouping(land_occupation_indicator.get('landCover', {}).get("@id"))
-
-    } for land_occupation_indicator in land_occupation_indicators]
+        'area-by-year': _node_value(indicator),
+        'area-unit': indicator.get('term', {}).get("units"),
+        'land-cover-id': indicator.get('landCover', {}).get("@id"),
+        'country-id': get_country_id(impact_assessment, blank_node=indicator),
+        'area-by-year-is-valid': _node_value(indicator) is not None and _node_value(
+            indicator) > 0,
+        'area-unit-is-valid': indicator.get('term', {}).get("units") == "m2*year",
+        'used-country': fallback_country(get_country_id(impact_assessment, blank_node=indicator), [LOOKUP]),
+        'pef-grouping': get_pef_grouping(indicator.get('landCover', {}).get("@id"))
+
+    } for indicator in land_occupation_indicators]
 
     found_indicators_with_coefficient = [
         indicator | {

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/environmentalFootprintV3_1/soilQualityIndexLandTransformation.py

@@ -92,21 +92,24 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
 
     found_transformations = [
         {
-            'value': _node_value(transformation_indicator),
-            'land-cover-id-from': transformation_indicator.get('previousLandCover', {}).get("@id"),
-            'land-cover-id-to': transformation_indicator.get('landCover', {}).get("@id"),
-            'indicator-id': transformation_indicator.get('term', {}).get('@id', ''),
+            'value': _node_value(indicator),
+            'land-cover-id-from': indicator.get('previousLandCover', {}).get("@id"),
+            'land-cover-id-to': indicator.get('landCover', {}).get("@id"),
+            'indicator-id': indicator.get('term', {}).get('@id', ''),
             'good-land-cover-term': all([
-                bool(transformation_indicator.get('landCover')),
-                bool(transformation_indicator.get('previousLandCover'))
+                bool(indicator.get('landCover')),
+                bool(indicator.get('previousLandCover'))
             ]),
-            'country-id': get_country_id(impact_assessment),
+            'country-id': get_country_id(impact_assessment, blank_node=indicator),
             'value-is-valid': (
-                _node_value(transformation_indicator) is not None and
-                _node_value(transformation_indicator) >= 0
+                _node_value(indicator) is not None and
+                _node_value(indicator) >= 0
             ),
-            'lookup-country': fallback_country(get_country_id(impact_assessment), [from_lookup_file, to_lookup_file]),
-        } for transformation_indicator in resource_uses
+            'lookup-country': fallback_country(
+                get_country_id(impact_assessment, blank_node=indicator),
+                [from_lookup_file, to_lookup_file]
+            ),
+        } for indicator in resource_uses
     ]
 
     found_transformations_with_coefficient = [

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/faostat2018/utils.py

@@ -1,9 +1,9 @@
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data_closest_date
-from hestia_earth.utils.tools import safe_parse_float, flatten
+from hestia_earth.utils.tools import safe_parse_float, flatten, non_empty_list
 
-from hestia_earth.models.log import logger, debugMissingLookup, logRequirements, logShouldRun, debugValues
+from hestia_earth.models.log import logger, debugMissingLookup, logRequirements, logShouldRun, debugValues, log_as_table
 from hestia_earth.models.utils.animalProduct import (
     FAO_LOOKUP_COLUMN, FAO_EQUIVALENT_LOOKUP_COLUMN, get_animalProduct_lookup_value
 )
@@ -152,24 +152,37 @@ def should_run_landTransformationFromCropland(term_id: str, impact: dict):
     return should_run, indicators
 
 
+def _map_indicator_value(impact: dict, start_year: int, end_year: int):
+    def mapper(indicator: dict):
+        country_id = get_country_id(impact, blank_node=indicator)
+        total, permanent, temporary = get_cropland_ratio(country_id, start_year, end_year)
+        return {
+            'landCover-id': indicator.get('landCover', {}).get('@id'),
+            'value': indicator.get('value'),
+            'country-id': country_id,
+            'diff-total-area': total,
+            'diff-temporary-area': temporary,
+            'diff-permanent-area': permanent
+        } if total is not None else None
+    return mapper
+
+
 def run_landTransformationFromCropland(term_id: str, impact: dict, indicators: list, years: int):
-    country_id = get_country_id(impact)
     end_year = impact_end_year(impact)
-    total, permanent, temporary = get_cropland_ratio(country_id, end_year - years, end_year)
+
+    values = non_empty_list(map(_map_indicator_value(impact, end_year - years, end_year), indicators))
 
     debugValues(impact, model=MODEL, term_id=term_id,
-                diff_temporary_area=temporary,
-                diff_permanent_area=permanent,
-                diff_total_area=total)
+                indicators_used=log_as_table(values))
 
     return flatten([
         [
-            _new_indicator(term_id, MODEL, indicator.get('landCover', {}).get('@id'), 'annualCropland') | {
-                'value': indicator.get('value') * temporary / total
+            _new_indicator(term_id, MODEL, value.get('landCover-id'), 'annualCropland') | {
+                'value': value.get('value') * value.get('diff-temporary-area') / value.get('diff-total-area')
             },
-            _new_indicator(term_id, MODEL, indicator.get('landCover', {}).get('@id'), 'permanentCropland') | {
-                'value': indicator.get('value') * permanent / total
+            _new_indicator(term_id, MODEL, value.get('landCover-id'), 'permanentCropland') | {
+                'value': value.get('value') * value.get('diff-permanent-area') / value.get('diff-total-area')
             }
         ]
-        for indicator in indicators
-    ]) if total is not None else []
+        for value in values
+    ])

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/geospatialDatabase/utils.py

@@ -1,4 +1,6 @@
 import os
+from area import area
+from functools import reduce
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.tools import non_empty_list
 
@@ -85,12 +87,11 @@ def geospatial_data(site: dict, only_coordinates=False):
 
 def _get_boundary_area_size(boundary: dict):
     try:
-        from hestia_earth.earth_engine.boundary import get_size_km2
-    except ImportError:
-        raise ImportError("Run `pip install hestia_earth.earth_engine` to use this functionality")
-
-    try:
-        return get_size_km2(boundary)
+        return (
+            (area(boundary.get('geometry')) / 1_000_000) if 'geometry' in boundary else
+            reduce(lambda p, c: p + _get_boundary_area_size(c), boundary.get('features'), 0) if 'features' in boundary
+            else area(boundary) / 1_000_000
+        )
     except Exception:
         return None
 
@@ -101,10 +102,12 @@ def _get_region_area_size(site: dict):
 
 
 def get_area_size(site: dict):
-    return None if has_coordinates(site) else (
-        # fallback if `boundary` provided but no `boundaryArea` was computed
-        site.get('boundaryArea') or _get_boundary_area_size(site.get('boundary'))
-    ) if has_boundary(site) else _get_region_area_size(site)
+    return _cached_value(site, CACHE_AREA_SIZE) or (
+        None if has_coordinates(site) else (
+            # fallback if `boundary` provided but no `boundaryArea` was computed
+            site.get('boundaryArea') or _get_boundary_area_size(site.get('boundary'))
+        ) if has_boundary(site) else _get_region_area_size(site)
+    )
 
 
 def _is_below_max_size(term: str, site: dict) -> bool:

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/hestia/aboveGroundCropResidue.py

@@ -28,6 +28,7 @@ RETURNS = {
         "value": ""
     }]
 }
+MODEL_KEY = 'aboveGroundCropResidue'
 TERM_ID = 'aboveGroundCropResidueLeftOnField,aboveGroundCropResidueBurnt,aboveGroundCropResidueIncorporated,aboveGroundCropResidueRemoved'  # noqa: E501
 TOTAL_TERM_ID = 'aboveGroundCropResidueTotal'
 REMAINING_MODEL = PRODUCT_ID_TO_PRACTICES_ID[-1]['product']
@@ -59,7 +60,7 @@ def _should_run_model(model, cycle: dict, total_value: float):
     practice_value = _get_practice_value(model.get('practices'), cycle)
     has_product = find_term_match(cycle.get('products', []), term_id, None) is not None
 
-    logRequirements(cycle, model=MODEL, term=term_id,
+    logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                     practice_value=practice_value,
                     has_product=has_product)
 
@@ -70,7 +71,7 @@ def _should_run_model(model, cycle: dict, total_value: float):
         ]),
         not has_product
     ])
-    logShouldRun(cycle, MODEL, term_id, should_run)
+    logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
     return should_run, practice_value
 
 
@@ -104,7 +105,7 @@ def _run(cycle: dict, total_values: list):
     for model in models:
         term_id = model.get('product')
         value = _run_model(model, cycle, total_value)
-        debugValues(cycle, model=MODEL, term=term_id,
+        debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                     total_above_ground_crop_residue=total_value,
                     remaining_crop_residue_value=remaining_value,
                     allocated_value=value)
@@ -132,13 +133,13 @@ def _should_run_product(cycle: dict, total_values: list, term_id: str):
         find_term_match(cycle.get('practices', []), term_id).get('value', []) == [0] for term_id in practice_term_ids
     ])
 
-    logRequirements(cycle, model=MODEL, term=term_id,
+    logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                     term_type_cropResidue_incomplete=term_type_incomplete,
                     has_aboveGroundCropResidueTotal=has_aboveGroundCropResidueTotal,
                     practice_term_ids=';'.join(practice_term_ids),
                     practice_value_is_0=is_value_0)
     should_run = all([has_aboveGroundCropResidueTotal or is_value_0, term_type_incomplete])
-    logShouldRun(cycle, MODEL, term_id, should_run)
+    logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
     return should_run
 
 

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/hestia/cropResidueManagement.py

@@ -20,6 +20,7 @@ RETURNS = {
         "term.termType": "cropResidueManagement"
     }]
 }
+MODEL_KEY = 'cropResidueManagement'
 PRACTICE_IDS = [
     residueBurnt.TERM_ID,
     residueIncorporated.TERM_ID,
@@ -50,10 +51,10 @@ def _should_run(cycle: dict):
     should_run = all([99.5 <= sum_practices <= 100.5])
 
     for term_id in missing_practices:
-        logRequirements(cycle, model=MODEL, term=term_id,
+        logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                         sum_crop_residue_management=sum_practices)
 
-        logShouldRun(cycle, MODEL, term_id, should_run)
+        logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
 
     return should_run, missing_practices
 

{hestia_earth_models-0.73.0 → hestia_earth_models-0.73.2}/hestia_earth/models/hestia/default_emissions.py

@@ -6,7 +6,7 @@ from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils import _omit
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
-from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.input import unique_background_inputs
 from . import MODEL