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

hestia_earth/models/hestia/seed_emissions.py

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

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

hestia_earth/models/ipcc2019/ch4ToAirAquacultureSystems.py

@@ -63,15 +63,12 @@ def _find_measurement(site: dict):
     return measurements[0] if measurements else None
 
 
-def _run(cycle: dict):
+def _run(cycle: dict, factors: list):
     cycle_duration = cycle.get('cycleDuration')
     site = cycle.get('site', {})
     site_area = site.get('area')
-    water_term = _find_measurement(site).get('term', {})
-    factor_value = safe_parse_float(get_lookup_value(water_term, LOOKUPS.get('measurement')))
-    factor_min = safe_parse_float(get_lookup_value(water_term, f"{LOOKUPS.get('measurement')}-min"))
-    factor_max = safe_parse_float(get_lookup_value(water_term, f"{LOOKUPS.get('measurement')}-max"))
     ratio = site_area * cycle_duration / 365
+    factor_value, factor_min, factor_max = factors
     return [_emission(ratio * factor_value, ratio * factor_min, ratio * factor_max)]
 
 
@@ -80,7 +77,13 @@ def _should_run(cycle: dict):
     is_relative = cycle.get('functionalUnit') == CycleFunctionalUnit.RELATIVE.value
     site = cycle.get('site', {})
     site_area = site.get('area')
-    has_water_type = _find_measurement(site) is not None
+
+    water_measurement = _find_measurement(site)
+    has_water_type = water_measurement is not None
+    water_term = (water_measurement or {}).get('term', {})
+    factor_value = safe_parse_float(get_lookup_value(water_term, LOOKUPS.get('measurement')), default=None)
+    factor_min = safe_parse_float(get_lookup_value(water_term, f"{LOOKUPS.get('measurement')}-min"), default=None)
+    factor_max = safe_parse_float(get_lookup_value(water_term, f"{LOOKUPS.get('measurement')}-max"), default=None)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     cycle_duration=cycle_duration,
@@ -88,9 +91,14 @@ def _should_run(cycle: dict):
                     site_area=site_area,
                     has_water_type=has_water_type)
 
-    should_run = all([cycle_duration, is_relative, site_area, has_water_type])
+    should_run = all([
+        cycle_duration, is_relative, site_area, has_water_type,
+        factor_value is not None, factor_min is not None, factor_max is not None
+    ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run
+    return should_run, [factor_value, factor_min, factor_max]
 
 
-def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []
+def run(cycle: dict):
+    should_run, factors = _should_run(cycle)
+    return _run(cycle, factors) if should_run else []

hestia_earth/models/ipcc2019/ch4ToAirEntericFermentation.py

@@ -172,7 +172,7 @@ def _extract_groupped_data(value: str, DE: float, NDF: float, ionophore: bool, m
     debugValues({}, model=MODEL, term=TERM_ID,
                 value_key=value_key)
 
-    return safe_parse_float(extract_grouped_data(value, value_key), None)
+    return safe_parse_float(extract_grouped_data(value, value_key), default=None)
 
 
 def _get_lookup_value(lookup, term: dict, lookup_col: str, DE: float, NDF: float, ionophore: bool, milk_yield: float):
@@ -215,9 +215,9 @@ def _get_default_values(lookup, term: dict):
     min = get_table_value(lookup, 'termid', term_id, column_name(LOOKUPS['liveAnimal'][4])) if term_id else None
     max = get_table_value(lookup, 'termid', term_id, column_name(LOOKUPS['liveAnimal'][5])) if term_id else None
     return {
-        'value': safe_parse_float(value, None),
-        'min': safe_parse_float(min, None),
-        'max': safe_parse_float(max, None)
+        'value': safe_parse_float(value, default=None),
+        'min': safe_parse_float(min, default=None),
+        'max': safe_parse_float(max, default=None)
     }
 
 
@@ -257,10 +257,10 @@ def _should_run(cycle: dict):
 
     enteric_factor = safe_parse_float(_get_lookup_value(
         lookup, term, LOOKUPS['liveAnimal'][1], DE or DE_default, NDF, ionophore, milk_yield
-    ), None)
+    ), default=None)
     enteric_sd = safe_parse_float(_get_lookup_value(
         lookup, term, LOOKUPS['liveAnimal'][2], DE or DE_default, NDF, ionophore, milk_yield
-    ), None)
+    ), default=None)
 
     default_values = _get_default_values(lookup, term)
 

hestia_earth/models/ipcc2019/ch4ToAirExcreta.py

