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

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',

hestia_earth/models/faostat2018/seed.py

@@ -43,8 +43,9 @@ def _input(value: float, sd: float):
 def _run_product(product: dict):
     term = product.get('term', {})
     product_value = list_sum(product.get('value', []))
-    value = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][0], model=MODEL, term=TERM_ID)) * product_value
-    sd = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][1], model=MODEL, term=TERM_ID))
+    value = safe_parse_float(
+        get_lookup_value(term, LOOKUPS['crop'][0], model=MODEL, term=TERM_ID), default=0) * product_value
+    sd = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][1], model=MODEL, term=TERM_ID), default=0)
     return value, sd
 
 

hestia_earth/models/faostat2018/utils.py

@@ -34,10 +34,10 @@ def product_equivalent_value(product: dict, year: int, country: str):
         return None
 
     quantity_values = get_region_lookup_value(f"{LOOKUP_PREFIX}-productionQuantity.csv", country, grouping)
-    quantity = safe_parse_float(extract_grouped_data_closest_date(quantity_values, year))
+    quantity = safe_parse_float(extract_grouped_data_closest_date(quantity_values, year), default=0)
 
     head_values = get_region_lookup_value(f"{LOOKUP_PREFIX}-head.csv", country, grouping)
-    head = safe_parse_float(extract_grouped_data_closest_date(head_values, year))
+    head = safe_parse_float(extract_grouped_data_closest_date(head_values, year), default=0)
 
     # quantity is in Tonnes
     value = quantity * 1000 / head if head > 0 else 0
@@ -58,7 +58,7 @@ def product_equivalent_value(product: dict, year: int, country: str):
 def _split_delta(table_value: str, start_year: int, end_year: int):
     start_value = extract_grouped_data_closest_date(table_value, start_year)
     end_value = extract_grouped_data_closest_date(table_value, end_year)
-    return safe_parse_float(end_value) - safe_parse_float(start_value) if all([
+    return safe_parse_float(end_value, default=None) - safe_parse_float(start_value, default=None) if all([
         start_value is not None, end_value is not None
     ]) else None
 
@@ -69,7 +69,8 @@ def get_sum_of_columns(country: str, year: int, columns_list: list) -> float:
             extract_grouped_data_closest_date(
                 data=get_region_lookup_value(FAOSTAT_AREA_LOOKUP, country, col, model=MODEL),
                 year=year
-            )
+            ),
+            default=0
         ) for col in columns_list]
     )
 
@@ -128,7 +129,7 @@ def get_change_in_harvested_area_for_crop(country_id: str, crop_name: str, start
     lookup_name = 'region-crop-cropGroupingFaostatProduction-areaHarvested.csv'
     value = get_region_lookup_value(lookup_name, country_id, crop_name)
     return safe_parse_float(
-        extract_grouped_data_closest_date(value, start_year)
+        extract_grouped_data_closest_date(value, start_year), default=0
     ) if end_year == 0 or end_year == start_year else _split_delta(value, start_year, end_year)
 
 

hestia_earth/models/geospatialDatabase/altitude.py

@@ -42,7 +42,8 @@ def _measurement(site: dict, value: float):
 
 def _run(site: dict):
     value = download(TERM_ID, site, EE_PARAMS)
-    return [_measurement(site, safe_parse_float(value))] if value is not None else []
+    value = safe_parse_float(value, default=None)
+    return [_measurement(site, value)] if value is not None else []
 
 
 def _should_run(site: dict):

hestia_earth/models/geospatialDatabase/drainageClass.py

@@ -40,7 +40,8 @@ def _measurement(site: dict, value: float):
 
 def _run(site: dict):
     value = download(TERM_ID, site, EE_PARAMS)
-    return [_measurement(site, safe_parse_float(value))] if value is not None else []
+    value = safe_parse_float(value, default=None)
+    return [_measurement(site, value)] if value is not None else []
 
 
 def _should_run(site: dict):

hestia_earth/models/geospatialDatabase/organicCarbonPerKgSoil.py

@@ -69,8 +69,9 @@ def _measurement(site: dict, value: int, depthUpper: int, depthLower: int):
 
 def _run_depths(site: dict, params: dict):
     value = download(TERM_ID, site, params)
+    value = safe_parse_float(value, default=None)
     return None if value is None else (
-        _measurement(site, safe_parse_float(value) * 10, params.get('depthUpper'), params.get('depthLower'))
+        _measurement(site, value * 10, params.get('depthUpper'), params.get('depthLower'))
     )
 
 

hestia_earth/models/geospatialDatabase/totalNitrogenPerKgSoil.py

@@ -69,8 +69,9 @@ def _measurement(site: dict, value: int, depthUpper: int, depthLower: int):
 
 def _run_depths(site: dict, params: dict):
     value = download(TERM_ID, site, params)
+    value = safe_parse_float(value, default=None)
     return None if value is None else (
-        _measurement(site, safe_parse_float(value), params.get('depthUpper'), params.get('depthLower'))
+        _measurement(site, value, params.get('depthUpper'), params.get('depthLower'))
     )
 
 

hestia_earth/models/geospatialDatabase/totalPhosphorusPerKgSoil.py

@@ -44,7 +44,8 @@ def _measurement(site: dict, value: float):
 
 def _run(site: dict):
     value = download(TERM_ID, site, EE_PARAMS)
-    return [_measurement(site, safe_parse_float(value))] if value is not None else []
+    value = safe_parse_float(value, default=None)
+    return [_measurement(site, value)] if value is not None else []
 
 
 def _should_run(site: dict):

hestia_earth/models/geospatialDatabase/utils.py

@@ -111,7 +111,7 @@ def _is_below_max_size(term: str, site: dict) -> bool:
     current_size = _cached_value(site, CACHE_AREA_SIZE) or get_area_size(site)
     if current_size is not None:
         logRequirements(site, model=MODEL, term=term,
-                        current_size=int(current_size),
+                        current_size=round(float(current_size), 5),
                         max_area_size=MAX_AREA_SIZE)
         return current_size <= MAX_AREA_SIZE
     return True

hestia_earth/models/globalCropWaterModel2008/rootingDepth.py

@@ -60,7 +60,7 @@ def _get_value(cycle: dict, term: dict, irrigation_ids: list):
     else:
         column = 'Rooting_depth_average_m'
 
-    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, column), None)
+    return safe_parse_float(get_crop_lookup_value(MODEL, TERM_ID, term_id, column), default=None)
 
 
 def _should_run_product(cycle: dict):

