hestia-earth-models 0.64.12__py3-none-any.whl → 0.64.13__py3-none-any.whl

hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -102,7 +102,7 @@ def _run(impact_assessment: dict):
         multiply_values([fresh_water, factor]),
         inputs_value
     ])
-    return _indicator(value)
+    return _indicator(value) if value is not None else None
 
 
 def _should_run(impact_assessment: dict):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandOccupation.py

@@ -83,7 +83,7 @@ def _run(impact_assessment: dict):
         multiply_values([land_occupation_m2_kg, factor]),
         inputs_value
     ])
-    return _indicator(value)
+    return _indicator(value) if value is not None else None
 
 
 def _should_run(impact_assessment: dict):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandTransformation.py

@@ -81,7 +81,7 @@ def _run(impact_assessment: dict):
         multiply_values([landTransformation, region_factor]),
         inputs_value
     ])
-    return _indicator(value)
+    return _indicator(value) if value is not None else None
 
 
 def _should_run(impact_assessment: dict):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsTotalLandUseEffects.py

@@ -59,8 +59,9 @@ def run(impact_assessment: dict):
     inputs_value = convert_value_from_cycle(
         product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
     )
+    value = sum_values([landUseEffects, inputs_value])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     landUseEffects=landUseEffects,
                     inputs_value=inputs_value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(sum_values([landUseEffects, inputs_value]))
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cml2001Baseline/eutrophicationPotentialExcludingFate.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cml2001Baseline/terrestrialAcidificationPotentialIncludingFateAverageEurope.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cml2001NonBaseline/eutrophicationPotentialIncludingFateAverageEurope.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cml2001NonBaseline/terrestrialAcidificationPotentialExcludingFate.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cycle/completeness/seed.py

