hestia-earth-models 0.74.3__py3-none-any.whl → 0.74.5__py3-none-any.whl

hestia_earth/models/hestia/resourceUse_utils.py

@@ -1,16 +1,13 @@
 from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.tools import to_precision
+from hestia_earth.utils.tools import to_precision, list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.blank_node import _gapfill_datestr, DatestrGapfillMode, DatestrFormat, _str_dates_match
 from hestia_earth.models.utils.impact_assessment import get_site
 from hestia_earth.models.utils.indicator import _new_indicator
-from .utils import (
-    LAND_USE_TERMS_FOR_TRANSFORMATION,
-    crop_ipcc_land_use_category,
-)
+from .utils import LAND_USE_TERMS_FOR_TRANSFORMATION, crop_ipcc_land_use_category
 from . import MODEL
 
 _MAXIMUM_OFFSET_DAYS = 365 * 2
@@ -41,7 +38,7 @@ def _gap_filled_date_obj(date_str: str) -> datetime:
     )
 
 
-def _find_closest_node(
+def _find_closest_node_date(
     ia_date_str: str,
     management_nodes: list,
     historic_date_offset: int,
@@ -62,32 +59,22 @@ def _find_closest_node(
     return filtered_dates[min(filtered_dates.keys())] if filtered_dates else ""
 
 
-def should_run(
-    impact_assessment: dict,
-    site: dict,
-    term_id: str,
-    historic_date_offset: int
-) -> tuple[bool, dict, str, str]:
-    relevant_emission_resource_use = [
-        node for node in impact_assessment.get("emissionsResourceUse", [])
-        if node.get("term", {}).get("@id", "") == _RESOURCE_USE_TERM_ID and node.get("value", -1) >= 0
-    ]
+def should_run(impact_assessment: dict, term_id: str, historic_date_offset: int) -> tuple[bool, dict, str, str]:
+    cycle = impact_assessment.get('cycle', {})
+    has_otherSites = len(cycle.get('otherSites') or []) != 0
+
+    site = get_site(impact_assessment)
     filtered_management_nodes = [
         node for node in site.get("management", [])
-        if node.get("value", -1) >= 0 and node.get("term", {}).get("termType", "") == TermTermType.LANDCOVER.value
+        if node.get("value", -1) >= 0 and node.get("term", {}).get("termType") == TermTermType.LANDCOVER.value
     ]
-    land_occupation_during_cycle_found = any(
-        node.get("term", {}).get("@id") in
-        {node.get("landCover", {}).get("@id") for node in relevant_emission_resource_use}
-        for node in filtered_management_nodes
-    )
     match_mode = (
         DatestrGapfillMode.START if impact_assessment.get("cycle", {}).get("aggregated") is True
         else DatestrGapfillMode.END
     )
     match_date = "startDate" if match_mode == DatestrGapfillMode.START else "endDate"
 
-    closest_date = _find_closest_node(
+    closest_date = _find_closest_node_date(
         ia_date_str=impact_assessment.get(match_date, ""),
         management_nodes=filtered_management_nodes,
         historic_date_offset=historic_date_offset,
@@ -104,98 +91,53 @@ def should_run(
         None
     )
     current_node = filtered_management_nodes.pop(current_node_index) if current_node_index is not None else None
+    landCover_term_id = (current_node or {}).get('term', {}).get('@id')
 
-    logRequirements(impact_assessment, model=MODEL, term=term_id,
-                    closest_end_date=closest_end_date,
-                    closest_start_date=closest_start_date,
-                    has_landOccupationDuringCycle=land_occupation_during_cycle_found,
-                    landCover_term_id=(current_node or {}).get('term', {}).get('@id'))
-
-    should_run_result = all([
-        relevant_emission_resource_use,
-        land_occupation_during_cycle_found,
-        current_node,
-        closest_end_date or closest_start_date
-    ])
-    logShouldRun(impact_assessment, MODEL, term=term_id, should_run=should_run_result)
-
-    return should_run_result, current_node, closest_end_date, closest_start_date
+    prior_management_nodes = [
+        node for node in filtered_management_nodes
+        if _str_dates_match(node.get("endDate", ""), closest_end_date) or
+        _str_dates_match(node.get("startDate", ""), closest_start_date)
+    ]
 
+    ipcc_land_use_category = crop_ipcc_land_use_category(landCover_term_id)
 
-def _get_land_occupation_for_land_use_type(impact_assessment: dict, ipcc_land_use_category: str) -> float:
-    """
-    Returns the sum of all land occupation for the specified land_use_category.
-    """
-    return sum(
-        node.get("value", 0) for node in impact_assessment.get("emissionsResourceUse", [])
+    total_landOccupationDuringCycle = list_sum([
+        node.get("value") for node in impact_assessment.get("emissionsResourceUse", [])
         if node.get("term", {}).get("@id", "") == _RESOURCE_USE_TERM_ID
         and crop_ipcc_land_use_category(node.get("landCover", {}).get("@id", "")) == ipcc_land_use_category
-    )
-
-
-def _calculate_indicator_value(
-    impact_assessment: dict,
-    term_id: str,
-    management_nodes: list,
-    ipcc_land_use_category: str,
-    previous_land_cover_id: str,
-    historic_date_offset: int
-) -> float:
-    """
-    Land transformation from [land type] previous management nodes
-     = (Land occupation, during Cycle * Historic Site Percentage Area [land type] / 100) / HISTORIC_DATE_OFFSET
-    """
-    land_occupation_for_cycle = _get_land_occupation_for_land_use_type(
-        impact_assessment=impact_assessment,
-        ipcc_land_use_category=ipcc_land_use_category
-    )
-    historical_land_use = sum(
-        node.get("value", 0) for node in management_nodes
-        if node.get("term", {}).get("@id", "") == previous_land_cover_id
-    )
-
-    debugValues(impact_assessment, model=MODEL, term=term_id,
-                ipcc_land_use_category=ipcc_land_use_category,
-                land_occupation_for_cycle=land_occupation_for_cycle,
-                historical_land_use=historical_land_use,
-                historic_date_offset=historic_date_offset)
+    ], default=None)
 
-    return ((land_occupation_for_cycle * historical_land_use) / 100) / historic_date_offset
+    indicators = [
+        {
+            'landCover-id': landCover_term_id,
+            'previous-landCover-id': previous_land_cover_id,
+            'landOccupationDuringCycle': total_landOccupationDuringCycle,
+            'historical-landUse-change': list_sum([
+                node.get("value") for node in prior_management_nodes
+                if node.get("term", {}).get("@id") == previous_land_cover_id
+            ], default=None),
+        }
+        for previous_land_cover_id in [t[0] for t in LAND_USE_TERMS_FOR_TRANSFORMATION.values()]
+    ] if landCover_term_id else []
+    valid_indicators = [indicator for indicator in indicators if indicator['historical-landUse-change'] is not None]
 
+    logRequirements(impact_assessment, model=MODEL, term=term_id,
+                    has_otherSites=has_otherSites,
+                    closest_end_date=closest_end_date,
+                    closest_start_date=closest_start_date,
+                    landCover_term_id=landCover_term_id,
+                    ipcc_land_use_category=ipcc_land_use_category,
+                    indicators=log_as_table(indicators))
 
-def _run_calculate_transformation(
-    term_id: str,
-    current_node: dict,
-    closest_end_date: str,
-    closest_start_date: str,
-    impact_assessment: dict,
-    site: dict,
-    historic_date_offset: int
-) -> list:
-    """
-    Calculate land transformation for all land use categories.
-    """
-    indicators = [
-        _new_indicator_with_value(
-            term_id=term_id,
-            land_cover_id=current_node.get("term", {}).get("@id"),
-            previous_land_cover_id=previous_land_cover_id,
-            value=_calculate_indicator_value(
-                impact_assessment=impact_assessment,
-                term_id=term_id,
-                management_nodes=[
-                    node for node in site.get("management", [])
-                    if _str_dates_match(node.get("endDate", ""), closest_end_date) or
-                    _str_dates_match(node.get("startDate", ""), closest_start_date)
-                ],
-                ipcc_land_use_category=crop_ipcc_land_use_category(current_node.get("term", {}).get("@id", "")),
-                previous_land_cover_id=previous_land_cover_id,
-                historic_date_offset=historic_date_offset
-            )
-        ) for previous_land_cover_id in [t[0] for t in LAND_USE_TERMS_FOR_TRANSFORMATION.values()]
-    ]
+    should_run_result = all([
+        not has_otherSites,
+        ipcc_land_use_category,
+        total_landOccupationDuringCycle is not None,
+        valid_indicators
+    ])
+    logShouldRun(impact_assessment, MODEL, term=term_id, should_run=should_run_result)
 
-    return indicators
+    return should_run_result, valid_indicators
 
 
 def run_resource_use(
@@ -203,19 +145,16 @@ def run_resource_use(
     historic_date_offset: int,
     term_id: str
 ) -> list:
-    site = get_site(impact_assessment)
-    _should_run, current_node, closest_end_date, closest_start_date = should_run(
+    _should_run, indicators = should_run(
         impact_assessment=impact_assessment,
-        site=site,
         term_id=term_id,
         historic_date_offset=historic_date_offset
     )
-    return _run_calculate_transformation(
-        impact_assessment=impact_assessment,
-        site=site,
-        term_id=term_id,
-        current_node=current_node,
-        closest_end_date=closest_end_date,
-        closest_start_date=closest_start_date,
-        historic_date_offset=historic_date_offset
-    ) if _should_run else []
+    return [
+        _new_indicator_with_value(
+            term_id=term_id,
+            land_cover_id=i['landCover-id'],
+            previous_land_cover_id=i['previous-landCover-id'],
+            value=(i['landOccupationDuringCycle'] * i['historical-landUse-change'] / 100) / historic_date_offset
+        ) for i in indicators
+    ] if _should_run else []

hestia_earth/models/hestia/waterSalinity.py

@@ -4,6 +4,7 @@ from hestia_earth.utils.tools import safe_parse_float, list_average, non_empty_l
 from hestia_earth.utils.blank_node import group_by_keys
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import is_from_model
 from hestia_earth.models.utils.measurement import _new_measurement
 from hestia_earth.models.utils.site import related_cycles
 from hestia_earth.models.utils.term import get_lookup_value
@@ -11,14 +12,21 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Site": {
-        "related": {
-            "Cycle": {
-                "@type": "Cycle",
-                "products": [{
-                    "@type": "Product",
-                    "primary": "True",
-                    "term.termType": "liveAquaticSpecies"
-                }]
+        "optional": {
+            "measurements": [{
+                "@type": "Measurement",
+                "term.@id": ["brackishWater", "salineWater", "freshWater"],
+                "value": "true"
+            }],
+            "related": {
+                "Cycle": {
+                    "@type": "Cycle",
+                    "products": [{
+                        "@type": "Product",
+                        "primary": "True",
+                        "term.termType": "liveAquaticSpecies"
+                    }]
+                }
             }
         }
     }
@@ -35,19 +43,26 @@ LOOKUPS = {
     "liveAquaticSpecies": "defaultSalinity"
 }
 TERM_ID = 'waterSalinity'
+_MEASUREMENT_TERM_IDS = ["brackishWater", "salineWater", "freshWater"]
+_DEFAULT_SALINITY = {
+    'freshWater': 0,
+    'brackishWater': 5000,
+    'salineWater': 32000
+}
 
 
 def _measurement(value: float, start_date: str = None, end_date: str = None):
     data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [value]
-    data['endDate'] = end_date
     if start_date:
         data['startDate'] = start_date
+    if end_date:
+        data['endDate'] = end_date
     data['methodClassification'] = MeasurementMethodClassification.EXPERT_OPINION.value
     return data if value is not None else None
 
 
-def _should_run(site: dict):
+def _should_run_by_products(site: dict):
     cycles = related_cycles(site)
     relevant_products = [
         {
@@ -72,8 +87,8 @@ def _should_run(site: dict):
     return should_run, relevant_products
 
 
-def run(site: dict):
-    should_run, values = _should_run(site)
+def _run_by_products(site: dict):
+    should_run, values = _should_run_by_products(site)
     grouped_values = group_by_keys(values, ['start-date', 'end-date'])
     return non_empty_list([
         _measurement(
@@ -83,3 +98,33 @@ def run(site: dict):
         )
         for value in grouped_values.values()
     ]) if should_run else []
+
+
+def _should_run_by_measurement(site: dict):
+    measurements = [
+        m for m in site.get('measurements', [])
+        if all([
+            m.get('term', {}).get('@id') in _MEASUREMENT_TERM_IDS,
+            not is_from_model(m),
+            m.get('value')
+        ])
+    ]
+
+    logRequirements(site, model=MODEL, term=TERM_ID,
+                    existing_measurements=';'.join([m.get('term', {}).get('@id') for m in measurements]))
+
+    should_run = all([measurements])
+    logShouldRun(site, MODEL, TERM_ID, should_run)
+    return should_run, measurements
+
+
+def _run_by_measurement(site: dict):
+    should_run, measurements = _should_run_by_measurement(site)
+    return [
+        _measurement(_DEFAULT_SALINITY[m.get('term', {}).get('@id')], m.get('startDate'), m.get('endDate'))
+        for m in measurements
+    ] if should_run else []
+
+
+def run(site: dict):
+    return _run_by_measurement(site) or _run_by_products(site)

hestia_earth/models/impact_assessment/post_checks/__init__.py

@@ -2,14 +2,15 @@ from os.path import dirname, abspath
 import sys
 
 from hestia_earth.models.utils import _run_in_serie
-from . import cycle, site
+from . import cycle, site, remove_cache_fields
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
 
 MODELS = [
     cycle.run,
-    site.run
+    site.run,
+    remove_cache_fields.run
 ]
 
 

hestia_earth/models/impact_assessment/post_checks/remove_cache_fields.py

@@ -0,0 +1,9 @@
+def run(impact: dict):
+    cache_keys = [key for key in impact.keys() if key.startswith('cache')]
+    for key in cache_keys:
+        del impact[key]
+        try:
+            impact['added'].remove(key)
+        except Exception:
+            continue
+    return impact

hestia_earth/models/impact_assessment/pre_checks/cache_emissionsResourceUse.py

@@ -0,0 +1,21 @@
+from hestia_earth.utils.blank_node import group_by_keys, get_node_value, ArrayTreatment
+from hestia_earth.utils.tools import non_empty_list
+
+_GROUP_KEYS = ['term', 'methodModel', 'inputs', 'operation', 'country', 'region']
+
+
+def _grouped_blank_node(blank_nodes: list):
+    blank_node = {
+        key: blank_nodes[0].get(key) for key in _GROUP_KEYS if blank_nodes[0].get(key)
+    } | {
+        'value': non_empty_list([v.get('value') for v in blank_nodes])
+    }
+    value = get_node_value(blank_node, default_array_treatment=ArrayTreatment.SUM)
+    return blank_node | {'value': value}
+
+
+def run(impact: dict):
+    blank_nodes = impact.get('emissionsResourceUse', [])
+    grouped_blank_nodes = group_by_keys(blank_nodes, _GROUP_KEYS)
+    grouped_blank_nodes = [_grouped_blank_node(value) for value in grouped_blank_nodes.values()]
+    return grouped_blank_nodes

hestia_earth/models/impact_assessment/pre_checks/cycle.py

@@ -23,6 +23,11 @@ def _run(impact: dict):
     site = _load_calculated_node(cycle.get('site', {}), SchemaType.SITE)
     if site:
         cycle['site'] = site
+
+    # need to download `otherSites` as well
+    if 'otherSites' in cycle:
+        cycle['otherSites'] = [_load_calculated_node(s, SchemaType.SITE) for s in cycle['otherSites']]
+
     return cycle
 
 

hestia_earth/models/ipcc2019/co2ToAirAboveGroundBiomassStockChange.py

@@ -1,7 +1,6 @@
-from hestia_earth.schema import CycleFunctionalUnit, EmissionMethodTier, MeasurementMethodClassification, SiteSiteType
+from hestia_earth.schema import EmissionMethodTier, MeasurementMethodClassification
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match
 from hestia_earth.models.utils.emission import _new_emission
 
 from .biomass_utils import detect_land_cover_change, get_valid_management_nodes, summarise_land_cover_nodes
@@ -61,13 +60,6 @@ The list of `MeasurementMethodClassification`s that can be used to calculate SOC
 order from strongest to weakest.
 """
 
-_SITE_TYPE_SYSTEMS_MAPPING = {
-    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value: [
-        "protectedCroppingSystemSoilBased",
-        "protectedCroppingSystemSoilAndSubstrateBased"
-    ]
-}
-
 
 def _emission(
     *,
@@ -129,12 +121,12 @@ def run(cycle: dict) -> list[dict]:
         A list of [Emission nodes](https://www.hestia.earth/schema/Emission) containing model results.
     """
     should_run_exec = create_should_run_function(
-        carbon_stock_term_id=_CARBON_STOCK_TERM_ID,
+        _CARBON_STOCK_TERM_ID,
+        measurements_mandatory=False,  # Model can allocate zero emissions to LUC with enough landCover data
+        measurement_method_ranking=_MEASUREMENT_METHOD_RANKING,
         get_valid_management_nodes_func=get_valid_management_nodes,
-        should_compile_inventory_func=_should_compile_inventory_func,
         summarise_land_use_func=summarise_land_cover_nodes,
         detect_land_use_change_func=detect_land_cover_change,
-        measurement_method_ranking=_MEASUREMENT_METHOD_RANKING
     )
 
     run_exec = create_run_function(
@@ -143,60 +135,10 @@ def run(cycle: dict) -> list[dict]:
         management_change_emission_term_id=_MG_EMISSION_TERM_ID
     )
 
-    should_run, kwargs, logs = should_run_exec(cycle)
+    should_run, cycle_id, inventory, logs = should_run_exec(cycle)
 
     for term_id in [_LU_EMISSION_TERM_ID, _MG_EMISSION_TERM_ID]:
         logRequirements(cycle, model=MODEL, term=term_id, **logs)
         logShouldRun(cycle, MODEL, term_id, should_run)
 
-    return run_exec(**kwargs) if should_run else []
-
-
-def _should_compile_inventory_func(
-    site: dict, cycles: list[dict], carbon_stock_measurements: list[dict]
-) -> tuple[bool, dict]:
-    """
-    Determine whether a site is suitable and has enough data to compile a carbon stock inventory.
-
-    Parameters
-    ----------
-    site : dict
-        A HESTIA (Site node)[https://www.hestia.earth/schema/Site]
-    cycles : list[dict]
-        A list of HESTIA (Cycle nodes)[https://www.hestia.earth/schema/Cycle] that are related to the site.
-    carbon_stock_measurements : list[dict]
-        A list of HESTIA carbon stock (Measurement nodes)[https://www.hestia.earth/schema/Measurement] that are related
-        to the site.
-
-    Returns
-    -------
-    tuple[bool, dict]
-        `(should_run, logs)`.
-    """
-    site_type = site.get("siteType")
-    has_soil = site_type not in _SITE_TYPE_SYSTEMS_MAPPING or all(
-        cumulative_nodes_term_match(
-            cycle.get("practices", []),
-            target_term_ids=_SITE_TYPE_SYSTEMS_MAPPING[site_type],
-            cumulative_threshold=0
-        ) for cycle in cycles
-    )
-
-    has_cycles = len(cycles) > 0
-    has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
-
-    should_run = all([
-        has_soil,
-        has_cycles,
-        has_functional_unit_1_ha
-    ])
-
-    logs = {
-        "site_type": site_type,
-        "has_soil": has_soil,
-        "carbon_stock_term": _CARBON_STOCK_TERM_ID,
-        "has_cycles": has_cycles,
-        "has_functional_unit_1_ha": has_functional_unit_1_ha,
-    }
-
-    return should_run, logs
+    return run_exec(cycle_id, inventory) if should_run else []

hestia_earth/models/ipcc2019/co2ToAirBelowGroundBiomassStockChange.py

@@ -1,7 +1,6 @@
-from hestia_earth.schema import CycleFunctionalUnit, EmissionMethodTier, SiteSiteType
+from hestia_earth.schema import EmissionMethodTier
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match
 from hestia_earth.models.utils.emission import _new_emission
 
 from .biomass_utils import detect_land_cover_change, get_valid_management_nodes, summarise_land_cover_nodes
@@ -19,7 +18,7 @@ REQUIREMENTS = {
                     "dates": "",
                     "depthUpper": "0",
                     "depthLower": "30",
-                    "term.@id": " belowGroundBiomass"
+                    "term.@id": "belowGroundBiomass"
                 }
             ]
         },
@@ -52,13 +51,6 @@ _DEPTH_LOWER = 30
 
 _CARBON_STOCK_TERM_ID = 'belowGroundBiomass'
 
-_SITE_TYPE_SYSTEMS_MAPPING = {
-    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value: [
-        "protectedCroppingSystemSoilBased",
-        "protectedCroppingSystemSoilAndSubstrateBased"
-    ]
-}
-
 
 def _emission(
     *,
@@ -121,12 +113,13 @@ def run(cycle: dict) -> list[dict]:
         A list of [Emission nodes](https://www.hestia.earth/schema/Emission) containing model results.
     """
     should_run_exec = create_should_run_function(
-        carbon_stock_term_id=_CARBON_STOCK_TERM_ID,
+        _CARBON_STOCK_TERM_ID,
+        depth_upper=_DEPTH_UPPER,
+        depth_lower=_DEPTH_LOWER,
+        measurements_mandatory=False,  # Model can allocate zero emissions to LUC with enough landCover data
         get_valid_management_nodes_func=get_valid_management_nodes,
-        should_compile_inventory_func=_should_compile_inventory_func,
         summarise_land_use_func=summarise_land_cover_nodes,
-        detect_land_use_change_func=detect_land_cover_change,
-        should_run_measurement_func=_should_run_measurement_func
+        detect_land_use_change_func=detect_land_cover_change
     )
 
     run_exec = create_run_function(
@@ -135,81 +128,10 @@ def run(cycle: dict) -> list[dict]:
         management_change_emission_term_id=_MG_EMISSION_TERM_ID
     )
 
-    should_run, kwargs, logs = should_run_exec(cycle)
+    should_run, cycle_id, inventory, logs = should_run_exec(cycle)
 
     for term_id in [_LU_EMISSION_TERM_ID, _MG_EMISSION_TERM_ID]:
         logRequirements(cycle, model=MODEL, term=term_id, **logs)
         logShouldRun(cycle, MODEL, term_id, should_run)
 
-    return run_exec(**kwargs) if should_run else []
-
-
-def _should_run_measurement_func(node: dict) -> bool:
-    """
-    Validate a [Measurement](https://www.hestia.earth/schema/Measurement) to determine whether it is a valid
-    `organicCarbonPerHa` node.
-
-    Parameters
-    ----------
-    node : dict
-        The node to be validated.
-
-    Returns
-    -------
-    bool
-        `True` if the node passes all validation criteria, `False` otherwise.
-    """
-    return all([
-        node.get("depthLower") == _DEPTH_LOWER,
-        node.get("depthUpper") == _DEPTH_UPPER
-    ])
-
-
-def _should_compile_inventory_func(
-    site: dict, cycles: list[dict], carbon_stock_measurements: list[dict]
-) -> tuple[bool, dict]:
-    """
-    Determine whether a site is suitable and has enough data to compile a carbon stock inventory.
-
-    Parameters
-    ----------
-    site : dict
-        A HESTIA (Site node)[https://www.hestia.earth/schema/Site]
-    cycles : list[dict]
-        A list of HESTIA (Cycle nodes)[https://www.hestia.earth/schema/Cycle] that are related to the site.
-    carbon_stock_measurements : list[dict]
-        A list of HESTIA carbon stock (Measurement nodes)[https://www.hestia.earth/schema/Measurement] that are related
-        to the site.
-
-    Returns
-    -------
-    tuple[bool, dict]
-        `(should_run, logs)`.
-    """
-    site_type = site.get("siteType")
-    has_soil = site_type not in _SITE_TYPE_SYSTEMS_MAPPING or all(
-        cumulative_nodes_term_match(
-            cycle.get("practices", []),
-            target_term_ids=_SITE_TYPE_SYSTEMS_MAPPING[site_type],
-            cumulative_threshold=0
-        ) for cycle in cycles
-    )
-
-    has_cycles = len(cycles) > 0
-    has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
-
-    should_run = all([
-        has_soil,
-        has_cycles,
-        has_functional_unit_1_ha
-    ])
-
-    logs = {
-        "site_type": site_type,
-        "has_soil": has_soil,
-        "carbon_stock_term": _CARBON_STOCK_TERM_ID,
-        "has_cycles": has_cycles,
-        "has_functional_unit_1_ha": has_functional_unit_1_ha,
-    }
-
-    return should_run, logs
+    return run_exec(cycle_id, inventory) if should_run else []