hestia-earth-models 0.64.6__tar.gz → 0.64.8__tar.gz

{hestia-earth-models-0.64.6/hestia_earth_models.egg-info → hestia-earth-models-0.64.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.64.6
+Version: 0.64.8
 Summary: HESTIA's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: HESTIA Team

{hestia-earth-models-0.64.6 → hestia-earth-models-0.64.8}/hestia_earth/models/cycle/animal/milkYield.py

@@ -1,18 +1,16 @@
 """
 Milk Yield
 
-This model gap-fills the practice "Milk yield per animal X (raw/FPCM)" (e.g. `Milk yield per cow (raw)`) when:
-- the practice is added to the Cycle itself, and we can match it with the `term` of an Animal blank node;
-- the Animal blank node Term has a lookup value of `kgDayMilkForFeedingOffspring`.
+This model gap-fills the practice "Milk yield per animal X (raw/FPCM)" (e.g. `Milk yield per cow (raw)`) when
+the practice is added to the Cycle itself, and we can match it with the `term` of an Animal blank node.
 """
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import non_empty_list, safe_parse_float
+from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import logShouldRun, logRequirements, log_blank_nodes_id
 from hestia_earth.models.utils.blank_node import merge_blank_nodes
 from hestia_earth.models.utils.term import get_lookup_value
-from hestia_earth.models.utils.practice import _new_practice
 from .. import MODEL
 
 REQUIREMENTS = {
@@ -21,12 +19,10 @@ REQUIREMENTS = {
             "@type": "Animal",
             "term.termType": "liveAnimal"
         }],
-        "optional": {
-            "practices": [{
-                "@type": "Practice",
-                "term.termType": "animalManagement"
-            }]
-        }
+        "practices": [{
+            "@type": "Practice",
+            "term.termType": "animalManagement"
+        }]
     }
 }
 RETURNS = {
@@ -38,27 +34,19 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "liveAnimal": ["milkYieldPracticeTermIds", "kgDayMilkForFeedingOffspring"]
+    "liveAnimal": "milkYieldPracticeTermIds"
 }
 
 MODEL_KEY = 'milkYield'
 
 
-def _default_practice(animal: dict, practice_term_id: str):
-    term = animal.get('term', {})
-    value = get_lookup_value(term, LOOKUPS['liveAnimal'][1], model=MODEL, model_key=MODEL_KEY)
-    return (_new_practice(practice_term_id) | {'value': [safe_parse_float(value)]}) if value else None
-
-
 def _run(cycle: dict, animal: dict):
     term = animal.get('term', {})
     term_id = term.get('@id')
-    value = get_lookup_value(term, LOOKUPS['liveAnimal'][0], model=MODEL, model_key=MODEL_KEY)
+    value = get_lookup_value(term, LOOKUPS['liveAnimal'], model=MODEL, model_key=MODEL_KEY)
     practice_ids = non_empty_list((value or '').split(';'))
     practices = non_empty_list(
-        [p for p in cycle.get('practices', []) if p.get('term', {}).get('@id') in practice_ids] or (
-            [_default_practice(animal, practice_ids[0])] if practice_ids else []
-        )
+        [p for p in cycle.get('practices', []) if p.get('term', {}).get('@id') in practice_ids]
     )
 
     logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,

{hestia-earth-models-0.64.6 → hestia-earth-models-0.64.8}/hestia_earth/models/cycle/unknownPreSeasonWaterRegime.py

@@ -36,7 +36,6 @@ def _practice():
 def _should_run(cycle: dict):
     practices = cycle.get('practices', [])
     flooded_terms = get_flooded_pre_season_terms()
-    print(flooded_terms)
     existing_practice = next((p for p in practices if p.get('term', {}).get('@id') in flooded_terms), None)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,

{hestia-earth-models-0.64.6 → hestia-earth-models-0.64.8}/hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandOccupation.py