hestia_earth/models/hestia/brackishWater.py

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

hestia_earth/models/hestia/default_emissions.py

@@ -0,0 +1,105 @@
+from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.utils.tools import flatten, safe_parse_float
+from hestia_earth.utils.emission import cycle_emissions_in_system_boundary
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils import _omit
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
+from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.input import unique_background_inputs
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "inputs": [{
+            "@type": "Input",
+            "value": "> 0",
+            "none": {
+                "impactAssessment": {"@type": "ImpactAssessment"},
+                "fromCycle": "True",
+                "producedInCycle": "True"
+            }
+        }]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "methodTier": "background"
+    }]
+}
+LOOKUPS = {
+    "organicFertiliser": "backgroundEmissionsResourceUseDefaultValue"
+}
+MODEL_KEY = 'default_emissions'
+TIER = EmissionMethodTier.BACKGROUND.value
+
+
+def _emission(term_id: str, value: float, input: dict):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['inputs'] = [input]
+    emission['methodTier'] = TIER
+    return emission
+
+
+def _default_value(input: dict):
+    return safe_parse_float(get_lookup_value(input.get('term', {}), LOOKUPS['organicFertiliser']), default=None)
+
+
+def _run_input(cycle: dict):
+    required_emission_term_ids = [
+        id for id in cycle_emissions_in_system_boundary(cycle)
+        if id.endswith('InputsProduction')
+    ]
+
+    def run(input: dict):
+        input_term = input.get('input').get('term')
+        term_id = input_term.get('@id')
+        value = input.get('default-value-from-lookup')
+
+        for emission_id in required_emission_term_ids:
+            logShouldRun(cycle, MODEL, term_id, True, methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)
+
+        return [
+            _emission(term_id, value, input_term) for term_id in required_emission_term_ids
+        ]
+
+    return run
+
+
+def _should_run(cycle: dict):
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
+
+    inputs = [
+        input | {
+            'default-value-from-lookup': _default_value(input['input']),
+            'no-gap-filled-background-emissions': no_gap_filled_background_emissions_func(input['input'])
+        }
+        for input in unique_background_inputs(cycle)
+    ]
+    valid_inputs = [
+        input for input in inputs
+        if all([
+            input.get('default-value-from-lookup') is not None,
+            input.get('no-gap-filled-background-emissions')
+        ])
+    ]
+
+    should_run = all([bool(valid_inputs)])
+
+    for input in inputs:
+        term_id = input.get('input').get('term', {}).get('@id')
+
+        logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                        **_omit(input, ['input', 'input-value']))
+        logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
+
+    return should_run, valid_inputs
+
+
+def run(cycle: dict):
+    should_run, grouped_inputs = _should_run(cycle)
+    return flatten(map(_run_input(cycle), grouped_inputs)) if should_run else []

hestia_earth/models/hestia/default_resourceUse.py

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

hestia_earth/models/hestia/freshWater.py

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

hestia_earth/models/hestia/inorganicFertiliser.py

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

hestia_earth/models/hestia/landCover.py

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

hestia_earth/models/hestia/landTransformation100YearAverageDuringCycle.py

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

hestia_earth/models/hestia/landTransformation20YearAverageDuringCycle.py

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

hestia_earth/models/hestia/liveAnimal.py

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

hestia_earth/models/hestia/management.py

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

hestia_earth/models/hestia/netPrimaryProduction.py

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

hestia_earth/models/hestia/organicCarbonPerHa.py

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

hestia_earth/models/hestia/salineWater.py

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