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

hestia_earth/models/{akagiEtAl2011AndIpcc2006 → akagiEtAl2011}/__init__.py

@@ -6,7 +6,7 @@ from hestia_earth.models.utils.blank_node import run_if_required
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
-MODEL = 'akagiEtAl2011AndIpcc2006'
+MODEL = 'akagiEtAl2011'
 PKG = '.'.join(['hestia_earth', 'models', MODEL])
 
 

hestia_earth/models/akagiEtAl2011/ch4ToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'ch4ToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/nh3ToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'nh3ToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/noxToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'noxToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/pm25ToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'pm25ToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/so2ToAirCropResidueBurning.py

@@ -0,0 +1,32 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import run_emission
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "products": [{
+                "@type": "Product",
+                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
+                "value": ""
+            }],
+            "completeness.cropResidue": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "emission": ["akagiEtAl2011CropResidueBurningFactor", "akagiEtAl2011CropResidueBurningFactor-sd"]
+}
+TERM_ID = 'so2ToAirCropResidueBurning'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_emission(TERM_ID, cycle)

hestia_earth/models/akagiEtAl2011/utils.py

@@ -0,0 +1,45 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+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.cropResidue import get_crop_residue_burnt_value
+from . import MODEL
+
+TIER = EmissionMethodTier.TIER_1.value
+LOOKUP_NAME = 'akagiEtAl2011CropResidueBurningFactor'
+
+
+def _emission(term_id: str, value: float, sd: float = None):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = TIER
+    if sd is not None:
+        emission['sd'] = [sd]
+        emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    return emission
+
+
+def _run(term_id: str, product_value: list):
+    value = sum(product_value)
+    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)]
+
+
+def _should_run(term_id: str, cycle: dict):
+    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,
+                    has_crop_residue_burnt=has_crop_residue_burnt)
+
+    should_run = all([has_crop_residue_burnt])
+    logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER)
+    return should_run, crop_residue_burnt_value
+
+
+def run_emission(term_id: str, cycle: dict):
+    should_run, crop_residue_burnt_value = _should_run(term_id, cycle)
+    return _run(term_id, crop_residue_burnt_value) if should_run else []

hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -61,7 +61,7 @@ def _get_factor_from_basinId(site: dict, aware_id: str):
         download_lookup(f"{AWARE_KEY}.csv"), column_name(AWARE_KEY), int(aware_id), column_name(lookup_col)
     )
     debugMissingLookup(f"{AWARE_KEY}.csv", AWARE_KEY, aware_id, lookup_col, value, model=MODEL, term=TERM_ID)
-    return safe_parse_float(value, None)
+    return safe_parse_float(value, default=None)
 
 
 def _get_factor_from_region(impact_assessment: dict, site: dict):
@@ -71,7 +71,7 @@ def _get_factor_from_region(impact_assessment: dict, site: dict):
     lookup_suffix = 'unspecified' if not site_type else ('irri' if site_type in IRRIGATED_SITE_TYPES else 'non_irri')
     column = f"Agg_CF_{lookup_suffix}"
     value = get_region_lookup_value(lookup_name, region_id, column, model=MODEL, term=TERM_ID)
-    return safe_parse_float(value, None)
+    return safe_parse_float(value, default=None)
 
 
 def run(impact_assessment: dict):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsTotalLandUseEffects.py

@@ -45,7 +45,7 @@ def _indicator(value: float):
 def impact_value(impact_assessment: dict, term_id: str):
     impact = find_term_match(impact_assessment.get('impacts', []), term_id)
     value = impact.get('value')
-    value = safe_parse_float(value, None)
+    value = safe_parse_float(value, default=None)
     debugValues(impact, model=MODEL, term=TERM_ID, node=term_id, value=value, coefficient=1)
     return value
 

hestia_earth/models/chaudharyBrooks2018/utils.py

@@ -33,4 +33,4 @@ def get_region_factor(term_id: str, impact_assessment: dict, lookup_suffix: str,
         term_id, lookup_name, 'ecoregion', ecoregion, site_type
     )
     value = extract_grouped_data(value, group_key) if group_key else value
-    return safe_parse_float(value)
+    return safe_parse_float(value, default=None)

hestia_earth/models/config/Cycle.json

@@ -976,6 +976,17 @@
       },
       "stage": 2
     },
