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

hestia_earth/models/ipcc2019/ch4ToAirAquacultureSystems.py

@@ -3,7 +3,7 @@ from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.tools import safe_parse_float, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-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.emission import _new_emission
 from . import MODEL
 
@@ -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.term 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):