hestia-earth-models 0.72.2__py3-none-any.whl → 0.73.1__py3-none-any.whl

hestia_earth/models/hestia/default_resourceUse.py

@@ -0,0 +1,110 @@
+from hestia_earth.schema import IndicatorMethodTier, TermTermType
+from hestia_earth.utils.tools import flatten, safe_parse_float
+from hestia_earth.utils.lookup import download_lookup, lookup_term_ids
+
+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.term import get_lookup_value
+from hestia_earth.models.utils.input import unique_background_inputs
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "cycle": {
+            "@type": "Cycle",
+            "inputs": [{
+                "@type": "Input",
+                "value": "> 0",
+                "none": {
+                    "impactAssessment": {"@type": "ImpactAssessment"},
+                    "fromCycle": "True",
+                    "producedInCycle": "True"
+                }
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Indicator": [{
+        "value": "",
+        "inputs": "",
+        "methodTier": "background"
+    }]
+}
+LOOKUPS = {
+    "organicFertiliser": "backgroundEmissionsResourceUseDefaultValue"
+}
+MODEL_KEY = 'default_resourceUse'
+TIER = IndicatorMethodTier.BACKGROUND.value
+
+
+def _indicator(term_id: str, value: float, input: dict):
+    indicator = _new_indicator(term_id, MODEL)
+    indicator['value'] = value
+    indicator['inputs'] = [input]
+    indicator['methodTier'] = TIER
+    return indicator
+
+
+def _default_value(input: dict):
+    return safe_parse_float(get_lookup_value(input.get('term', {}), LOOKUPS['organicFertiliser']), default=None)
+
+
+def _run_input(impact: dict):
+    required_resourceUse_term_ids = [
+        id for id in lookup_term_ids(download_lookup(f"{TermTermType.RESOURCEUSE.value}.csv"))
+        if id.endswith('InputsProduction')
+    ]
+
+    def run(input: dict):
+        input_term = input.get('input').get('term')
+        term_id = input_term.get('@id')
+        value = input.get('default-value-from-lookup')
+
+        for emission_id in required_resourceUse_term_ids:
+            logShouldRun(impact, MODEL, term_id, True, methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)
+
+        return [
+            _indicator(term_id, value, input_term) for term_id in required_resourceUse_term_ids
+        ]
+
+    return run
+
+
+def _should_run(impact: dict):
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(
+        node=impact, list_key='emissionsResourceUse', term_type=TermTermType.RESOURCEUSE
+    )
+
+    inputs = [
+        input | {
+            'default-value-from-lookup': _default_value(input['input']),
+            'no-gap-filled-background-emissions': no_gap_filled_background_emissions_func(input['input'])
+        }
+        for input in unique_background_inputs(impact.get('cycle', {}))
+    ]
+    valid_inputs = [
+        input for input in inputs
+        if all([
+            input.get('default-value-from-lookup') is not None,
+            input.get('no-gap-filled-background-emissions')
+        ])
+    ]
+
+    should_run = all([bool(valid_inputs)])
+
+    for input in inputs:
+        term_id = input.get('input').get('term', {}).get('@id')
+
+        logRequirements(impact, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                        **_omit(input, ['input', 'input-value']))
+        logShouldRun(impact, MODEL, term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
+
+    return should_run, valid_inputs
+
+
+def run(impact: dict):
+    should_run, grouped_inputs = _should_run(impact)
+    return flatten(map(_run_input(impact), grouped_inputs)) if should_run else []

hestia_earth/models/hestia/excretaKgMass.py

@@ -3,7 +3,7 @@ from hestia_earth.utils.model import filter_list_term_type, find_term_match
 from hestia_earth.utils.tools import non_empty_list, list_sum
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
-from hestia_earth.models.utils import get_kg_term_id, get_kg_N_term_id, get_kg_VS_term_id
+from hestia_earth.models.utils import get_kg_term_id, get_kg_N_term_id, get_kg_VS_term_id, _filter_list_term_unit
 from hestia_earth.models.utils.term import download_term
 from hestia_earth.models.utils.constant import Units
 from hestia_earth.models.utils.product import _new_product, convert_product_to_unit
@@ -31,12 +31,12 @@ RETURNS = {
 MODEL_KEY = 'excretaKgMass'
 
 UNITS = [
-    Units.KG_N.value,
-    Units.KG_VS.value
+    Units.KG_N,
+    Units.KG_VS
 ]
 
 
-def _product(value: float, term_id: str):
+def _product(term_id: str, value: float = None):
     product = _new_product(term_id, value, MODEL)
     return product
 
@@ -80,17 +80,15 @@ def _run_product(cycle: dict, product_term_id: str):
     # use existing product if exist, else create new one
     existing_product = find_term_match(cycle.get('products', []), product_term_id)
 
-    return (existing_product | _product(value, product_term_id)) if value else None
+    return (existing_product | _product(product_term_id, value)) if value else _product(product_term_id)
 
 
 def _should_run(cycle: dict):
     node_type = cycle.get('type', cycle.get('@type'))
     excreta_products = filter_list_term_type(cycle.get('products', []), TermTermType.EXCRETA)
     kg_term_ids = list(set([
-        get_kg_term_id(p.get('term', {}).get('@id')) for p in excreta_products if all([
-            p.get('term', {}).get('units') in UNITS,
-            p.get('value', [])
-        ])
+        get_kg_term_id(p.get('term', {}).get('@id'))
+        for p in _filter_list_term_unit(excreta_products, UNITS)
     ]))
     gap_fill_term_ids = [
         term_id for term_id in kg_term_ids if not find_term_match(excreta_products, term_id).get('value', [])

hestia_earth/models/hestia/freshWater.py

@@ -34,7 +34,7 @@ def _should_run(site: dict):
     logRequirements(site, model=MODEL, term=TERM_ID,
                     waterSalinity=waterSalinity)
 
-    should_run = all([0 < waterSalinity < 500])
+    should_run = all([0 < (waterSalinity or 0) < 500])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

hestia_earth/models/hestia/inorganicFertiliser.py

@@ -88,15 +88,15 @@ def _include_term_ids(term_id: str):
 def _run_input(cycle: dict, input: dict):
     term_id = input.get('term', {}).get('@id')
     input_term_ids = _include_term_ids(term_id)
-    nitrogenContent = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent'), 0)
-    nitrogenContent_min = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent-min'), None)
-    nitrogenContent_max = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent-max'), None)
-    phosphateContentAsP2O5 = safe_parse_float(get_term_lookup(term_id, 'phosphateContentAsP2O5'), 0)
-    phosphateContentAsP2O5_min = safe_parse_float(get_term_lookup(term_id, 'phosphateContentAsP2O5-min'), None)
-    phosphateContentAsP2O5_max = safe_parse_float(get_term_lookup(term_id, 'phosphateContentAsP2O5-max'), None)
-    potassiumContentAsK2O = safe_parse_float(get_term_lookup(term_id, 'potassiumContentAsK2O'), 0)
-    potassiumContentAsK2O_min = safe_parse_float(get_term_lookup(term_id, 'potassiumContentAsK2O-min'), None)
-    potassiumContentAsK2O_max = safe_parse_float(get_term_lookup(term_id, 'potassiumContentAsK2O-max'), None)
+    nitrogenContent = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent'), default=0)
+    nitrogenContent_min = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent-min'), default=None)
+    nitrogenContent_max = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent-max'), default=None)
+    phosphateContentAsP2O5 = safe_parse_float(get_term_lookup(term_id, 'phosphateContentAsP2O5'), default=0)
+    phosphateContentAsP2O5_min = safe_parse_float(get_term_lookup(term_id, 'phosphateContentAsP2O5-min'), default=None)
+    phosphateContentAsP2O5_max = safe_parse_float(get_term_lookup(term_id, 'phosphateContentAsP2O5-max'), default=None)
+    potassiumContentAsK2O = safe_parse_float(get_term_lookup(term_id, 'potassiumContentAsK2O'), default=0)
+    potassiumContentAsK2O_min = safe_parse_float(get_term_lookup(term_id, 'potassiumContentAsK2O-min'), default=None)
+    potassiumContentAsK2O_max = safe_parse_float(get_term_lookup(term_id, 'potassiumContentAsK2O-max'), default=None)
 
     from_units = input.get('term', {}).get('units')
     input_value = list_sum(input.get('value'))
@@ -166,9 +166,9 @@ def _run_input(cycle: dict, input: dict):
 def _should_run_input(cycle: dict, input: dict):
     term_id = input.get('term', {}).get('@id')
     has_value = list_sum(input.get('value', [])) > 0
-    nitrogenContent = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent'), None)
-    phosphateContentAsP2O5 = safe_parse_float(get_term_lookup(term_id, 'phosphateContentAsP2O5'), None)
-    potassiumContentAsK2O = safe_parse_float(get_term_lookup(term_id, 'potassiumContentAsK2O'), None)
+    nitrogenContent = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent'), default=None)
+    phosphateContentAsP2O5 = safe_parse_float(get_term_lookup(term_id, 'phosphateContentAsP2O5'), default=None)
+    potassiumContentAsK2O = safe_parse_float(get_term_lookup(term_id, 'potassiumContentAsK2O'), default=None)
 
     # skip inputs that already have all the inlcuded term with a value
     inputs = cycle.get('inputs', [])

hestia_earth/models/hestia/landCover.py

@@ -163,7 +163,7 @@ def _should_group_landCover(management_node: dict):
     )
 
 
-def get_changes(country_id: str, end_year: int) -> tuple[dict, bool]:
+def _get_changes(country_id: str, end_year: int) -> tuple[dict, bool]:
     """
     For each entry in ALL_LAND_USE_TERMS, creates a key: value in output dictionary, also TOTAL
     """
@@ -178,7 +178,7 @@ def get_changes(country_id: str, end_year: int) -> tuple[dict, bool]:
         )
         for land_use_term in ALL_LAND_USE_TERMS + [LAND_AREA]
     }