@@ -12,34 +12,34 @@ from . import MODEL
 from .utils import get_coefficient_factor
 
 REQUIREMENTS = {
-    "Cycle": {
-        "siteDuration": "> 0",
-        "siteArea": "> 0",
-        "site": {"siteType": "",
-                 "@type": "Site",
-                 "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
-                 "country": {"@type": "Term", "termType": "region"}
-                 },
-        "optional": {
-            "otherSitesDuration": "> 0",
-            "otherSitesArea": "> 0",
-            "otherSites": [
-                {
-                    "siteType": "",
+    "ImpactAssessment": {
+        "cycle": {
+            "@type": "Cycle",
+            "siteDuration": "> 0",
+            "siteArea": "> 0",
+            "site": {
+                "siteType": "",
+                "@type": "Site",
+                "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
+                "country": {"@type": "Term", "termType": "region"}
+            },
+            "optional": {
+                "otherSitesDuration": "> 0",
+                "otherSitesArea": "> 0",
+                "otherSites": [{
                     "@type": "Site",
+                    "siteType": "",
                     "management": [{"@type": "Management", "value": "", "term.termType": "landCover"}],
                     "country": {"@type": "Term", "termType": "region"}
-                }
-            ]
+                }]
+            }
         }
     }
 }
 LOOKUPS = {
     "@doc": "Performs lookup on landCover.csv for column headers and region-pefTermGrouping-landOccupation.csv for CFs",
     "region-pefTermGrouping-landOccupation": "",
-    "landCover": [
-        "pefTermGrouping"
-    ]
+    "landCover": "pefTermGrouping"
 }
 
 RETURNS = {
@@ -62,7 +62,8 @@ def _run(sites: list):
     return _indicator(list_sum(values)) if values else None
 
 
-def _should_run(cycle: dict):
+def _should_run(impact_assessment: dict):
+    cycle = impact_assessment.get('cycle', {})
     end_date = cycle.get('endDate')
 
     has_site = bool(cycle.get('site', False))
@@ -76,8 +77,8 @@ def _should_run(cycle: dict):
         {
             'site-type': site.get('siteType'),
             'country-id': site.get('country', {}).get('@id'),
-            'area': site_areas[index],
-            'duration': site_durations[index],
+            'area': site_areas[index] if len(site_areas) >= index + 1 else None,
+            'duration': site_durations[index] if len(site_durations) >= index + 1 else None,
             'landCover-id': (most_relevant_blank_node_by_type(
                 site.get("management", []),
                 term_type=TermTermType.LANDCOVER.value,
@@ -123,6 +124,6 @@ def _should_run(cycle: dict):
     return should_run, valid_sites
 
 
-def run(cycle: dict):
-    should_run, sites = _should_run(cycle)
+def run(impact_assessment: dict):
+    should_run, sites = _should_run(impact_assessment)
     return _run(sites) if should_run else None

hestia-earth-models-0.64.8/hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -0,0 +1,182 @@
+"""
+Characterises [soilQualityIndexLandTransformation](https://hestia.earth/term/soilQualityIndexLandTransformation)
+based on an updated [LANCA model (De Laurentiis et al. 2019)](
+http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
+Factors version 2.5 (Horn and Meier, 2018).
+"""
+from typing import List
+
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import download_lookup
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum, safe_parse_date, non_empty_list
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import hectar_to_square_meter
+from hestia_earth.models.utils import pairwise
+from . import MODEL
+from .utils import get_coefficient_factor
+from ..utils.indicator import _new_indicator
+from ..utils.landCover import get_pef_grouping
+from ..utils.lookup import fallback_country
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "cycle": {
+            "@type": "Cycle",
+            "site": {
+                "area": "> 0",
+                "@type": "Site",
+                "management": [{"@type": "Management", "term.termType": "landCover"}],
+                "optional": {"country": {"@type": "Term", "termType": "region"}}
+            },
+            "optional": {
+                "otherSitesArea": "> 0",
+                "otherSites": [{
+                    "@type": "Site",
+                    "management": [{"@type": "Management", "term.termType": "landCover"}],
+                    "optional": {"country": {"@type": "Term", "termType": "region"}}
+                }]
+            }
+        }
+    }
+}
+
+LOOKUPS = {
+    "@doc": "Uses `landCover.csv` for column headers and region-pefTermGrouping-landTransformation-X.csv for to/from CFs. (CFs in `region-pefTermGrouping-landTransformation-from.csv` appear to be the opposite values as those in `region-pefTermGrouping-landTransformation-to.csv` but can be different in some cases)",  # noqa: E501
+    "region-pefTermGrouping-landTransformation-from": "",
+    "region-pefTermGrouping-landTransformation-to": "",
+    "landCover": "pefTermGrouping"
+}
+
+from_lookup_file = f"{list(LOOKUPS.keys())[1]}.csv"
+to_lookup_file = f"{list(LOOKUPS.keys())[2]}.csv"
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+TERM_ID = 'soilQualityIndexLandTransformation'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(sites: List[dict]):
+    result = []
+    for site in sites:
+        values = [(transformation_from_factor + transformation_to_factor) * hectar_to_square_meter(site['area'])
+                  for transformation_from_factor, transformation_to_factor in site['transformation_factors']]
+        result.append(list_sum(values))
+    return _indicator(list_sum(result)) if result else None
+
+
+def _should_run(impact_assessment: dict):
+    cycle = impact_assessment.get('cycle', {})
+
+    has_site = bool(cycle.get('site', {}))
+    site_area = cycle.get('site', {}).get("area", False)
+    has_area = site_area > 0
+
+    has_other_sites = bool(cycle.get('otherSites', []))
+
+    all_sites = non_empty_list([cycle.get('site')] + cycle.get('otherSites', []))
+    site_areas = [cycle.get('site', {}).get('area')] + cycle.get('otherSitesArea', [])
+
+    sites = [
+        {
+            'site_id': site.get('@id', site.get('id')),
+            'transformation_pairs': list(pairwise(
+                sorted(filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER.value),
+                       key=lambda d: safe_parse_date(d['endDate'])))),
+            'country_id_str': site.get('country', {}).get('@id', ''),
+            'area': site_areas[index] if len(site_areas) >= index + 1 else None,
+        }
+        for index, site in enumerate(all_sites)
+    ]
+
+    sites = [
+        site for site in sites
+        if all([
+            (site.get('area') or 0) > 0,
+            site.get('transformation_pairs', [])
+        ])
+    ]
+
+    sites = [
+        site |
+        {
+            'column_names': [(get_pef_grouping(from_transformation['term']['@id']),
+                              get_pef_grouping(to_transformation['term']['@id']))
+                             for from_transformation, to_transformation in site['transformation_pairs']],
+        } for site in sites
+    ]
+
+    has_lookup_column = lambda s: s['column_names'] and all([all(pair) for pair in s['column_names']])  # noqa: E731
+    valid_sites = [site for site in sites if has_lookup_column(site)]
+
+    has_valid_sites = bool(valid_sites)
+
+    valid_sites = [
+        site |
+        {
+            'country_id': fallback_country(site['country_id_str'],
+                                           [download_lookup(from_lookup_file), download_lookup(to_lookup_file)]
+                                           )
+        } for site in valid_sites
+    ]
+
+    valid_sites = [
+        site |
+        {
+            'transformation_factors': [(get_coefficient_factor(lookup_name=from_lookup_file,
+                                                               country_id=site['country_id'], term_id=TERM_ID,
+                                                               occupation_type=from_transformation_header),
+                                        get_coefficient_factor(lookup_name=to_lookup_file,
+                                                               country_id=site['country_id'], term_id=TERM_ID,
+                                                               occupation_type=to_transformation_header))
+                                       for from_transformation_header, to_transformation_header in site['column_names']]
+        } for site in valid_sites
+    ]
+
+    log_equivalent_eu_pef_land_use_names = [
+        [{
+            'site-id': site['site_id'],
+            'hestia-term': hestia_term,
+            'corine-term': corine_term,
+        } for hestia_term, corine_term in site['column_names']
+        ] for site in valid_sites]
+
+    log_transformation_factors = [
+        [{
+            'site-id': site['site_id'],
+            'country-id-used-for-factors': site['country_id'],
+            'country-id-in-input': site['country_id_str'],
+            'factor-from': from_transformation_header,
+            'factor-to': to_transformation_header,
+        } for from_transformation_header, to_transformation_header in site['transformation_factors']
+        ] for site in valid_sites]
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_site=has_site,
+                    has_area=has_area,
+                    has_other_sites=has_other_sites,
+                    has_valid_sites=has_valid_sites,
+                    equivalent_EU_PEF_landUse_names=log_as_table(log_equivalent_eu_pef_land_use_names),
+                    transformation_factors=log_as_table(log_transformation_factors)
+                    )
+    should_run = has_valid_sites
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+
+    return should_run, valid_sites
+
+
+def run(impact_assessment: dict):
+    should_run, sites = _should_run(impact_assessment)
+    return _run(sites) if should_run else None

hestia-earth-models-0.64.8/hestia_earth/models/environmentalFootprintV3/soilQualityIndexTotalLandUseEffects.py

@@ -0,0 +1,66 @@
+"""
+Characterises [soilQualityIndexTotalLandUseEffects](https://hestia.earth/term/soilQualityIndexTotalLandUseEffects)
+based on an updated [LANCA model (De Laurentiis et al. 2019)](
+http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
+Factors version 2.5 (Horn and Meier, 2018).
+"""
+from hestia_earth.utils.model import find_term_match
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from . import MODEL
+from ..utils.indicator import _new_indicator
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {"@type": "Indicator", "value": "", "term.@id": "soilQualityIndexLandOccupation"},
+            {"@type": "Indicator", "value": "", "term.@id": "soilQualityIndexLandTransformation"}
+        ]
+    }
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }
+}
+TERM_ID = 'soilQualityIndexTotalLandUseEffects'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(land_occupation_indicator, transformation_indicator):
+    value = land_occupation_indicator['value'] + transformation_indicator['value']
+    return _indicator(value) if value else None
+
+
+def _should_run(impactassessment: dict):
+    land_occupation_indicator = find_term_match(impactassessment.get('emissionsResourceUse', []),
+                                                "soilQualityIndexLandOccupation")
+    transformation_indicator = find_term_match(impactassessment.get('emissionsResourceUse', []),
+                                               "soilQualityIndexLandTransformation")
+
+    has_valid_values = all([isinstance(land_occupation_indicator.get('value', None), (int, float)),
+                            isinstance(transformation_indicator.get('value', None), (int, float))])
+
+    logRequirements(impactassessment, model=MODEL, term=TERM_ID,
+                    transformation_indicator=transformation_indicator,
+                    land_occupation_indicator=land_occupation_indicator,
+                    has_valid_values=has_valid_values
+                    )
+
+    should_run = all([transformation_indicator, land_occupation_indicator, has_valid_values])
+
+    logShouldRun(impactassessment, MODEL, TERM_ID, should_run)
+    return should_run, land_occupation_indicator, transformation_indicator
+
+
+def run(impactassessment: dict):
+    should_run, land_occupation_indicator, transformation_indicator = _should_run(impactassessment)
+    return _run(land_occupation_indicator, transformation_indicator) if should_run else None

