hestia-earth-models 0.73.0__py3-none-any.whl → 0.73.2__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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
 

hestia_earth/models/hestia/default_resourceUse.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.indicator import _new_indicator
 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