-    missing_changes = any(val is None for val in changes_dict.values())
+    missing_changes = [k for k, v in changes_dict.items() if v is None]
     changes_dict = {k: v if v is not None else 0 for k, v in changes_dict.items()}
     changes_dict[TOTAL_AGRICULTURAL_CHANGE] = (
         float(changes_dict.get(TOTAL_CROPLAND, 0)) + float(changes_dict.get(PERMANENT_PASTURE, 0))
@@ -609,7 +609,7 @@ def _should_run_historical_land_use_change_single_crop(
 ) -> tuple[bool, dict]:
     """Calculate land use change percentages for a single management node/crop."""
     # (C-H).
-    changes, missing_changes = get_changes(country_id=country_id, end_year=end_year)
+    changes, missing_changes = _get_changes(country_id=country_id, end_year=end_year)
 
     # (L). Estimate maximum forest loss
     forest_loss = _estimate_maximum_forest_change(
@@ -749,12 +749,13 @@ def _should_run_historical_land_use_change_single_crop(
         land_use_type=land_use_type,
         country_id=country_id,
         changes=log_as_table(changes),
+        missing_changes=log_as_table(missing_changes),
         site_area=log_as_table(capped_site_area),
         sum_of_site_areas_is_100=sum_of_site_areas_is_100,
         site_type_allowed=site_type_allowed
     )
 
-    should_run = all([not missing_changes, country_id, site_type_allowed, sum_of_site_areas_is_100])
+    should_run = all([len(missing_changes) == 0, country_id, site_type_allowed, sum_of_site_areas_is_100])
     logShouldRun(site, MODEL, term.get("@id"), should_run, model_key=MODEL_KEY)
 
     return should_run, capped_site_area
@@ -831,7 +832,8 @@ def _should_run(site: dict) -> tuple[bool, list, dict]:
                     land_use_type=land_use_type,
                     allowed_land_use_types=';'.join(ALLOWED_LAND_USE_TYPES),
                     has_no_prior_land_cover_data=has_no_prior_land_cover_data,
-                    management_nodes=log_as_table([_omit(n, ['term']) for n in relevant_nodes]))
+                    management_nodes=log_as_table([_omit(n, ['term']) for n in relevant_nodes]),
+                    should_run_nodes=should_run_nodes)
 
     should_run = all([land_use_type, has_no_prior_land_cover_data, should_run_nodes])
     logShouldRun(site, MODEL, None, should_run, model_key=MODEL_KEY)