{hestia-earth-models-0.64.6 → hestia-earth-models-0.64.8}/hestia_earth/models/environmentalFootprintV3/utils.py

@@ -12,6 +12,6 @@ def get_coefficient_factor(lookup_name: str, country_id: str, occupation_type: O
     """
     coefficient = get_table_value(download_lookup(lookup_name), 'termid', country_id, column_name(occupation_type))
     debugMissingLookup(
-        lookup_name, 'termid', country_id, column_name(occupation_type), coefficient, model=MODEL, term=term_id
+        lookup_name, 'termid', country_id, occupation_type, coefficient, model=MODEL, term=term_id
     )
     return coefficient

{hestia-earth-models-0.64.6 → hestia-earth-models-0.64.8}/hestia_earth/models/hyde32/utils.py

@@ -45,6 +45,8 @@ def _run(impact_assessment: dict, term_id: str, land_occupation_m2: float, facto
 
 
 def _should_run(impact_assessment: dict, term_id: str, from_site_type: SiteSiteType, years: int):
+    site = get_site(impact_assessment)
+    has_site = bool(site)
     cycle = impact_assessment.get('cycle', {})
     product = get_product(impact_assessment)
     site = get_site(impact_assessment)
@@ -52,10 +54,12 @@ def _should_run(impact_assessment: dict, term_id: str, from_site_type: SiteSiteT
     land_transformation_factor = _get_emission_factor(term_id, impact_assessment, years, from_site_type)
 
     logRequirements(impact_assessment, model=MODEL, term=term_id,
+                    has_site=has_site,
                     land_occupation_m2_kg=land_occupation_m2_kg,
                     land_transformation_factor=land_transformation_factor)
 
     should_run = all([
+        has_site,
         land_occupation_m2_kg is not None,
         land_occupation_m2_kg == 0 or land_transformation_factor is not None
     ])

{hestia-earth-models-0.64.6 → hestia-earth-models-0.64.8}/hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -137,10 +137,12 @@ LOOKUPS = {
         "isWoolProducingAnimal"
     ],
     "system-liveAnimal-activityCoefficient-ipcc2019": "using animal term @id",
+    "landCover": "grazedPastureGrassInputId",
     "crop-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"],
     "crop": "grazedPastureGrassInputId",
     "forage-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"],
-    "landCover": "grazedPastureGrassInputId"
+    "feedFoodAdditive": "hasEnergyContent",
+    "feedFoodAdditive-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"]
 }
 RETURNS = {
     "Animal": [{

hestia-earth-models-0.64.8/hestia_earth/models/ipcc2019/co2ToAirAboveGroundBiomassStockChangeLandUseChange.py

@@ -0,0 +1,191 @@
+from hestia_earth.schema import CycleFunctionalUnit, EmissionMethodTier, MeasurementMethodClassification, SiteSiteType
+
+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 .co2ToAirCarbonStockChange_utils import create_run_function, create_should_run_function
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "measurements": [
+                {
+                    "@type": "Measurement",
+                    "value": "",
+                    "dates": "",
+                    "depthUpper": "0",
+                    "depthLower": "30",
+                    "term.@id": "aboveGroundBiomass"
+                }
+            ]
+        },
+        "functionalUnit": "1 ha",
+        "endDate": "",
+        "optional": {
+            "startDate": ""
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "sd": "",
+        "min": "",
+        "max": "",
+        "statsDefinition": "simulated",
+        "observations": "",
+        "methodTier": ""
+    }]
+}
+TERM_ID = 'co2ToAirAboveGroundBiomassStockChangeLandUseChange'
+
+_CARBON_STOCK_TERM_ID = 'aboveGroundBiomass'
+
+_MEASUREMENT_METHOD_RANKING = [
+    MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+    MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS,
+    MeasurementMethodClassification.TIER_3_MODEL,
+    MeasurementMethodClassification.TIER_2_MODEL,
+    MeasurementMethodClassification.TIER_1_MODEL,
+    MeasurementMethodClassification.GEOSPATIAL_DATASET
+]
+"""
+The list of `MeasurementMethodClassification`s that can be used to calculate SOC stock change emissions, ranked in
+order from strongest to weakest.
+"""
+
+_SITE_TYPE_SYSTEMS_MAPPING = {
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value: [
+        "protectedCroppingSystemSoilBased",
+        "protectedCroppingSystemSoilAndSubstrateBased"
+    ]
+}
+
+
+def _emission(
+    *,
+    value: list[float],
+    method_tier: EmissionMethodTier,
+    sd: list[float] = None,
+    min: list[float] = None,
+    max: list[float] = None,
+    statsDefinition: str = None,
+    observations: list[int] = None
+) -> dict:
+    """
+    Create an emission node based on the provided value and method tier.
+
+    See [Emission schema](https://www.hestia.earth/schema/Emission) for more information.
+
+    Parameters
+    ----------
+    value : float
+        The emission value (kg CO2 ha-1).
+    sd : float
+        The standard deviation (kg CO2 ha-1).
+    method_tier : EmissionMethodTier
+        The emission method tier.
+
+    Returns
+    -------
+    dict
+        The emission dictionary with keys 'depth', 'value', and 'methodTier'.
+    """
+    update_dict = {
+        "value": value,
+        "sd": sd,
+        "min": min,
+        "max": max,
+        "statsDefinition": statsDefinition,
+        "observations": observations,
+        "methodTier": method_tier.value
+    }
+    emission = _new_emission(TERM_ID, MODEL) | {
+        key: value for key, value in update_dict.items() if value
+    }
+    return emission
+
+
+def run(cycle: dict) -> list[dict]:
+    """
+    Run the `ipcc2019.co2ToAirAboveGroundBiomassStockChangeManagementChange`.
+
+    Parameters
+    ----------
+    cycle : dict
+        A HESTIA (Cycle node)[https://www.hestia.earth/schema/Cycle].
+
+    Returns
+    -------
+    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,
+        _should_compile_inventory_func,
+        measurement_method_ranking=_MEASUREMENT_METHOD_RANKING
+    )
+
+    run_exec = create_run_function(_emission)
+
+    should_run, cycle_id, inventory, logs = should_run_exec(cycle)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID, **logs)
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+
+    return run_exec(cycle_id, inventory) 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_stock_measurements = len(carbon_stock_measurements) > 0
+    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_stock_measurements,
+        has_cycles,
+        has_functional_unit_1_ha
+    ])
+
+    logs = {
+        "site_type": site_type,
+        "has_soil": has_soil,
+        "carbon_stock_term": _CARBON_STOCK_TERM_ID,
+        "has_stock_measurements": has_stock_measurements,
+        "has_cycles": has_cycles,
+        "has_functional_unit_1_ha": has_functional_unit_1_ha,
+    }
+
+    return should_run, logs