hestia-earth-models 0.64.12__py3-none-any.whl → 0.64.14__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/materialAndSubstrate.py

@@ -0,0 +1,158 @@
+"""
+Material and Substrate
+
+This model gap-fills depreciated amount per Cycle from Site Infrastructure node.
+"""
+from typing import Union
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import download_lookup
+from hestia_earth.utils.tools import to_precision, flatten, list_sum
+from hestia_earth.utils.model import filter_list_term_type
+
+from hestia_earth.models.log import logShouldRun, logRequirements
+from hestia_earth.models.utils.constant import DAYS_IN_YEAR
+from hestia_earth.models.utils.input import _new_input
+from hestia_earth.models.utils.completeness import _is_term_type_incomplete
+from .import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.material": "False",
+        "cycleDuration": "",
+        "site": {
+            "@type": "Site",
+            "infrastructure": [
+                {
+                    "@type": "Infrastructure",
+                    "defaultLifespan": "",
+                    "inputs": [
+                        {
+                            "@type": "Input",
+                            "term.termType": ["material", "substrate"],
+                            "value": "",
+                            "lifespan": ""
+                        }
+                    ]
+                }
+            ]
+        }
+    }
+}
+RETURNS = {
+    "Input": [{
+        "value": "",
+        "min": "",
+        "max": "",
+        "sd": "",
+        "statsDefinition": ""
+    }]
+}
+LOOKUPS = {
+    "material": ""
+}
+MODEL_KEY = 'materialAndSubstrate'
+
+_ID_SUFFIX = "DepreciatedAmountPerCycle"
+_OPTIONAL_VALUES = ["min", "max", "sd"]
+_SIGNIFICANT_DIGITS = 5
+
+
+def _input(term_id: str, value: float, stats: dict) -> dict:
+    node = _new_input(term_id + _ID_SUFFIX)
+    node['value'] = [value]
+    return node | stats
+
+
+def _get_value(node: dict, field_name: str) -> float:
+    value = node.get(field_name)
+    return list_sum(value) if isinstance(value, list) else value
+
+
+def calculate_value(input_node: dict, field_name: str, cycle_duration: float) -> Union[float, None]:
+    lifespan = input_node.get("lifespan")
+    value = _get_value(node=input_node, field_name=field_name)
+    return (
+        to_precision(number=(value / (lifespan * DAYS_IN_YEAR)) * cycle_duration, digits=_SIGNIFICANT_DIGITS)
+        if value else None
+    )
+
+
+def _run_input(cycle: dict, input_node: dict) -> dict:
+    cycle_duration = cycle.get("cycleDuration")
+
+    value = calculate_value(
+        input_node=input_node,
+        field_name="value",
+        cycle_duration=cycle_duration
+    )
+
+    optional_gap_filled_values = {
+        field_name: [
+            calculate_value(input_node=input_node, field_name=field_name, cycle_duration=cycle_duration)
+        ]
+        for field_name in _OPTIONAL_VALUES if field_name in input_node
+    }
+    if "statsDefinition" in input_node:
+        optional_gap_filled_values["statsDefinition"] = input_node["statsDefinition"]
+
+    return _input(input_node.get('term', {}).get('@id'), value, optional_gap_filled_values)
+
+
+def _has_depreciated_term(term: dict):
+    lookup = download_lookup(f"{term.get('termType')}.csv")
+    return term.get('@id') + _ID_SUFFIX in list(lookup.termid)
+
+
+def _should_run_input(cycle: dict, input_node: dict) -> bool:
+    term = input_node.get('term', {})
+    term_id = term.get('@id')
+    has_lifespan = input_node.get('lifespan', 0) > 0
+    has_valid_value = _get_value(input_node, 'value') > 0
+    has_depreciated_term = _has_depreciated_term(term)
+
+    should_run = all([
+        has_depreciated_term,
+        has_valid_value,
+        has_lifespan
+    ])
+
+    logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                    has_valid_value=has_valid_value,
+                    has_lifespan=has_lifespan,
+                    has_depreciated_term=has_depreciated_term)
+    logShouldRun(input_node, MODEL, term_id, should_run, model_key=MODEL_KEY)
+    return should_run
+
+
+def _should_run_infrastructure(cycle: dict, infra_node: dict) -> tuple[bool, list]:
+    inputs = filter_list_term_type(infra_node.get('inputs', []), [TermTermType.MATERIAL, TermTermType.SUBSTRATE])
+    inputs = [
+        i | {
+            'lifespan': i.get('lifespan') or infra_node.get('defaultLifespan')
+        }
+        for i in inputs
+    ]
+    return [i for i in inputs if _should_run_input(cycle, i)]
+
+
+def _should_run(cycle: dict) -> tuple[bool, list]:
+    inputs = flatten([
+        _should_run_infrastructure(cycle, i)
+        for i in cycle.get('site', {}).get('infrastructure', [])
+    ])
+    has_material_inputs = len(inputs) > 0
+    cycle_duration = cycle.get('cycleDuration')
+    is_incomplete = _is_term_type_incomplete(cycle, TermTermType.MATERIAL)
+
+    logRequirements(cycle, model=MODEL, term=None, model_key=MODEL_KEY,
+                    term_type_material_incomplete=is_incomplete,
+                    has_material_inputs=has_material_inputs)
+
+    should_run = all([is_incomplete, has_material_inputs, cycle_duration])
+    logShouldRun(cycle, MODEL, None, should_run, model_key=MODEL_KEY)
+    return should_run, inputs
+
+
+def run(cycle: dict):
+    should_run, inputs = _should_run(cycle)
+    return [_run_input(cycle, i) for i in inputs] if should_run else []

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([