hestia_earth/models/hestia/landTransformation100YearAverageDuringCycle.py

@@ -27,6 +27,9 @@ RETURNS = {
         "previousLandCover": ""
     }]
 }
+LOOKUPS = {
+    "crop": "IPCC_LAND_USE_CATEGORY"
+}
 TERM_ID = 'landTransformation100YearAverageDuringCycle'
 _HISTORIC_DATE_OFFSET = 100
 

hestia_earth/models/hestia/landTransformation20YearAverageDuringCycle.py

@@ -27,6 +27,9 @@ RETURNS = {
         "previousLandCover": ""
     }]
 }
+LOOKUPS = {
+    "crop": "IPCC_LAND_USE_CATEGORY"
+}
 TERM_ID = 'landTransformation20YearAverageDuringCycle'
 _HISTORIC_DATE_OFFSET = 20
 

hestia_earth/models/hestia/liveAnimal.py

@@ -66,7 +66,7 @@ def _should_run(cycle: dict):
     ) or next(
         (p for p in product.get('properties', []) if p.get('term', {}).get('@id').endswith('PerHead')), {}
     )
-    propertyPerHead_value = safe_parse_float(propertyPerHead.get('value'), None)
+    propertyPerHead_value = safe_parse_float(propertyPerHead.get('value'), default=None)
 
     # make sure the `liveAnimal` Term is not already present as a Product or Input
     term_id = get_liveAnimal_term_id(product, model_key=MODEL_KEY)