@@ -89,7 +89,8 @@ def _get_excreta_b0(country: dict, input: dict):
     data_values = get_region_lookup_value(lookup_name, country.get('@id'), term_id, model=MODEL, term=TERM_ID)
     return safe_parse_float(
         extract_grouped_data(data_values, productivity_key.value) or
-        extract_grouped_data(data_values, PRODUCTIVITY.HIGH.value)  # defaults to high if low is not found
+        extract_grouped_data(data_values, PRODUCTIVITY.HIGH.value),  # defaults to high if low is not found
+        default=None
     )
 
 
@@ -100,7 +101,8 @@ def _get_excretaManagement_MCF_from_lookup(term_id: str, ecoClimateZone: int, du
     debugMissingLookup(lookup_name, 'termid', term_id, ecoClimateZone, data_values, model=MODEL, term=TERM_ID)
     return safe_parse_float(
         extract_grouped_data(data_values, duration_key.value)
-        or extract_grouped_data(data_values, DEFAULT_DURATION.value)  # defaults to 12 months if no duration specified
+        or extract_grouped_data(data_values, DEFAULT_DURATION.value),  # defaults to 12 months if no duration specified
+        default=None
     ) if data_values else 0
 
 

hestia_earth/models/ipcc2019/co2ToAirUreaHydrolysis.py

@@ -38,7 +38,7 @@ def _emission(value: float):
 
 
 def _urea_emission_factor(term_id: str):
-    return safe_parse_float(get_term_lookup(term_id, LOOKUPS['inorganicFertiliser'][2]), None)
+    return safe_parse_float(get_term_lookup(term_id, LOOKUPS['inorganicFertiliser'][2]), default=None)
 
 
 def _run(urea_values: list):

hestia_earth/models/ipcc2019/croppingDuration.py

@@ -54,7 +54,9 @@ def _practice(value: float, min: float, max: float, sd: float):
 
 
 def _get_value(country: str, col: str):
-    return safe_parse_float(get_region_lookup_value(LOOKUP_TABLE, country, col, model=MODEL, term=TERM_ID))
+    return safe_parse_float(
+        get_region_lookup_value(LOOKUP_TABLE, country, col, model=MODEL, term=TERM_ID), default=None
+    )
 
 
 def _run(country: str):
@@ -67,7 +69,7 @@ def _run(country: str):
 
 def _should_run(cycle: dict):
     country = cycle.get('site', {}).get('country', {}).get('@id')
-    croppingDuration = _get_value(country, LOOKUP_COL_PREFIX)
+    croppingDuration = _get_value(country, LOOKUP_COL_PREFIX) or 0
 
     cycleDuration = cycle.get('cycleDuration', 0)
     flooded_rice = has_flooded_rice(cycle.get('products', []))

hestia_earth/models/ipcc2019/ligninContent.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

hestia_earth/models/{akagiEtAl2011AndIpcc2006 → ipcc2019}/n2OToAirCropResidueBurningDirect.py

@@ -2,7 +2,8 @@ from hestia_earth.schema import EmissionMethodTier
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
-from .utils import _get_crop_residue_burnt_value
+from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.cropResidue import get_crop_residue_burnt_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -23,9 +24,11 @@ RETURNS = {
         "methodTier": "tier 1"
     }]
 }
+LOOKUPS = {
+    "emission": ["ipcc2019CropResidueBurningFactor"]
+}
 TERM_ID = 'n2OToAirCropResidueBurningDirect'
 TIER = EmissionMethodTier.TIER_1.value
-DRY_MATTER_FACTOR_TO_N2O = 0.07/1000
 
 
 def _emission(value: float):
@@ -37,11 +40,12 @@ def _emission(value: float):
 
 def _run(product_value: list):
     value = sum(product_value)
-    return [_emission(value * DRY_MATTER_FACTOR_TO_N2O)]
+    factor = get_lookup_value({'termType': 'emission', '@id': TERM_ID}, LOOKUPS['emission'][0])
+    return [_emission(value * factor)]
 
 
 def _should_run(cycle: dict):
-    crop_residue_burnt_value = _get_crop_residue_burnt_value(cycle)
+    crop_residue_burnt_value = get_crop_residue_burnt_value(cycle)
     has_crop_residue_burnt = len(crop_residue_burnt_value) > 0
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,

hestia_earth/models/ipcc2019/nitrogenContent.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

hestia_earth/models/ipcc2019/nonCo2EmissionsToAirNaturalVegetationBurning.py

@@ -314,7 +314,9 @@ def _get_fuel_factor(fuel_category: _FuelCategory) -> dict:
         debugMissingLookup(LOOKUP_FILENAME, "FuelCategory", row, target, data.get(target), model=MODEL, term=term_id)
 
     return (
-        {k: parsed for k, v in data.items() if (parsed := safe_parse_float(v, None)) is not None}  # remove missing
+        {
+            k: parsed for k, v in data.items() if (parsed := safe_parse_float(v, default=None)) is not None
+        }  # remove missing
         or _DEFAULT_FACTOR  # if parsed dict empty, return default
     )
 