@@ -15,7 +15,7 @@ REQUIREMENTS = {
     "Cycle": {
         "completeness.seed": "False",
         "inputs": [
-            {"@type": "Input", "value": "", "term.@id": ["seed", "saplings"]}
+            {"@type": "Input", "value": "", "term.@id": ["seed", "saplingsDepreciatedAmountPerCycle"]}
         ],
         "site": {
             "@type": "Site",
@@ -46,11 +46,13 @@ def run(cycle: dict):
 
     product = find_primary_product(cycle) or {}
     term_id = product.get('term', {}).get('@id')
-    has_saplings = find_term_match(cycle.get('inputs', []), 'saplings', None) and is_plantation(MODEL, None, term_id)
+    has_saplingsDepreciatedAmountPerCycle = find_term_match(cycle.get('inputs', []),
+                                                            'saplingsDepreciatedAmountPerCycle',
+                                                            None) and is_plantation(MODEL, None, term_id)
 
     logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
                     site_type_allowed=site_type_allowed,
                     has_seed=has_seed,
-                    has_saplings=has_saplings)
+                    has_saplingsDepreciatedAmountPerCycle=has_saplingsDepreciatedAmountPerCycle)
 
-    return all([site_type_allowed, has_seed or has_saplings])
+    return all([site_type_allowed, has_seed or has_saplingsDepreciatedAmountPerCycle])

hestia_earth/models/cycle/concentrateFeed.py

@@ -72,7 +72,7 @@ def _calculate_value(cycle: dict, product: dict, inputs: list, property_id: str,
     valid_values = [
         (value.get('property-value'), value.get('input-value'))
         for value in values
-        if all([value.get('property-value'), value.get('input-value')])
+        if all([value.get('property-value') is not None, value.get('input-value') is not None])
     ]
     ratio_inputs_with_props = len(valid_values) / len(inputs) if len(inputs) and len(valid_values) else 0
     min_ratio = _min_ratio(property_id)
@@ -106,15 +106,20 @@ def _calculate_default_value(cycle: dict, product: dict, inputs: list, property_
 
 def _calculate_N_value(cycle: dict, product: dict, inputs: list, property_id: str):
     term_id = product.get('term', {}).get('@id')
+
+    def fallback_value(input: dict):
+        value = get_node_property_value(
+            MODEL, input, 'crudeProteinContent', handle_percents=False, term=term_id, property=property_id
+        )
+        return value * 0.16 if value is not None else None
+
     values = [{
         'input-id': i.get('term', {}).get('@id'),
         'input-value': list_sum(i.get('value', [])),
         'property-id': property_id,
         'property-value': get_node_property_value(
             MODEL, i, property_id, handle_percents=False, term=term_id, property=property_id
-        ) or get_node_property_value(
-            MODEL, i, 'crudeProteinContent', default=0, handle_percents=False, term=term_id, property=property_id
-        ) * 0.16
+        ) or fallback_value(input=i)
     } for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
 

hestia_earth/models/cycle/endDate.py

@@ -8,6 +8,7 @@ assumed it ended on the 14th of the month.
 from hestia_earth.utils.date import is_in_months
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils import last_day_of_month
 from . import MODEL
 
 REQUIREMENTS = {
@@ -24,9 +25,17 @@ RETURNS = {
 MODEL_KEY = 'endDate'
 
 
+def _end_of_month(date: str):
+    year = int(date[0:4])
+    month = int(date[5:7])
+    return last_day_of_month(year, month).strftime('%Y-%m-%d')
+
+
 def _run(cycle: dict):
     endDate = cycle.get('endDate')
-    return f"{endDate}-14"
+    is_same_month = endDate[0:7] == cycle.get('startDate', '')[0:7]
+    # end of the month if same month as startDate
+    return _end_of_month(endDate) if is_same_month else f"{endDate}-14"
 
 
 def _should_run(cycle: dict):

hestia_earth/models/cycle/milkYield.py

@@ -87,15 +87,16 @@ def _run(cycle: dict, product: dict):
 
     live_animal_term_id = get_liveAnimal_term_id(product, model_key=MODEL_KEY)
     live_animal_node = find_term_match(cycle.get('animals', []), live_animal_term_id)
+    animal_value = live_animal_node.get('value', 0)
 
-    value = list_sum(product.get('value')) / cycleDuration / live_animal_node.get('value')
-    sd = list_sum(product.get('sd')) / cycleDuration / live_animal_node.get('value') if all([
+    value = list_sum(product.get('value')) / cycleDuration / animal_value
+    sd = list_sum(product.get('sd')) / cycleDuration / animal_value if all([
         list_sum(product.get('sd', [])) > 0
     ]) else None
-    min = list_sum(product.get('min')) / cycleDuration / live_animal_node.get('value') if all([
+    min = list_sum(product.get('min')) / cycleDuration / animal_value if all([
         list_sum(product.get('min', [])) > 0
     ]) else None
-    max = list_sum(product.get('max')) / cycleDuration / live_animal_node.get('value') if all([
+    max = list_sum(product.get('max')) / cycleDuration / animal_value if all([
         list_sum(product.get('max', [])) > 0
     ]) else None
 
@@ -136,7 +137,7 @@ def _should_run_product(cycle: dict, product: dict):
                     missing_milkYield_practice=missing_milkYield_practice)
 
     should_run = all([
-        has_product_value, has_live_animal_node_value, practice_id, missing_milkYield_practice
+        cycleDuration, has_product_value, has_live_animal_node_value, practice_id, missing_milkYield_practice
     ])
     logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
     return should_run

hestia_earth/models/cycle/startDate.py

@@ -36,22 +36,24 @@ def _run_by_cycleDuration(cycle: dict):
 
 def _should_run_by_cycleDuration(cycle: dict):
     has_endDate = cycle.get('endDate') is not None
-    has_day_precision = has_endDate and is_in_days(cycle.get('endDate'))
+    has_endDate_day_precision = has_endDate and is_in_days(cycle.get('endDate'))
     has_cycleDuration = cycle.get('cycleDuration') is not None
 
     logRequirements(cycle, model=MODEL, key=MODEL_KEY, by='cycleDuration',
                     has_endDate=has_endDate,
-                    has_day_precision=has_day_precision,
+                    has_endDate_day_precision=has_endDate_day_precision,
                     has_cycleDuration=has_cycleDuration)
 
-    should_run = all([has_endDate, has_day_precision, has_cycleDuration])
+    should_run = all([has_endDate, has_endDate_day_precision, has_cycleDuration])
     logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY, by='cycleDuration')
     return should_run
 
 
 def _run_by_startDate(cycle: dict):
     startDate = cycle.get('startDate')
-    return f"{startDate}-15"
+    is_same_month = startDate[0:7] == cycle.get('endDate', '')[0:7]
+    # start of the month if same month as end date
+    return f"{startDate}-01" if is_same_month else f"{startDate}-15"
 
 
 def _should_run_by_startDate(cycle: dict):

hestia_earth/models/edip2003/ozoneDepletionPotential.py

@@ -30,5 +30,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/emissionNotRelevant/__init__.py

@@ -4,9 +4,10 @@ Emission not relevant
 The emission is not relevant for this Site, Cycle, or Product.
 """
 from hestia_earth.schema import NodeType, TermTermType, EmissionMethodTier
+from hestia_earth.utils.emission import emission_is_in_system_boundary
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission, is_in_system_boundary
+from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.blank_node import _run_required
 from hestia_earth.models.utils.term import get_all_emission_terms
 
@@ -38,7 +39,7 @@ def _emission(term_id: str):
 def _should_run_emission(cycle: dict):
     def run(term_id: str):
         is_not_relevant = not _run_required(MODEL, {'@id': term_id, 'termType': TermTermType.EMISSION.value}, cycle)
-        in_system_boundary = is_in_system_boundary(term_id)
+        in_system_boundary = emission_is_in_system_boundary(term_id)
 
         should_run = all([is_not_relevant, in_system_boundary])
         if should_run:

hestia_earth/models/environmentalFootprintV3/freshwaterEcotoxicityPotentialCtue.py

@@ -1,5 +1,5 @@
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.pesticideAI import impact_lookup_value, impact_value_set_none
+from hestia_earth.models.utils.pesticideAI import impact_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -30,5 +30,4 @@ def _indicator(value: float):
 
 def run(impact_assessment: dict):
     value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['pesticideAI'])
-    should_run = any([value is not None, impact_value_set_none(impact_assessment)])
-    return _indicator(value) if should_run else None
+    return _indicator(value) if value is not None else None

hestia_earth/models/hestia/landCover.py

@@ -6,17 +6,18 @@ functionality of the Blonk model.
 """
 import math
 from collections import defaultdict
-
 from hestia_earth.schema import SiteSiteType, TermTermType
-from hestia_earth.utils.lookup import (download_lookup, get_table_value, column_name,
-                                       extract_grouped_data_closest_date, _is_missing_value, extract_grouped_data)
+from hestia_earth.utils.lookup import (
+    download_lookup, get_table_value, column_name,
+    extract_grouped_data_closest_date, _is_missing_value, extract_grouped_data
+)
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, to_precision, non_empty_value
 
-from hestia_earth.models.cycle.input.hestiaAggregatedData import MODEL_ID
 from hestia_earth.models.log import logRequirements, log_as_table, logShouldRun
+from hestia_earth.models.utils.management import _new_management
 from hestia_earth.models.utils.term import get_lookup_value
-from hestia_earth.models.hestia import MODEL
+from . import MODEL
 
 REQUIREMENTS = {
     "Site": {
@@ -46,9 +47,7 @@ RETURNS = {
         ],
         "value": "",
         "endDate": "",
-        "startDate": "",
-        "methodModel": "HESTIA",
-        "methodClassification": ["modelled using other measurements", "expert opinion"]
+        "startDate": ""
     }]
 }
 LOOKUPS = {
@@ -67,7 +66,8 @@ LOOKUPS = {
     "crop": ["cropGroupingFaostatArea", "IPCC_LAND_USE_CATEGORY"],
     "landCover": ["cropGroupingFaostatProduction", "FAOSTAT_LAND_AREA_CATEGORY"]
 }
-MODEL_KEY = "landCover"
+MODEL_KEY = 'landCover'
+
 LAND_AREA = LOOKUPS["region-faostatArea"][3]
 TOTAL_CROPLAND = "Cropland"
 ANNUAL_CROPLAND = "Arable land"
@@ -105,12 +105,20 @@ IPCC_LAND_USE_CATEGORY_PERENNIAL = "Perennial crops"
 OUTPUT_SIGNIFICANT_DIGITS = 3
 
 
+def _management(term_id: str, value: float, start_date: str, end_date: str):
+    node = _new_management(term_id, MODEL)
+    node['value'] = value
+    node['startDate'] = start_date
+    node['endDate'] = end_date
+    return node
+
+
 def _is_missing_or_none(value) -> bool:
     return value is None or _is_missing_value(value)
 
 
 def _safe_divide(numerator, denominator, default=0) -> float:
-    return default if denominator == 0 else numerator / denominator
+    return default if not denominator else numerator / denominator
 
 
 def site_area_sum_to_100(dict_of_percentages: dict):
@@ -432,22 +440,16 @@ def _run_make_management_nodes(existing_nodes: list, percentage_transformed_from
         for land_type, ratio in percentage_transformed_from.items()
     ]
     values = [v for v in values if v.get("land_management_key") not in existing_nodes_set]
-    nodes = [
-        {
-            "term": {
-                "@type": "Term",
-                "@id": LAND_USE_TERMS_FOR_TRANSFORMATION[value.get("land_type")][0],
-                "name": LAND_USE_TERMS_FOR_TRANSFORMATION[value.get("land_type")][1],
-                "termType": TermTermType.LANDCOVER.value
-            },
-            "value": value.get("percentage"),
-            "startDate": value.get("land_management_key")[1],
-            "endDate": value.get("land_management_key")[2],
-            "@type": "Management"
-        } for value in values
-    ]
 
-    return nodes
+    return [
+        _management(
+            term_id=LAND_USE_TERMS_FOR_TRANSFORMATION[value.get("land_type")][0],
+            value=value.get("percentage"),
+            start_date=value.get("land_management_key")[1],
+            end_date=value.get("land_management_key")[2]
+        )
+        for value in values
+    ]
 
 
 def get_ratio_of_expanded_area(country_id: str, fao_name: str, end_year: int) -> float:
@@ -696,7 +698,7 @@ def _should_run_historical_land_use_change_single_crop(
             sum_of_site_areas_is_100
         ]
     )
-    logShouldRun(site, MODEL_ID, term=term.get("@id"), should_run=should_run, key=MODEL_KEY)
+    logShouldRun(site, MODEL, term=term.get("@id"), should_run=should_run, key=MODEL_KEY)
 
     return should_run, site_area
 

hestia_earth/models/ipcc2013ExcludingFeedbacks/gwp100.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/ipcc2013IncludingFeedbacks/gwp100.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/ipcc2019/aboveGroundBiomass.py

@@ -7,11 +7,9 @@ from typing import Optional, Union
 from hestia_earth.schema import (
     MeasurementMethodClassification,
     MeasurementStatsDefinition,
-    SiteSiteType,
-    TermTermType
+    SiteSiteType
 )
 
-from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
@@ -24,8 +22,8 @@ from hestia_earth.models.utils.measurement import _new_measurement
 
 from . import MODEL
 from .biomass_utils import (
-    BiomassCategory, detect_land_cover_change, group_by_biomass_category, group_by_term_id, sample_biomass_equilibrium,
-    summarise_land_cover_nodes
+    BiomassCategory, get_valid_land_cover_terms, detect_land_cover_change, group_by_biomass_category, group_by_term_id,
+    sample_biomass_equilibrium, summarise_land_cover_nodes
 )
 
 
@@ -94,8 +92,6 @@ _ITERATIONS = 10000
 _METHOD_CLASSIFICATION = MeasurementMethodClassification.TIER_1_MODEL.value
 _STATS_DEFINITION = MeasurementStatsDefinition.SIMULATED.value
 
-_LAND_COVER_TERM_TYPE = TermTermType.LANDCOVER
-
 _EQUILIBRIUM_TRANSITION_PERIOD = 20
 _EXCLUDED_ECO_CLIMATE_ZONES = {EcoClimateZone.POLAR_MOIST, EcoClimateZone.POLAR_DRY}
 _EXCLUDED_SITE_TYPES = {
@@ -156,7 +152,7 @@ def _should_run(site: dict) -> tuple[bool, dict, dict]:
     site_type = site.get("siteType")
     eco_climate_zone = get_eco_climate_zone_value(site, as_enum=True)
 
-    land_cover = filter_list_term_type(site.get("management", []), _LAND_COVER_TERM_TYPE)
+    land_cover = get_valid_land_cover_terms(site)
 
     has_valid_site_type = site_type not in _EXCLUDED_SITE_TYPES
     has_valid_eco_climate_zone = all([

hestia_earth/models/ipcc2019/animal/milkYieldPerAnimal.py

@@ -51,9 +51,9 @@ def _run_animal(data: dict):
     animal = data.get('animal')
     value = data.get('value')
     practice_id = get_lookup_value(animal.get('term'), LOOKUPS['liveAnimal'][1])
-    return animal | {
+    return animal | ({
         'practices': merge_blank_nodes(animal.get('practices', []), [_practice(practice_id, value)])
-    }
+    } if practice_id else {})
 
 
 def _should_run(cycle: dict):

hestia_earth/models/ipcc2019/belowGroundBiomass.py

@@ -7,11 +7,9 @@ from typing import Optional, Union
 from hestia_earth.schema import (
     MeasurementMethodClassification,
     MeasurementStatsDefinition,
-    SiteSiteType,
-    TermTermType
+    SiteSiteType
 )
 
-from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
@@ -24,8 +22,8 @@ from hestia_earth.models.utils.measurement import _new_measurement
 
 from . import MODEL
 from .biomass_utils import (
-    BiomassCategory, detect_land_cover_change, group_by_biomass_category, sample_biomass_equilibrium,
-    summarise_land_cover_nodes
+    BiomassCategory, get_valid_land_cover_terms, detect_land_cover_change, group_by_biomass_category,
+    sample_biomass_equilibrium, summarise_land_cover_nodes
 )
 
 
@@ -81,8 +79,6 @@ _ITERATIONS = 10000
 _METHOD_CLASSIFICATION = MeasurementMethodClassification.TIER_1_MODEL.value
 _STATS_DEFINITION = MeasurementStatsDefinition.SIMULATED.value
 
-_LAND_COVER_TERM_TYPE = TermTermType.LANDCOVER
-
 _EQUILIBRIUM_TRANSITION_PERIOD = 20
 _EXCLUDED_ECO_CLIMATE_ZONES = {EcoClimateZone.POLAR_MOIST, EcoClimateZone.POLAR_DRY}
 _EXCLUDED_SITE_TYPES = {
@@ -149,7 +145,7 @@ def _should_run(site: dict) -> tuple[bool, dict, dict]:
     site_type = site.get("siteType")
     eco_climate_zone = get_eco_climate_zone_value(site, as_enum=True)
 
-    land_cover = filter_list_term_type(site.get("management", []), _LAND_COVER_TERM_TYPE)
+    land_cover = get_valid_land_cover_terms(site)
 
     has_valid_site_type = site_type not in _EXCLUDED_SITE_TYPES
     has_valid_eco_climate_zone = all([

hestia_earth/models/ipcc2019/biomass_utils.py

@@ -5,9 +5,12 @@ from numpy import random
 from numpy.typing import NDArray
 from typing import Callable, Optional, Union
 
+from hestia_earth.schema import TermTermType
 from hestia_earth.utils.blank_node import get_node_value
+from hestia_earth.utils.model import filter_list_term_type
 
 from hestia_earth.models.utils.array_builders import repeat_single, truncated_normal_1d
+from hestia_earth.models.utils.blank_node import validate_start_date_end_date
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_ecoClimateZone_lookup_grouped_value
 from hestia_earth.models.utils.term import get_lookup_value
 
@@ -404,3 +407,11 @@ _KWARGS_TO_SAMPLE_FUNC = {
     ("value", "error"): sample_plus_minus_error,
     ("value",): sample_constant
 }
+
+
+def get_valid_land_cover_terms(site: dict) -> list[dict]:
+    """Retrieve valid `landCover` nodes from a site's management."""
+    return [
+        node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+        if validate_start_date_end_date(node)
+    ]

hestia_earth/models/ipcc2019/ch4ToAirEntericFermentation.py

@@ -250,7 +250,7 @@ def _should_run(cycle: dict):
                 milk_yield=milk_yield,
                 enteric_factor=enteric_factor,
                 enteric_sd=enteric_sd,
-                default_values=default_values)
+                default_values=';'.join(map(str, default_values)))
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     term_type_animalFeed_complete=is_animalFeed_complete,

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -24,7 +24,7 @@ from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.array_builders import correlated_normal_2d, gen_seed
 from hestia_earth.models.utils.blank_node import (
     _gapfill_datestr, _get_datestr_format, DatestrGapfillMode, DatestrFormat, group_nodes_by_year, node_term_match,
-    split_node_by_dates
+    split_node_by_dates, validate_start_date_end_date
 )
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
@@ -408,7 +408,8 @@ def create_should_run_function(
         cycles = related_cycles(site)
 
         carbon_stock_measurements = [
-            node for node in site.get("measurements", []) if all([
+            node for node in site.get("measurements", [])
+            if all([
                 node_term_match(node, carbon_stock_term_id),
                 _has_valid_array_fields(node),
                 _has_valid_dates(node),
@@ -417,7 +418,10 @@ def create_should_run_function(
             ])
         ]
 
-        land_cover_nodes = filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+        land_cover_nodes = [
+            node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+            if validate_start_date_end_date(node)
+        ]
 
         seed = gen_seed(site)  # All cycles linked to the same site should be consistent
         rng = random.default_rng(seed)

hestia_earth/models/ipcc2019/n2OToAirExcretaDirect.py

@@ -10,7 +10,12 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "completeness.excreta": "True",
+        "or": {
+            "completeness.excreta": "True",
+            "inputs": [
+                {"@type": "Input", "term.termType": "excreta", "units": "kg N"}
+            ]
+        },
         "practices": [
             {"@type": "Practice", "value": "", "term.termType": "excretaManagement"}
         ]
@@ -36,26 +41,26 @@ def _emission(value: float):
     return emission
 
 
-def _run(excretaKgN: float, N2O_N_EF: float):
-    value = N2O_N_EF * excretaKgN * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+def _run(N_total: float, N2O_N_EF: float):
+    value = (N2O_N_EF or 0) * (N_total or 0) * get_atomic_conversion(Units.KG_N2O, Units.TO_N)
     return [_emission(value)]
 
 
 def _should_run(cycle: dict):
-    excretaKgN = total_excreta(cycle.get('inputs', []))
+    N_total = total_excreta(cycle.get('inputs', []))
     N2O_N_EF = get_lookup_factor(cycle.get('practices', []), LOOKUPS['excretaManagement'])
     term_type_complete = _is_term_type_complete(cycle, TermTermType.EXCRETA)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    excretaKgN=excretaKgN,
+                    N_total=N_total,
                     N2O_N_EF=N2O_N_EF,
                     term_type_excreta_complete=term_type_complete)
 
-    should_run = all([excretaKgN, N2O_N_EF])
+    should_run = all([N_total, N2O_N_EF]) or all([not N_total, term_type_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, excretaKgN, N2O_N_EF
+    return should_run, N_total, N2O_N_EF
 
 
 def run(cycle: dict):
-    should_run, excretaKgN, N2O_N_EF = _should_run(cycle)
-    return _run(excretaKgN, N2O_N_EF) if should_run else []
+    should_run, N_total, N2O_N_EF = _should_run(cycle)
+    return _run(N_total, N2O_N_EF) if should_run else []

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_1_utils.py

@@ -24,7 +24,7 @@ from hestia_earth.utils.blank_node import get_node_value
 from hestia_earth.models.utils.array_builders import gen_seed
 from hestia_earth.models.utils.blank_node import (
     cumulative_nodes_match, cumulative_nodes_lookup_match, cumulative_nodes_term_match,
-    node_lookup_match, node_term_match, group_nodes_by_year
+    node_lookup_match, node_term_match, group_nodes_by_year, validate_start_date_end_date
 )
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
 from hestia_earth.models.utils.descriptive_stats import calc_descriptive_stats
@@ -1209,8 +1209,14 @@ def _assign_ipcc_land_use_category(
     DECISION_TREE = _LAND_USE_CATEGORY_DECISION_TREE
     DEFAULT = IpccLandUseCategory.OTHER
 
-    land_cover_nodes = filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])
-    water_regime_nodes = filter_list_term_type(management_nodes, [TermTermType.WATERREGIME])
+    land_cover_nodes = [
+        node for node in filter_list_term_type(management_nodes, [TermTermType.LANDCOVER])
+        if validate_start_date_end_date(node)
+    ]
+    water_regime_nodes = [
+        node for node in filter_list_term_type(management_nodes, [TermTermType.WATERREGIME])
+        if validate_start_date_end_date(node)
+    ]
 
     has_irrigation = check_irrigation(water_regime_nodes)
     has_upland_rice = _has_upland_rice(land_cover_nodes)