hestia_earth/models/hestia/management.py

@@ -95,7 +95,7 @@ _INPUT_RULES = {
     TermTermType.INORGANICFERTILISER.value: (
         (
             TermTermType.INORGANICFERTILISER.value,  # Lookup column
-            lambda x: safe_parse_float(x) > 0,  # Condition
+            lambda x: safe_parse_float(x, default=0) > 0,  # Condition
             _INORGANIC_NITROGEN_FERTILISER_USED_TERM_ID  # New term.
         ),
     ),

hestia_earth/models/hestia/netPrimaryProduction.py

@@ -45,7 +45,7 @@ def _should_run(site: dict):
     logRequirements(site, model=MODEL, term=TERM_ID,
                     temperature=temperature)
 
-    should_run = temperature > 0
+    should_run = all([(temperature or 0) > 0])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run, temperature
 

hestia_earth/models/hestia/organicCarbonPerHa.py

@@ -189,8 +189,8 @@ def _run_calculation(site: dict, depth_key: str, measurement_nodes: list[dict])
         A list of `organicCarbonPerHa` [Measurement nodes](https://www.hestia.earth/schema/Measurement).
     """
     split = depth_key.split('_')  # "a_to_b"
-    depth_upper = safe_parse_float(split[0])
-    depth_lower = safe_parse_float(split[2])
+    depth_upper = safe_parse_float(split[0], default=0)
+    depth_lower = safe_parse_float(split[2], default=0)
 
     soil_bulk_density_nodes = [
         node for node in measurement_nodes if node.get('term', {}).get('@id') == SOIL_BULK_DENSITY_TERM_ID

hestia_earth/models/hestia/salineWater.py

@@ -34,7 +34,7 @@ def _should_run(site: dict):
     logRequirements(site, model=MODEL, term=TERM_ID,
                     waterSalinity=waterSalinity)
 
-    should_run = all([waterSalinity > 18000])
+    should_run = all([(waterSalinity or 0) > 18000])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

hestia_earth/models/hestia/seed_emissions.py

@@ -14,7 +14,7 @@ from hestia_earth.models.utils.site import valid_site_type
 from hestia_earth.models.utils.cycle import cycle_end_year
 from hestia_earth.models.utils.crop import get_crop_grouping_faostat_production, get_landCover_term_id
 from hestia_earth.models.utils.completeness import _is_term_type_complete
-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.lookup import get_region_lookup_value
 from . import MODEL
 
@@ -83,6 +83,7 @@ def _run_emission(
     input_term_id = input_term.get('@id')
     seed_value = list_sum(seed_input.get('value'))
     value = emission_value * economicValueShare / 100 / total_yield * seed_value
+    logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, model_key=MODEL_KEY, emission_id=term_id)
     debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 value=value,
                 coefficient=1,
@@ -107,7 +108,7 @@ def _map_group_emissions(group_id: str, required_emission_term_ids: list, emissi
     included_emissions = list(filter(lambda v: v in emission_ids, emissions))
     missing_emissions = list(filter(lambda v: v not in emission_ids, emissions))
     return {
-        'id': group_id,
+        'group-id': group_id,
         'total-emissions': len(emissions),
         'included-emissions': len(included_emissions),
         'missing-emissions': '-'.join(missing_emissions),
@@ -120,7 +121,7 @@ def _filter_emissions(cycle: dict):
 
     emissions = [
         {
-            'id': i.get('term', {}).get('@id'),
+            'emission-id': i.get('term', {}).get('@id'),
             'group-id': get_lookup_value(i.get('term', {}), LOOKUPS['emission'], model=MODEL, model_key=MODEL_KEY),
             'value': list_sum(i.get('value'))
         }
@@ -130,7 +131,7 @@ def _filter_emissions(cycle: dict):
             len(i.get('value', [])) > 0
         ])
     ]
-    emission_ids = set([v.get('id') for v in emissions])
+    emission_ids = set([v.get('emission-id') for v in emissions])
     group_ids = set([v.get('group-id') for v in emissions if v.get('group-id')])
 
     # for each group, get the list of all required emissions
@@ -140,7 +141,7 @@ def _filter_emissions(cycle: dict):
     ]
     # only keep groups that have all emissions present in the Cycle
     valid_groups = list(filter(lambda group: group.get('is-valid'), emissions_per_group))
-    valid_group_ids = set([v.get('id') for v in valid_groups])
+    valid_group_ids = set([v.get('group-id') for v in valid_groups])
 
     # finally, only return emissions which groups are valid
     return list(filter(
@@ -151,19 +152,21 @@ def _filter_emissions(cycle: dict):
 
 def _evs(product: dict):
     return safe_parse_float(
-        get_lookup_value(product.get('term', {}), 'global_economic_value_share', model=MODEL, model_key=MODEL_KEY)
+        get_lookup_value(product.get('term', {}), 'global_economic_value_share', model=MODEL, model_key=MODEL_KEY),
+        default=None
     ) or product.get('economicValueShare')
 
 
 def _faostat_yield(country_id: str, end_year: int, product: dict):
     grouping = get_crop_grouping_faostat_production(MODEL, product.get('term', {}))
-    return safe_parse_float(extract_grouped_data_closest_date(get_region_lookup_value(
+    value = extract_grouped_data_closest_date(get_region_lookup_value(
         'region-crop-cropGroupingFaostatProduction-yield.csv',
         country_id,
         grouping,
         model=MODEL,
         model_key=MODEL_KEY
-    ), end_year))
+    ), end_year)
+    return safe_parse_float(value, default=None)
 
 
 def _group_seed_inputs(inputs: list):
@@ -242,10 +245,11 @@ def _should_run(cycle: dict):
         emissions,
         {}
     )
+    has_single_land_cover = len(crop_land_cover_ids) <= 1
 
     should_run = all([
         site_type_valid,
-        len(crop_land_cover_ids) <= 1,
+        has_single_land_cover,
         is_product_complete,
         total_economicValueShare,
         total_yield,
@@ -253,29 +257,39 @@ def _should_run(cycle: dict):
         bool(emissions)
     ])
 
+    logs = {
+        'site_type_valid': site_type_valid,
+        'crop_products': log_as_table(crop_products),
+        'crop_land_cover_ids': ';'.join(crop_land_cover_ids),
+        'has_single_land_cover': has_single_land_cover,
+        'is_term_type_product_complete': is_product_complete,
+        'total_economicValueShare': total_economicValueShare,
+        'total_yield': total_yield,
+        'end_year': end_year,
+        'country_id': country_id
+    }
+
     for seed_input in seed_inputs:
         term_id = seed_input.get('input').get('term', {}).get('@id')
 
         logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                        site_type_valid=site_type_valid,
-                        crop_products=log_as_table(crop_products),
-                        crop_land_cover_ids=';'.join(crop_land_cover_ids),
-                        is_term_type_product_complete=is_product_complete,
-                        total_economicValueShare=total_economicValueShare,
-                        total_yield=total_yield,
-                        end_year=end_year,
-                        country_id=country_id,
                         emissions=log_as_table(emissions),
                         emissions_per_group=log_as_table(emissions_per_group),
-                        **_omit(seed_input, 'input'))
+                        **_omit(seed_input, 'input'),
+                        **logs)
 
         logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
 
-        # log missing emissions to show in the logs
+        # log failed emissions to show in the logs
         for group in emissions_per_group:
-            if not group.get('is-valid'):
+            emission_id = group.get('group-id')
+            if not group.get('is-valid') or not should_run:
+                logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY, emission_id=emission_id,
+                                **group,
+                                **_omit(seed_input, 'input'),
+                                **logs)
                 logShouldRun(cycle, MODEL, term_id, False,
-                             methodTier=TIER, model_key=MODEL_KEY, emission_id=group.get('id'))
+                             methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)
 
     return should_run, total_economicValueShare, total_yield, grouped_seed_inputs, grouped_emissions
 

hestia_earth/models/hestia/stockingDensityAnimalHousingAverage.py

@@ -3,7 +3,7 @@ from hestia_earth.utils.model import filter_list_term_type
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils import weighted_average
-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.practice import _new_practice
 from . import MODEL
 

hestia_earth/models/hestia/totalNitrogenPerKgSoil.py

@@ -45,7 +45,7 @@ def _should_run(site: dict):
     logRequirements(site, model=MODEL, term=TERM_ID,
                     carbon_content_value=carbon_content_value)
 
-    should_run = not is_from_model(carbon_content) and carbon_content_value > 0
+    should_run = all([not is_from_model(carbon_content), (carbon_content_value or 0) > 0])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run, carbon_content_value
 

hestia_earth/models/hestia/waterSalinity.py

@@ -5,7 +5,7 @@ from hestia_earth.utils.tools import safe_parse_float
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.measurement import _new_measurement
 from hestia_earth.models.utils.site import related_cycles
-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 = {
@@ -52,7 +52,8 @@ def _should_run(site: dict):
         {
             'product-id': product.get('term', {}).get('@id'),
             'lookup-value': safe_parse_float(
-                get_lookup_value(product.get('term', {}), LOOKUPS['liveAquaticSpecies']), default=None
+                get_lookup_value(product.get('term', {}), LOOKUPS['liveAquaticSpecies']),
+                default=None
             ),
             'start-date': product.get('startDate') or cycle.get('startDate'),
             'end-date': product.get('endDate') or cycle.get('endDate')

hestia_earth/models/ipcc2006/aboveGroundCropResidueRemoved.py

@@ -38,11 +38,11 @@ def _product(value: float):
 
 def _get_value(product: dict, product_dm_property: dict):
     value = product.get('value', [0])[0]
-    dm_percent = safe_parse_float(product_dm_property.get('value'))
+    dm_percent = safe_parse_float(product_dm_property.get('value'), default=None)
     debugValues(product, model=MODEL, term=product.get('term', {}).get('@id'),
                 value=value,
                 dm_percent=dm_percent)
-    return value * dm_percent / 100
+    return value * dm_percent / 100 if dm_percent is not None else 0
 
 
 def _run(products: list):

hestia_earth/models/ipcc2006/aboveGroundCropResidueTotal.py

@@ -41,21 +41,25 @@ def _product(value: float):
 def _get_value_dm(product: dict, dm_percent: float):
     term_id = product.get('term', {}).get('@id', '')
     product_yield = list_sum(product.get('value', [0]))
-    yield_dm = product_yield * (dm_percent / 100)
+    yield_dm = product_yield * (dm_percent / 100) if dm_percent is not None else None
 
     # estimate the AG DM calculation
-    slope = safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][1]), None)
-    intercept = safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][0]), None)
+    slope = safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][1]), default=None)
+    intercept = safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][0]), default=None)
     debugValues(product, model=MODEL, term=TERM_ID,
                 yield_dm=yield_dm,
                 dryMatter_percent=dm_percent,
                 slope=slope,
                 intercept=intercept)
-    return None if slope is None or intercept is None else (yield_dm * slope + intercept * 1000)
+    return None if any([
+        slope is None,
+        intercept is None,
+        yield_dm is None
+    ]) else (yield_dm * slope + intercept * 1000)
 
 
 def _run(product: dict, dm_property: dict):
-    value = _get_value_dm(product, safe_parse_float(dm_property.get('value')))
+    value = _get_value_dm(product, safe_parse_float(dm_property.get('value'), default=None))
     return [_product(value)] if value is not None else []
 
 
@@ -63,7 +67,7 @@ def _should_run_product(product: dict):
     term_id = product.get('term', {}).get('@id')
     value = list_sum(product.get('value', [0]))
     return value > 0 and (
-        safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][0]), None) is not None
+        safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][0]), default=None) is not None
     )
 
 

hestia_earth/models/ipcc2006/belowGroundCropResidue.py

@@ -41,17 +41,17 @@ def _product(value: float):
 def _get_value_dm(product: dict, dm_percent: float):
     term_id = product.get('term', {}).get('@id', '')
     product_yield = list_sum(product.get('value', [0]))
-    yield_dm = product_yield * (dm_percent / 100)
+    yield_dm = product_yield * (dm_percent / 100) if dm_percent is not None else None
 
     # TODO with the spreadsheet there are a number of ways this value is calculated.
     # Currently, the result of this model when applied to Sah et al does not match
     # the example due to hardcoded calc in the spreadsheet
 
     # estimate the BG DM calculation
-    intercept = safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][0]))
-    slope = safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][1]))
+    intercept = safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][0]), default=None)
+    slope = safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][1]), default=None)
     ab_bg_ratio = safe_parse_float(
-        get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][2])
+        get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][2]), default=None
     )
     debugValues(product, model=MODEL, term=TERM_ID,
                 yield_dm=yield_dm,
@@ -64,12 +64,16 @@ def _get_value_dm(product: dict, dm_percent: float):
     #  https://www.ipcc-nggip.iges.or.jp/public/2019rf/pdf/4_Volume4/19R_V4_Ch11_Soils_N2O_CO2.pdf
     #  only if site.type = pasture
     # multiply by the ratio of above to below matter
-    return None if slope is None or intercept is None or ab_bg_ratio is None \
-        else ((yield_dm * slope + intercept * 1000) + yield_dm) * ab_bg_ratio
+    return None if any([
+        yield_dm is None,
+        slope is None,
+        intercept is None,
+        ab_bg_ratio is None
+    ]) else ((yield_dm * slope + intercept * 1000) + yield_dm) * ab_bg_ratio
 
 
 def _run(product: dict, dm_property: dict):
-    value = _get_value_dm(product, safe_parse_float(dm_property.get('value')))
+    value = _get_value_dm(product, safe_parse_float(dm_property.get('value'), default=None))
     return [_product(value)] if value is not None else []
 
 
@@ -77,7 +81,7 @@ def _should_run_product(product: dict):
     term_id = product.get('term', {}).get('@id')
     value = list_sum(product.get('value', [0]))
     return value > 0 and (
-        safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][0]), None) is not None
+        safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, LOOKUPS['crop'][0]), default=None) is not None
     )
 
 

hestia_earth/models/ipcc2019/animal/utils.py

@@ -30,7 +30,7 @@ def productivity_lookup_value(term_id: str, lookup: str, country: dict, animal:
     return safe_parse_float(
         extract_grouped_data(value, productivity_key.value) or
         extract_grouped_data(value, PRODUCTIVITY.HIGH.value),  # defaults to high if low is not found
-        None
+        default=None
     )
 
 

hestia_earth/models/ipcc2019/belowGroundCropResidue.py

@@ -42,7 +42,7 @@ def _product(value: float):
 
 
 def _get_lookup_value(term: dict, column: str):
-    return safe_parse_float(get_lookup_value(term, column, model=MODEL, term=TERM_ID), None)
+    return safe_parse_float(get_lookup_value(term, column, model=MODEL, term=TERM_ID), default=None)
 
 
 def _product_value(product: dict):

hestia_earth/models/ipcc2019/carbonContent.py

@@ -67,7 +67,7 @@ def _crop_residue_lookup_col(term):
 
 
 def _get_lookup_value(term: dict, column: str):
-    return safe_parse_float(get_lookup_value(term, column, model=MODEL, term=TERM_ID), None)
+    return safe_parse_float(get_lookup_value(term, column, model=MODEL, term=TERM_ID), default=None)
 
 
 # Single crop