@@ -343,7 +345,9 @@ def _get_emission_factor(term_id: _EmissionTermId, emission_category: _EmissionC
         )
 
     return (
-        {k: parsed for k, v in data.items() if (parsed := safe_parse_float(v, None)) is not None}  # remove missing
+        {
+            k: parsed for k, v in data.items() if (parsed := safe_parse_float(v, default=None)) is not None
+        }  # remove missing
         or _DEFAULT_FACTOR  # if parsed dict empty, return default
     )
 

hestia_earth/models/ipcc2019/pastureGrass_utils.py

@@ -34,7 +34,7 @@ def _get_activityCoefficient(animal: dict, systems: list) -> float:
     values = [(
         safe_parse_float(
             get_table_value(lookup, 'termid', system.get('term', {}).get('@id'), column_name(term_id)),
-            0
+            default=0
         ),
         list_sum(system.get('value', [0]))
     ) for system in systems]
@@ -46,7 +46,7 @@ def _calculate_NEm(cycle: dict, animal: dict) -> float:
     term = animal.get('term', {})
 
     mjDayKgCfiNetEnergyMaintenance = safe_parse_float(
-        get_lookup_value(term, 'mjDayKgCfiNetEnergyMaintenanceIpcc2019', model=MODEL, model_key=MODEL_KEY), 0
+        get_lookup_value(term, 'mjDayKgCfiNetEnergyMaintenanceIpcc2019', model=MODEL, model_key=MODEL_KEY), default=0
     )
     liveweightPerHead = get_node_property(animal, 'liveweightPerHead', False).get('value', 0)
     animal_value = animal.get('value', 0)
@@ -102,13 +102,13 @@ def _calculate_NEl_sheepAndGoat(cycle: dict, animal: dict) -> float:
     milkYield = list_sum(milkYieldPractice.get('value', []))
     EV_milk = safe_parse_float(
         get_lookup_value(milkYieldPractice.get('term', {}), 'mjKgEvMilkIpcc2019', model=MODEL, model_key=MODEL_KEY),
-        0
+        default=0
     )
     default_fatContent = safe_parse_float(
         get_lookup_value(
             milkYieldPractice.get('term', {}), 'defaultFatContentEvMilkIpcc2019', model=MODEL, model_key=MODEL_KEY
         ),
-        7
+        default=7
     )
     fatContent = get_node_property(milkYieldPractice, 'fatContent').get('value', 0)
     animal_value = animal.get('value', 0)
@@ -138,9 +138,9 @@ def _calculate_NEwork(cycle: dict, animal: dict, NEm: float) -> float:
 
 def _get_pregnancy_ratio_per_birth(animal: dict, value: str) -> float:
     animalsPerBirth = get_node_property(animal, 'animalsPerBirth').get('value', 3)