+    {
+      "key": "emissions",
+      "model": "hestia",
+      "value": "default_emissions",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      },
+      "stage": 2
+    },
     [
       {
         "key": "emissions",
@@ -1649,7 +1660,7 @@
     [
       {
         "key": "emissions",
-        "model": "akagiEtAl2011AndIpcc2006",
+        "model": "akagiEtAl2011",
         "value": "ch4ToAirCropResidueBurning",
         "runStrategy": "add_blank_node_if_missing",
         "runArgs": {
@@ -1664,8 +1675,8 @@
       },
       {
         "key": "emissions",
-        "model": "akagiEtAl2011AndIpcc2006",
-        "value": "n2OToAirCropResidueBurningDirect",
+        "model": "akagiEtAl2011",
+        "value": "nh3ToAirCropResidueBurning",
         "runStrategy": "add_blank_node_if_missing",
         "runArgs": {
           "runNonMeasured": true,
@@ -1679,8 +1690,8 @@
       },
       {
         "key": "emissions",
-        "model": "akagiEtAl2011AndIpcc2006",
-        "value": "nh3ToAirCropResidueBurning",
+        "model": "akagiEtAl2011",
+        "value": "noxToAirCropResidueBurning",
         "runStrategy": "add_blank_node_if_missing",
         "runArgs": {
           "runNonMeasured": true,
@@ -1694,8 +1705,23 @@
       },
       {
         "key": "emissions",
-        "model": "akagiEtAl2011AndIpcc2006",
-        "value": "noxToAirCropResidueBurning",
+        "model": "akagiEtAl2011",
+        "value": "pm25ToAirCropResidueBurning",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "akagiEtAl2011",
+        "value": "so2ToAirCropResidueBurning",
         "runStrategy": "add_blank_node_if_missing",
         "runArgs": {
           "runNonMeasured": true,
@@ -1767,6 +1793,21 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "ipcc2019",
+        "value": "n2OToAirCropResidueBurningDirect",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
       {
         "key": "emissions",
         "model": "ipcc2019",

hestia_earth/models/config/ImpactAssessment.json

@@ -56,6 +56,17 @@
       },
       "stage": 1
     },
+    {
+      "key": "emissionsResourceUse",
+      "model": "hestia",
+      "value": "default_resourceUse",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      },
+      "stage": 1
+    },
     [
       {
         "key": "emissionsResourceUse",
@@ -216,6 +227,17 @@
         "stage": 1
       }
     ],
+    {
+      "key": "emissionsResourceUse",
+      "model": "resourceUseNotRelevant",
+      "value": "all",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceLowerTier": true
+      },
+      "stage": 1
+    },
     [
       {
         "key": "impacts",

hestia_earth/models/cycle/completeness/soilAmendment.py

@@ -29,7 +29,7 @@ def run(cycle: dict):
     soilPh = measurement_value(soilPh_measurement)
 
     soilPh_added = is_from_model(soilPh_measurement)
-    soilPh_above_6_5 = soilPh > 6.5
+    soilPh_above_6_5 = soilPh is not None and soilPh > 6.5
 
     logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
                     soilPh_added=soilPh_added,

hestia_earth/models/cycle/product/economicValueShare.py

@@ -31,8 +31,10 @@ RETURNS = {
 LOOKUPS = {
     "@doc": "Depending on the primary product [termType](https://hestia.earth/schema/Product#term)",
     "crop": "global_economic_value_share",
+    "processedFood": "global_economic_value_share",
     "excreta": "global_economic_value_share",
-    "animalProduct": "global_economic_value_share"
+    "animalProduct": "global_economic_value_share",
+    "waste": "global_economic_value_share"
 }
 MODEL_KEY = 'economicValueShare'
 MAX_VALUE = 100.5

hestia_earth/models/cycle/product/price.py

@@ -1,4 +1,4 @@
-from hestia_earth.utils.tools import non_empty_list
+from hestia_earth.utils.tools import list_sum, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.currency import DEFAULT_CURRENCY
@@ -7,7 +7,15 @@ from .. import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{"@type": "Product"}]
+        "products": [{
+            "@type": "Product",
+            "optional": {
+                "revenue": "0"
+            },
+            "none": {
+                "price": ""
+            }
+        }]
     }
 }
 RETURNS = {
@@ -15,6 +23,14 @@ RETURNS = {
         "price": ""
     }]
 }
+LOOKUPS = {
+    "@doc": "Depending on the primary product [termType](https://hestia.earth/schema/Product#term)",
+    "crop": "global_economic_value_share",
+    "processedFood": "global_economic_value_share",
+    "excreta": "global_economic_value_share",
+    "animalProduct": "global_economic_value_share",
+    "waste": "global_economic_value_share"
+}
 MODEL_KEY = 'price'
 
 
@@ -24,26 +40,35 @@ def _product(product: dict, value: float):
     return {'currency': DEFAULT_CURRENCY, **product, MODEL_KEY: value}
 
 
-def _should_run_product_by_share_0(cycle: dict, product: dict):
+def _should_run_product(cycle: dict, product: dict):
     term_id = product.get('term', {}).get('@id')
+
+    value = list_sum(product.get('value') or [], default=None)
+    is_yield_0 = value == 0
+
     share = lookup_share(MODEL_KEY, product)
     share_is_0 = share is not None and share == 0
 
+    revenue = product.get('revenue', -1)
+    revenue_is_0 = revenue == 0
+
     logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by='economicValueShare',
-                    share_is_0=share_is_0)
+                    global_economic_value_share=share,
+                    share_is_0=share_is_0,
+                    revenue=revenue,
+                    revenue_is_0=revenue_is_0,
+                    product_yield=value,
+                    is_yield_0=is_yield_0)
 
-    should_run = all([share_is_0])
+    should_run = any([share_is_0, revenue_is_0, is_yield_0])
     logShouldRun(cycle, MODEL, term_id, should_run, key=MODEL_KEY, by='economicValueShare')
     return should_run
 
 
-def _should_run_product(product: dict): return product.get(MODEL_KEY) is None
-
-
 def run(cycle: dict):
-    products = list(filter(_should_run_product, cycle.get('products', [])))
+    products = list(filter(lambda p: p.get(MODEL_KEY) is None, cycle.get('products', [])))
     return non_empty_list([
         (
-            _product(p, 0) if _should_run_product_by_share_0(cycle, p) else None
+            _product(p, 0) if _should_run_product(cycle, p) else None
         ) for p in products
     ])

hestia_earth/models/cycle/product/revenue.py

@@ -9,9 +9,12 @@ REQUIREMENTS = {
     "Cycle": {
         "products": [{
             "@type": "Product",
-            "price": "",
             "optional": {
-                "value": ""
+                "value": "",
+                "price": ""
+            },
+            "none": {
+                "revenue": ""
             }
         }]
     }

hestia_earth/models/dammgen2009/noxToAirExcreta.py

@@ -1,22 +1,19 @@
 from hestia_earth.schema import EmissionMethodTier
+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
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 from hestia_earth.models.utils.emission import _new_emission
-from hestia_earth.models.utils.input import total_excreta
-from hestia_earth.models.utils.excretaManagement import get_lookup_factor
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "practices": [
-            {"@type": "Practice", "value": "", "term.termType": "excretaManagement"}
+        "emissions": [
+            {"@type": "Emission", "value": "", "term.@id": "n2OToAirExcretaDirect"}
         ]
     }
 }
-LOOKUPS = {
-    "excretaManagement": "EF_NO-N"
-}
 RETURNS = {
     "Emission": [{
         "value": "",
@@ -25,6 +22,7 @@ RETURNS = {
 }
 TERM_ID = 'noxToAirExcreta'
 TIER = EmissionMethodTier.TIER_1.value
+N2O_TERM_ID = 'n2OToAirExcretaDirect'
 
 
 def _emission(value: float):
@@ -34,24 +32,22 @@ def _emission(value: float):
     return emission
 
 
-def _run(excretaKgN: float, NO_N_EF: float):
-    value = (NO_N_EF or 0) * (excretaKgN or 0) * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
+def _run(n2o: dict):
+    value = 0.1 * list_sum(n2o.get("value", [])) / get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+    value = value * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
     return [_emission(value)]
 
 
 def _should_run(cycle: dict):
-    excretaKgN = total_excreta(cycle.get('inputs', []))
-    NO_N_EF = get_lookup_factor(cycle.get('practices', []), LOOKUPS['excretaManagement'])
+    n2o = find_term_match(cycle.get('emissions', []), N2O_TERM_ID)
 
-    logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    excretaKgN=excretaKgN,
-                    NO_N_EF=NO_N_EF)
+    logRequirements(cycle, model=MODEL, term=TERM_ID, has_n2o=n2o is not None)
 
-    should_run = all([excretaKgN is not None, NO_N_EF is not None])
+    should_run = all([n2o])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, excretaKgN, NO_N_EF
+    return should_run, n2o
 
 
 def run(cycle: dict):
-    should_run, excretaKgN, NO_N_EF = _should_run(cycle)
-    return _run(excretaKgN, NO_N_EF) if should_run else []
+    should_run, n2o = _should_run(cycle)
+    return _run(n2o) if should_run else []

hestia_earth/models/ecoinventV3/__init__.py

@@ -79,7 +79,7 @@ def _emission(term_id: str, value: float, input: dict):
     return emission
 
 
-def _add_emission(cycle: dict, input: dict):
+def _add_emission(cycle: dict, input: dict, **extra_logs):
     input_term_id = input.get('term', {}).get('@id')
     operation_term_id = input.get('operation', {}).get('@id')
     animal_term_id = input.get('animal', {}).get('@id')
@@ -89,7 +89,7 @@ def _add_emission(cycle: dict, input: dict):
         emissions = ecoinventV3_emissions(ecoinventName)
         for emission_term_id, value in emissions:
             # log run on each emission so we know it did run
-            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id)
+            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id, **extra_logs)
             debugValues(cycle, model=MODEL, term=emission_term_id,
                         value=value,
                         coefficient=coefficient,
@@ -112,6 +112,10 @@ def _run_input(cycle: dict):
         mappings = get_input_mappings(MODEL, cycle, input)
         has_mappings = len(mappings) > 0
 
+        # grouping the inputs together in the logs
+        input_parent_term_id = input.get('parent', {}).get('@id')
+        extra_logs = {'input_group_id': input_parent_term_id} if input_parent_term_id else {}
+
         # skip input that has background emissions we have already gap-filled (model run before)
         has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
 
@@ -119,13 +123,14 @@ def _run_input(cycle: dict):
                         has_ecoinvent_mappings=has_mappings,
                         ecoinvent_mappings=';'.join([v[0] for v in mappings]),
                         has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
-                        input_value=input_value)
+                        input_value=input_value,
+                        **extra_logs)
 
         should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
-        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
+        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER, **extra_logs)
 
