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

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

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

hestia_earth_models-0.73.0/hestia_earth/models/akagiEtAl2011/__init__.py

@@ -0,0 +1,13 @@
+from os.path import dirname, abspath
+import sys
+from importlib import import_module
+
+from hestia_earth.models.utils.blank_node import run_if_required
+
+CURRENT_DIR = dirname(abspath(__file__)) + '/'
+sys.path.append(CURRENT_DIR)
+MODEL = 'akagiEtAl2011'
+PKG = '.'.join(['hestia_earth', 'models', MODEL])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth_models-0.73.0/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-0.73.0/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-0.73.0/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-0.73.0/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-0.73.0/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-0.73.0/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-0.72.2 → hestia_earth_models-0.73.0}/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-0.72.2 → hestia_earth_models-0.73.0}/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-0.72.2 → hestia_earth_models-0.73.0}/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-0.72.2 → hestia_earth_models-0.73.0}/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-0.72.2 → hestia_earth_models-0.73.0}/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-0.72.2 → hestia_earth_models-0.73.0}/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-0.72.2 → hestia_earth_models-0.73.0}/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-0.73.0/hestia_earth/models/cycle/product/price.py

@@ -0,0 +1,74 @@
+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
+from .utils import lookup_share
+from .. import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "products": [{
+            "@type": "Product",
+            "optional": {
+                "revenue": "0"
+            },
+            "none": {
+                "price": ""
+            }
+        }]
+    }
+}
+RETURNS = {
+    "Product": [{
+        "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'
+
+
+def _product(product: dict, value: float):
+    # currency is required, but do not override if present
+    # currency in lookup table is set to USD
+    return {'currency': DEFAULT_CURRENCY, **product, MODEL_KEY: value}
+
+
+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',
+                    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 = 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 run(cycle: dict):
+    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(cycle, p) else None
+        ) for p in products
+    ])

{hestia_earth_models-0.72.2 → hestia_earth_models-0.73.0}/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-0.73.0/hestia_earth/models/dammgen2009/noxToAirExcreta.py

@@ -0,0 +1,53 @@
+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 . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "emissions": [
+            {"@type": "Emission", "value": "", "term.@id": "n2OToAirExcretaDirect"}
+        ]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1"
+    }]
+}
+TERM_ID = 'noxToAirExcreta'
+TIER = EmissionMethodTier.TIER_1.value
+N2O_TERM_ID = 'n2OToAirExcretaDirect'
+
+
+def _emission(value: float):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = TIER
+    return emission
+
+
+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):
+    n2o = find_term_match(cycle.get('emissions', []), N2O_TERM_ID)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID, has_n2o=n2o is not None)
+
+    should_run = all([n2o])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run, n2o
+
+
+def run(cycle: dict):
+    should_run, n2o = _should_run(cycle)
+    return _run(n2o) if should_run else []

{hestia_earth_models-0.72.2 → hestia_earth_models-0.73.0}/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-0.72.2 → hestia_earth_models-0.73.0}/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-0.72.2 → hestia_earth_models-0.73.0}/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-0.72.2 → hestia_earth_models-0.73.0}/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
 

{hestia_earth_models-0.72.2 → hestia_earth_models-0.73.0}/hestia_earth/models/faostat2018/product/price.py

@@ -65,7 +65,7 @@ def _lookup_data(
     def get_data(country_id):
         data = get_region_lookup_value(lookup_name, country_id, grouping, model=MODEL, term=term_id, key=MODEL_KEY)
         price = extract_grouped_data(data, str(year)) or extract_grouped_data(data, 'Average_price_per_tonne')
-        return safe_parse_float(price, None)
+        return safe_parse_float(price, default=None)
 
     # try get country data first, falls back to region data
     country_id = country.get('@id')
@@ -141,7 +141,7 @@ def _run_by_country(cycle: dict, product: dict, country: dict, year: int = None)
 
     # if units is number instead of kg, need to convert to number first
     conversion_to_number = safe_parse_float(
-        get_region_lookup_value(LOOKUP_UNITS_NUMBER.get(term_type), country.get('@id'), grouping), 1
+        get_region_lookup_value(LOOKUP_UNITS_NUMBER.get(term_type), country.get('@id'), grouping), default=1
     ) if term_units == Units.NUMBER.value else 1
 
     logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by='country',