-    single = safe_parse_float(extract_grouped_data(value, 'singleBirth'), 0)
-    double = safe_parse_float(extract_grouped_data(value, 'doubleBirth'), 0)
-    tripple = safe_parse_float(extract_grouped_data(value, 'tripleBirthOrMore'))
+    single = safe_parse_float(extract_grouped_data(value, 'singleBirth'), default=0)
+    double = safe_parse_float(extract_grouped_data(value, 'doubleBirth'), default=0)
+    tripple = safe_parse_float(extract_grouped_data(value, 'tripleBirthOrMore'), default=0)
     return (
         single if animalsPerBirth <= 1 else
         ((animalsPerBirth-1)/2)*single * (1-((animalsPerBirth-1)/2)*double) if 1 < animalsPerBirth < 2 else
@@ -153,7 +153,7 @@ def _get_pregnancy_ratio_per_birth(animal: dict, value: str) -> float:
 def _get_pregnancy_ratio(animal: dict) -> float:
     term = animal.get('term', {})
     value = get_lookup_value(term, 'ratioCPregnancyNetEnergyPregnancyIpcc2019', model=MODEL, model_key=MODEL_KEY)
-    return _get_pregnancy_ratio_per_birth(animal, value) if ';' in value else safe_parse_float(value, 0)
+    return _get_pregnancy_ratio_per_birth(animal, value) if ';' in value else safe_parse_float(value, default=0)
 
 
 def _calculate_NEp(cycle: dict, animal: dict, NEm: float) -> float:
@@ -168,7 +168,8 @@ def _calculate_NEg_cattleAndBuffalo(cycle: dict, animal: dict) -> float:
     term = animal.get('term', {})
 
     ratioCNetEnergyGrowthCattleBuffalo = safe_parse_float(
-        get_lookup_value(term, 'ratioCNetEnergyGrowthCattleBuffaloIpcc2019', model=MODEL, model_key=MODEL_KEY), 0
+        get_lookup_value(term, 'ratioCNetEnergyGrowthCattleBuffaloIpcc2019', model=MODEL, model_key=MODEL_KEY),
+        default=0
     )
     liveweightPerHead = get_node_property(animal, 'liveweightPerHead').get('value', 0)
     weightAtMaturity = get_node_property(animal, 'weightAtMaturity').get('value', 0)
@@ -190,8 +191,8 @@ def _calculate_NEg_sheepAndGoat(cycle: dict, animal: dict) -> float:
 
     MjKgABNetEnergyGrowthSheepGoats = get_lookup_value(
         term, 'mjKgABNetEnergyGrowthSheepGoatsIpcc2019', model=MODEL, model_key=MODEL_KEY)
-    MjKg_a = safe_parse_float(extract_grouped_data(MjKgABNetEnergyGrowthSheepGoats, 'a'), 0)
-    MjKg_b = safe_parse_float(extract_grouped_data(MjKgABNetEnergyGrowthSheepGoats, 'b'), 0)
+    MjKg_a = safe_parse_float(extract_grouped_data(MjKgABNetEnergyGrowthSheepGoats, 'a'), default=0)
+    MjKg_b = safe_parse_float(extract_grouped_data(MjKgABNetEnergyGrowthSheepGoats, 'b'), default=0)
     BWi = get_node_property(animal, 'weightAtWeaning').get('value', 0)
     BWf = get_node_property(animal, 'weightAtOneYear').get('value', 0) or \
         get_node_property(animal, 'weightAtSlaughter').get('value', 0)
@@ -352,7 +353,7 @@ def calculate_meanDE(practices: list, **log_args) -> float:
 
 
 def product_wool_energy(product: dict):
-    return safe_parse_float(get_lookup_value(product.get('term', {}), 'mjKgEvWoolNetEnergyWoolIpcc2019'), 24)
+    return safe_parse_float(get_lookup_value(product.get('term', {}), 'mjKgEvWoolNetEnergyWoolIpcc2019'), default=24)
 
 
 def should_run_practice(cycle: dict):

hestia_earth/models/ipcc2019/utils.py

@@ -53,7 +53,9 @@ def get_FracNH3NOx_N2O(cycle: dict, term_id: str):
 
 
 def get_yield_dm(term_id: str, term: dict):
-    return safe_parse_float(get_lookup_value(term, 'IPCC_2019_Ratio_AGRes_YieldDM', model=MODEL, term=term_id), None)
+    return safe_parse_float(
+        get_lookup_value(term, 'IPCC_2019_Ratio_AGRes_YieldDM', model=MODEL, term=term_id), default=None
+    )
 
 
 def get_milkYield_practice(node: dict):
@@ -146,7 +148,9 @@ EF5_FACTORS = {
 
 
 def _get_waterRegime_lookup(model_term_id: str, practice: dict, col: str):
-    return safe_parse_float(get_lookup_value(practice.get('term', {}), col, model=MODEL, term=model_term_id), None)
+    return safe_parse_float(
+        get_lookup_value(practice.get('term', {}), col, model=MODEL, term=model_term_id), default=None
+    )
 
 
 def _is_wet(ecoClimateZone: str = None):

hestia_earth/models/koble2014/residueBurnt.py

@@ -31,15 +31,18 @@ LOOKUP_NAME = 'region-crop-cropGroupingResidue-burnt.csv'
 def _get_default_percent(cycle: dict, term: dict, country_id: str):
     crop_grouping = get_lookup_value(term, LOOKUPS['crop'][0], model=MODEL, term=TERM_ID)
     percent = safe_parse_float(
-        get_region_lookup_value(LOOKUP_NAME, country_id, crop_grouping, model=MODEL, term=TERM_ID), None
+        get_region_lookup_value(LOOKUP_NAME, country_id, crop_grouping, model=MODEL, term=TERM_ID), default=None
     ) if crop_grouping else None
-    comb_factor = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][1]))
+    comb_factor = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][1]), default=None)
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     crop_grouping=crop_grouping,
                     country_id=country_id,
                     percent=percent,
                     comb_factor=comb_factor)
-    return percent if comb_factor is None or percent is None else percent * comb_factor
+    return percent if any([
+        comb_factor is None,
+        percent is None
+    ]) else percent * comb_factor
 
 
 def _run(cycle: dict, remaining_value: float, primary_product: dict, country_id: str):

hestia_earth/models/koble2014/residueRemoved.py

@@ -37,7 +37,7 @@ def _get_default_percent(cycle: dict, term: dict, country_id: str):
                     crop_grouping=crop_grouping,
                     country_id=country_id,
                     percent=percent)
-    return safe_parse_float(percent, None)
+    return safe_parse_float(percent, default=None)
 
 
 def _run(cycle: dict, remaining_value: float, primary_product: dict, country_id: str):