-        grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
-        log_missing_emissions_func(input_term_id, list(grouped_emissions.keys()))
+        grouped_emissions = reduce(_add_emission(cycle, input, **extra_logs), mappings, {}) if should_run else {}
+        log_missing_emissions_func(input_term_id, list(grouped_emissions.keys()), **extra_logs)
         return [
             _emission(term_id, value * input_value, input)
             for term_id, value in grouped_emissions.items()

hestia_earth/models/ecoinventV3AndEmberClimate/utils.py

@@ -19,4 +19,4 @@ def get_input_coefficient(model: str, cycle: dict, country_id: str, ecoinventNam
     # find the ratio for the country / year
     data = get_region_lookup_value(REGION_EMBER_SOURCES_LOOKUP_NAME, country_id, source_name, model=model)
     percentage = extract_grouped_data(data, str(year))
-    return safe_parse_float(percentage, 0) / 100
+    return safe_parse_float(percentage, default=0) / 100

hestia_earth/models/emepEea2019/utils.py

@@ -95,7 +95,8 @@ def group_fuel_inputs(inputs: list):
 
 def _get_emissions_factor(animal: dict, lookup_col: str) -> float:
     return safe_parse_float(
-        get_lookup_value(animal.get("term", {}), lookup_col, model=MODEL, term=animal.get("term", ""))
+        get_lookup_value(animal.get("term", {}), lookup_col, model=MODEL, term=animal.get("term", "")),
+        default=None
     )
 
 

hestia_earth/models/faostat2018/liveweightPerHead.py

@@ -55,7 +55,7 @@ def _product_value(product: dict, year: int, country_id: str):
     groupingFAO = get_animalProduct_lookup_value(MODEL, product_id, FAO_LOOKUP_COLUMN)
 
     data = get_region_lookup_value(LOOKUP_WEIGHT, country_id, groupingFAO, model=MODEL, term=TERM_ID)
-    average_carcass_weight = safe_parse_float(extract_grouped_data_closest_date(data, year), None)
+    average_carcass_weight = safe_parse_float(extract_grouped_data_closest_date(data, year), default=None)
     # average_carcass_weight is in hg, divide by 10 to go back to kg
     kg_carcass_weight = average_carcass_weight / 10 if average_carcass_weight else None