hestia-earth-models 0.69.1__py3-none-any.whl → 0.70.1__py3-none-any.whl

hestia_earth/models/emissionNotRelevant/__init__.py

@@ -1,10 +1,11 @@
-from hestia_earth.schema import NodeType, EmissionMethodTier
+from hestia_earth.schema import NodeType, EmissionMethodTier, TermTermType
+from hestia_earth.utils.lookup import download_lookup, lookup_term_ids, lookup_columns, column_name
 from hestia_earth.utils.lookup_utils import is_in_system_boundary
+from hestia_earth.utils.tools import flatten
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 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
+from hestia_earth.models.utils.blank_node import _run_required, _run_model_required
 
 REQUIREMENTS = {
     "Cycle": {
@@ -18,7 +19,17 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "emission": "inHestiaDefaultSystemBoundary"
+    "emission": [
+        "term.id",
+        "inHestiaDefaultSystemBoundary",
+        "inputTermTypesAllowed",
+        "productTermIdsAllowed",
+        "productTermTypesAllowed",
+        "siteTypesAllowed",
+        "typesAllowed"
+    ],
+    "emission-model-productTermIdsAllowed": "",
+    "emission-model-siteTypesAllowed": ""
 }
 MODEL = 'emissionNotRelevant'
 TIER = EmissionMethodTier.NOT_RELEVANT.value
@@ -31,9 +42,22 @@ def _emission(term_id: str):
     return emission
 
 
-def _should_run_emission(cycle: dict):
+def _emission_ids():
+    return lookup_term_ids(download_lookup(f"{TermTermType.EMISSION.value}.csv"))
+
+
+def _model_ids(lookup_suffix: str):
+    return [
+        col for col in lookup_columns(download_lookup(f"emission-model-{lookup_suffix}.csv"))
+        if col != column_name('term.id')
+    ]
+
+
+def _should_run_emission(cycle: dict, model_ids: list):
     def run(term_id: str):
-        is_not_relevant = not _run_required(MODEL, term_id, cycle)
+        is_not_relevant = not _run_required(MODEL, term_id, cycle) or any([
+            not _run_model_required(model_id, term_id, cycle, skip_logs=True) for model_id in model_ids
+        ])
         in_system_boundary = is_in_system_boundary(term_id)
 
         should_run = all([is_not_relevant, in_system_boundary])
@@ -49,8 +73,9 @@ def _should_run_emission(cycle: dict):
 
 
 def _run(cycle: dict):
-    emissions = get_all_emission_terms()
-    term_ids = list(filter(_should_run_emission(cycle), emissions))
+    emissions = _emission_ids()
+    model_ids = list(set(flatten(map(_model_ids, ['productTermIdsAllowed', 'siteTypesAllowed']))))
+    term_ids = list(filter(_should_run_emission(cycle, model_ids), emissions))
     return list(map(_emission, term_ids))
 
 

hestia_earth/models/frischknechtEtAl2000/ionisingRadiationKbqU235Eq.py

@@ -18,7 +18,7 @@ REQUIREMENTS = {
                 "ionisingCompoundsToWaterInputsProduction",
                 "ionisingCompoundsToSaltwaterInputsProduction"
             ],
-            "inputs": {"@type": "Term", "term.termType": "waste", "term.units": "kg"}
+            "inputs": [{"@type": "Term", "term.termType": "waste", "term.units": "kg"}]
         }]
     }
 }

hestia_earth/models/geospatialDatabase/croppingIntensity.py

@@ -14,8 +14,8 @@ REQUIREMENTS = {
         "site": {
             "@type": "Site",
             "or": [
-                {"region": {"@type": "Term"}},
-                {"country": {"@type": "Term"}}
+                {"region": {"@type": "Term", "termType": "region"}},
+                {"country": {"@type": "Term", "termType": "region"}}
             ]
         },
         "optional": {
@@ -23,8 +23,8 @@ REQUIREMENTS = {
                 {
                     "@type": "Site",
                     "or": [
-                        {"region": {"@type": "Term"}},
-                        {"country": {"@type": "Term"}}
+                        {"region": {"@type": "Term", "termType": "region"}},
+                        {"country": {"@type": "Term", "termType": "region"}}
                     ]
                 }
             ]

hestia_earth/models/geospatialDatabase/longFallowRatio.py

@@ -14,8 +14,8 @@ REQUIREMENTS = {
         "site": {
             "@type": "Site",
             "or": [
-                {"region": {"@type": "Term"}},
-                {"country": {"@type": "Term"}}
+                {"region": {"@type": "Term", "termType": "region"}},
+                {"country": {"@type": "Term", "termType": "region"}}
             ]
         },
         "optional": {
@@ -23,8 +23,8 @@ REQUIREMENTS = {
                 {
                     "@type": "Site",
                     "or": [
-                        {"region": {"@type": "Term"}},
-                        {"country": {"@type": "Term"}}
+                        {"region": {"@type": "Term", "termType": "region"}},
+                        {"country": {"@type": "Term", "termType": "region"}}
                     ]
                 }
             ]

hestia_earth/models/geospatialDatabase/region.py

@@ -1,8 +1,9 @@
-from hestia_earth.utils.api import download_hestia
+from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import linked_node
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from .utils import download, has_coordinates
+from hestia_earth.models.utils.term import download_term
 from . import MODEL
 
 REQUIREMENTS = {
@@ -30,7 +31,7 @@ def _download_region(site: dict):
         only_coordinates=True
     )
     try:
-        return None if gadm_id is None else linked_node(download_hestia(f"GADM-{gadm_id}"))
+        return None if gadm_id is None else linked_node(download_term(f"GADM-{gadm_id}", TermTermType.REGION))
     except Exception:
         return None
 

hestia_earth/models/geospatialDatabase/utils.py

@@ -1,10 +1,10 @@
 import os
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import debugValues, logErrorRun, logRequirements
 from hestia_earth.models.utils.site import cached_value, region_factor, region_level_1_id
+from hestia_earth.models.utils.term import download_term
 from . import MODEL
 
 MAX_AREA_SIZE = int(os.getenv('MAX_AREA_SIZE', '5000'))
@@ -97,7 +97,7 @@ def _get_boundary_area_size(boundary: dict):
 
 def _get_region_area_size(site: dict):
     term = site.get('region', site.get('country'))
-    return term.get('area', (download_hestia(term.get('@id')) or {}).get('area')) if term else None
+    return term.get('area', (download_term(term.get('@id'), TermTermType.REGION) or {}).get('area')) if term else None
 
 
 def get_area_size(site: dict):
@@ -153,9 +153,10 @@ def _get_cached_data(term: str, site: dict, data: dict):
     cache = _cached_value(site, term)
     cache_sub_key = _cache_sub_key(data)
     # data can be grouped by year when required
-    value = cache.get(cache_sub_key) if (
-        isinstance(cache, dict) and cache_sub_key in cache and cache is not None
-     ) else cache
+    value = cache.get(cache_sub_key) if all([
+        isinstance(cache, dict),
+        cache_sub_key
+    ]) else cache
     if value is not None:
         debugValues(site, model=MODEL, term=term, value_from_cache=value)
     return value

hestia_earth/models/haversineFormula/transport/distance.py

@@ -1,9 +1,10 @@
 from haversine import haversine
-from hestia_earth.utils.api import download_hestia
+from hestia_earth.schema import TermTermType
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.method import include_methodModel
+from hestia_earth.models.utils.term import download_term
 from .. import MODEL
 
 REQUIREMENTS = {
@@ -55,7 +56,7 @@ def _should_run_transport(cycle: dict, transport: dict):
 def _run_input(cycle: dict, site_country: dict):
     def exec(input: dict):
         term_id = input.get('term', {}).get('@id')
-        input_country = download_hestia(input.get('country', {}).get('@id'))
+        input_country = download_term(input.get('country', {}).get('@id'), TermTermType.REGION)
         distance_kms = haversine(
             (site_country.get('latitude'), site_country.get('longitude')),
             (input_country.get('latitude'), input_country.get('longitude'))
@@ -74,7 +75,7 @@ def _should_run_input(site_country_id: str):
     def exec(input: dict):
         input_country = input.get('country', {}) or {}
         input_country_id = input_country.get('@id')
-        input_country = download_hestia(input_country_id)
+        input_country = download_term(input_country_id, TermTermType.REGION)
         has_transports = len(input.get('transport', [])) > 0
         should_run = input_country and all([
             input_country.get('latitude'), input_country.get('latitude'),
@@ -89,7 +90,7 @@ def _should_run(cycle: dict):
     country_id = cycle.get('site', {}).get('country', {}).get('@id')
     inputs = list(filter(_should_run_input(country_id), cycle.get('inputs', [])))
     # download full term to get coordinates only if there is anything to run
-    country = download_hestia(country_id) if len(inputs) > 0 else {}
+    country = download_term(country_id, TermTermType.REGION) if len(inputs) > 0 else {}
 
     # can only run if the site country has centroid coordinates
     logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,

hestia_earth/models/{koble2014 → hestia}/aboveGroundCropResidue.py

@@ -33,6 +33,10 @@ TOTAL_TERM_ID = 'aboveGroundCropResidueTotal'
 REMAINING_MODEL = PRODUCT_ID_TO_PRACTICES_ID[-1]['product']
 
 
+def _product(term_id: str, value: float):
+    return _new_product(term_id, round(value, 7), MODEL)
+
+
 def _get_practices(term_id: str):
     return flatten([
         model.get('practices', []) for model in PRODUCT_ID_TO_PRACTICES_ID if all([
@@ -50,11 +54,6 @@ def _get_practice_value(term_ids: list, cycle: dict) -> float:
     return list_sum(values) / 100 if len(values) > 0 else None
 
 
-def _product(term_id: str, value: float):
-    product = _new_product(term_id, round(value, 2), MODEL)
-    return product
-
-
 def _should_run_model(model, cycle: dict, total_value: float):
     term_id = model.get('product')
     practice_value = _get_practice_value(model.get('practices'), cycle)

hestia_earth/models/{cycle → hestia}/aboveGroundCropResidueTotal.py

@@ -22,7 +22,7 @@ TERM_ID = 'aboveGroundCropResidueTotal'
 
 
 def _product(value: float):
-    product = _new_product(TERM_ID, value)
+    product = _new_product(TERM_ID, value, MODEL)
     return product
 
 
@@ -30,7 +30,7 @@ def _run(practice: dict, product: dict):
     practice_value = list_sum(practice.get('value', []))
     product_value = list_sum(product.get('value', []))
     value = product_value / (practice_value / 100)
-    return [_product(round(value, 2))]
+    return [_product(round(value, 7))]
 
 
 def _matching_product_by_practice(term_id: str):

hestia_earth/models/{site → hestia}/brackishWater.py

@@ -22,7 +22,7 @@ TERM_ID = 'brackishWater'
 
 
 def _measurement():
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [True]
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data

hestia_earth/models/{site → hestia}/cationExchangeCapacityPerKgSoil.py

@@ -30,7 +30,7 @@ BIBLIO_TITLE = 'Contribution of Organic Matter and Clay to Soil Cation-Exchange
 
 
 def _measurement(site: dict, value: float, depthUpper: int = None, depthLower: int = None):
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [value]
     if depthUpper is not None:
         data['depthUpper'] = depthUpper

hestia_earth/models/{cycle → hestia}/coldCarcassWeightPerHead.py

@@ -36,7 +36,7 @@ TERM_ID = 'coldCarcassWeightPerHead'
 
 
 def _property(value: float):
-    prop = _new_property(TERM_ID)
+    prop = _new_property(TERM_ID, MODEL)
     prop['value'] = value
     return prop
 

hestia_earth/models/{cycle → hestia}/coldDressedCarcassWeightPerHead.py

@@ -40,7 +40,7 @@ TERM_ID = 'coldDressedCarcassWeightPerHead'
 
 
 def _property(value: float):
-    prop = _new_property(TERM_ID)
+    prop = _new_property(TERM_ID, MODEL)
     prop['value'] = value
     return prop
 

hestia_earth/models/{cycle → hestia}/concentrateFeed.py

@@ -45,7 +45,7 @@ INPUT_TERM_TYPES = [
 
 
 def _property(term_id: str, value: float):
-    prop = _new_property(term_id)
+    prop = _new_property(term_id, MODEL)
     prop['value'] = value
     return prop
 

hestia_earth/models/{cycle → hestia}/cropResidueManagement.py

@@ -31,7 +31,7 @@ PRACTICE_IDS = [
 
 
 def _practice(term_id: str):
-    practice = _new_practice(term_id)
+    practice = _new_practice(term_id, MODEL)
     practice['value'] = [0]
     return practice
 

hestia_earth/models/{cycle → hestia}/croppingIntensity.py

@@ -24,7 +24,7 @@ TERM_ID = 'croppingIntensity'
 
 
 def _practice(value: float):
-    practice = _new_practice(TERM_ID)
+    practice = _new_practice(TERM_ID, MODEL)
     practice['value'] = [round(value, 7)]
     return practice
 

hestia_earth/models/{cycle → hestia}/energyContentLowerHeatingValue.py

@@ -9,7 +9,7 @@ REQUIREMENTS = {
     "Cycle": {
         "inputs": [{
             "@type": "Input",
-            "term.termType": ["woodFuel", "woodPellets"],
+            "term.@id": ["woodFuel", "woodPellets"],
             "properties": [{"@type": "Property", "value": "", "term.@id": "dryMatter"}]
         }]
     }
@@ -28,7 +28,7 @@ DRY_VALUE = 19.2  # Bone dry wood has an energy content of 19.2 MJ/kg
 
 
 def _property(value: float):
-    prop = _new_property(TERM_ID)
+    prop = _new_property(TERM_ID, MODEL)
     prop['value'] = value
     return prop
 

hestia_earth/models/{cycle → hestia}/excretaKgMass.py

@@ -14,6 +14,7 @@ REQUIREMENTS = {
         "products": [
             {
                 "@type": "Product",
+                "value": "",
                 "term.termType": "excreta",
                 "term.units": ["kg N", "kg VS"]
             }
@@ -36,16 +37,20 @@ UNITS = [
 
 
 def _product(value: float, term_id: str):
-    product = _new_product(term_id, value)
+    product = _new_product(term_id, value, MODEL)
     return product
 
 
 def _convert_by_product(cycle: dict, product: dict, term_id: str):
     existing_product = find_term_match(cycle.get('products', []), term_id)
+    existing_product_value = list_sum(existing_product.get('value', []), default=None)
 
     conversion_to_kg_ratio = convert_product_to_unit(product, existing_product.get('term', {}).get('units')) \
         if existing_product else None
-    value = list_sum(existing_product.get('value', [])) / conversion_to_kg_ratio if conversion_to_kg_ratio else None
+    value = existing_product_value / conversion_to_kg_ratio if all([
+        existing_product_value is not None,
+        conversion_to_kg_ratio
+    ]) else None
 
     debugValues(cycle, model=MODEL, term=term_id,
                 using_excreta_product=existing_product.get('term', {}).get('@id'),

hestia_earth/models/{cycle → hestia}/excretaKgN.py

@@ -30,7 +30,7 @@ MODEL_KEY = 'excretaKgN'
 
 
 def _product(value: float, term_id: str):
-    product = _new_product(term_id, value)
+    product = _new_product(term_id, value, MODEL)
     return product
 
 

hestia_earth/models/{cycle → hestia}/excretaKgVs.py

@@ -30,7 +30,7 @@ MODEL_KEY = 'excretaKgVs'
 
 
 def _product(value: float, term_id: str):
-    product = _new_product(term_id, value)
+    product = _new_product(term_id, value, MODEL)
     return product
 
 

hestia_earth/models/{cycle → hestia}/feedConversionRatio/__init__.py

@@ -24,7 +24,7 @@ MODELS = [
 
 
 def _practice(term_id: str, value: float):
-    practice = _new_practice(term_id)
+    practice = _new_practice(term_id, MODEL)
     practice['value'] = [value]
     return practice
 

hestia_earth/models/{site → hestia}/flowingWater.py

@@ -25,7 +25,7 @@ SITE_TYPE_TO_TERM_ID = {
 
 
 def _measurement(site: dict, term_id: str):
-    data = _new_measurement(term_id)
+    data = _new_measurement(term_id, MODEL)
     data['value'] = [True]
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data | get_source(site, BIBLIO_TITLE)

hestia_earth/models/{site → hestia}/freshWater.py

@@ -22,7 +22,7 @@ TERM_ID = 'freshWater'
 
 
 def _measurement():
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [True]
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data

hestia_earth/models/{cycle → hestia}/inorganicFertiliser.py

@@ -70,7 +70,7 @@ VALUE_BY_UNIT = {
 
 
 def _input(term_id: str, value: float, min: float = None, max: float = None):
-    input = _new_input(term_id)
+    input = _new_input(term_id, MODEL)
     input['value'] = [value]
     if min is not None:
         input['min'] = [min]

hestia_earth/models/{cycle → hestia}/irrigatedTypeUnspecified.py

@@ -1,15 +1,13 @@
-from hestia_earth.schema import TermTermType, CycleFunctionalUnit
+from hestia_earth.schema import CycleFunctionalUnit
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import is_irrigated
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.input import get_total_irrigation_m3
-from hestia_earth.models.utils.completeness import _is_term_type_complete
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "completeness.water": "",
         "functionalUnit": "1 ha",
         "none": {
             "practices": [{"@type": "Practice", "value": "> 0", "term.termType": "waterRegime"}]
@@ -31,38 +29,35 @@ TERM_ID = 'irrigatedTypeUnspecified'
 MIN_IRRIGATION_M3 = 250
 
 
-def _practice(value: float):
-    practice = _new_practice(TERM_ID)
-    practice['value'] = [value]
+def _practice():
+    practice = _new_practice(TERM_ID, MODEL)
+    practice['value'] = [100]
     return practice
 
 
-def _run(irrigation_m3: float):
-    value = 100 if irrigation_m3 > MIN_IRRIGATION_M3 else 0
-    return [_practice(value)]
-
-
 def _should_run(cycle: dict):
     functional_unit = cycle.get('functionalUnit')
-    water_complete = _is_term_type_complete(cycle, TermTermType.WATER)
     irrigation_value_m3 = get_total_irrigation_m3(cycle)
+    is_1_ha_functional_unit = functional_unit == CycleFunctionalUnit._1_HA.value
 
     no_irrigation_practice = not is_irrigated(cycle, model=MODEL, term=TERM_ID)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     no_irrigation_practice=no_irrigation_practice,
-                    term_type_water_complete=water_complete,
-                    irrigation_value_m3=irrigation_value_m3)
+                    is_1_ha_functional_unit=is_1_ha_functional_unit,
+                    irrigation_value_m3=irrigation_value_m3,
+                    irrigation_min_m3=MIN_IRRIGATION_M3,
+                    is_irrigated=irrigation_value_m3 > MIN_IRRIGATION_M3)
 
     should_run = all([
         no_irrigation_practice,
-        functional_unit == CycleFunctionalUnit._1_HA.value,
-        any([water_complete, irrigation_value_m3 > MIN_IRRIGATION_M3])
+        is_1_ha_functional_unit,
+        irrigation_value_m3 > MIN_IRRIGATION_M3
     ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, irrigation_value_m3
+    return should_run
 
 
 def run(cycle: dict):
-    should_run, irrigation_m3 = _should_run(cycle)
-    return _run(irrigation_m3) if should_run else []
+    should_run = _should_run(cycle)
+    return [_practice()] if should_run else []

hestia_earth/models/hestia/landCover.py

@@ -11,6 +11,7 @@ from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, to_precision
 
 from hestia_earth.models.log import logRequirements, log_as_table, logShouldRun
+from hestia_earth.models.utils import _omit
 from hestia_earth.models.utils.constant import DAYS_IN_YEAR
 from hestia_earth.models.utils.management import _new_management
 from hestia_earth.models.utils.term import get_lookup_value
@@ -40,7 +41,7 @@ REQUIREMENTS = {
             "permanent pasture",
             "other natural vegetation"
         ],
-        "country": "",
+        "country": {"@type": "Term", "termType": "region"},
         "management": [
             {
                 "@type": "Management",
@@ -56,11 +57,7 @@ REQUIREMENTS = {
 }
 RETURNS = {
     "Management": [{
-        "@type": "Management",
         "term.termType": "landCover",
-        "term.@id": [
-            "Forest", "Annual cropland", "Permanent cropland", "Permanent pasture", "Other natural vegetation"
-        ],
         "value": "",
         "endDate": "",
         "startDate": ""
@@ -95,6 +92,7 @@ SITE_TYPES = {
 DEFAULT_WINDOW_IN_YEARS = 20
 DATE_TOLERANCE_IN_YEARS = 2
 OUTPUT_SIGNIFICANT_DIGITS = 3
+ALLOWED_LAND_USE_TYPES = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE]
 _LOOKUP_EXPANSION = "region-crop-cropGroupingFaostatProduction-areaHarvestedUpTo20YearExpansion.csv"
 
 
@@ -755,16 +753,21 @@ def _collect_land_use_types(nodes: list) -> list:
     """Look up the land use type from management nodes."""
     return [
         {
+            "value": node.get("value", ""),
+            "term": node.get("term", {}),
             "id": node.get("term", {}).get("@id"),
             "land-use-type": _get_land_use_term_from_node(node),
-            "endDate": _gapfill_datestr(datestr=node.get("endDate"), mode=DatestrGapfillMode.END)[:10]
+            "endDate": _gapfill_datestr(datestr=node.get("endDate"), mode=DatestrGapfillMode.END)[:10],
+            "startDate": _gapfill_datestr(
+                datestr=node.get("startDate"), mode=DatestrGapfillMode.START
+            )[:10] if node.get("startDate") else None
         } for node in nodes
     ]
 
 
-def _no_prior_land_cover_data(nodes: list, end_date: str) -> bool:
+def _no_prior_land_cover_data(nodes: list, node: dict) -> bool:
     target_date = (
-        datetime.strptime(end_date, DatestrFormat.YEAR_MONTH_DAY.value)
+        datetime.strptime(node.get('startDate') or node.get('endDate'), DatestrFormat.YEAR_MONTH_DAY.value)
         - timedelta(days=DEFAULT_WINDOW_IN_YEARS * DAYS_IN_YEAR)
     )
     previous_nodes = [
@@ -774,45 +777,46 @@ def _no_prior_land_cover_data(nodes: list, end_date: str) -> bool:
     return len(previous_nodes) == 0
 
 
-def _should_run(site: dict, management_nodes: list) -> tuple[bool, dict]:
-    summarised_nodes = _collect_land_use_types(management_nodes)
-    allowed_land_use_types = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE]
+def _should_run(site: dict) -> tuple[bool, dict]:
+    management_nodes = _collect_land_use_types(
+        [
+            node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+            if not _should_group_landCover(node)
+        ]
+    )
     relevant_nodes = sorted(
         [
-            node for node in summarised_nodes
-            if node["land-use-type"] in allowed_land_use_types
+            node for node in management_nodes
+            if node["land-use-type"] in ALLOWED_LAND_USE_TYPES
         ],
-        key=lambda n: n.get("endDate")
+        key=lambda n: n.get("startDate") or n.get("endDate")
     )
+
     land_use_type = relevant_nodes[0].get("land-use-type") if relevant_nodes else None
 
     has_no_prior_land_cover_data = _no_prior_land_cover_data(
-        nodes=management_nodes,
-        end_date=relevant_nodes[-1:][0].get("endDate")
+        nodes=relevant_nodes,
+        node=relevant_nodes[-1:][0]
     ) if relevant_nodes else None
 
     should_run_nodes, site_area = _should_run_historical_land_use_change(
         site=site,
-        nodes=management_nodes,
+        nodes=relevant_nodes,
         land_use_type=land_use_type
     ) if all([land_use_type, has_no_prior_land_cover_data]) else (False, {})
 
     logRequirements(site, model=MODEL, model_key=MODEL_KEY,
-                    has_management_nodes=bool(management_nodes),
+                    has_management_nodes=bool(relevant_nodes),
                     land_use_type=land_use_type,
-                    allowed_land_use_types=';'.join(allowed_land_use_types),
+                    allowed_land_use_types=';'.join(ALLOWED_LAND_USE_TYPES),
                     has_no_prior_land_cover_data=has_no_prior_land_cover_data,
-                    summarised_nodes=log_as_table(summarised_nodes))
+                    management_nodes=log_as_table([_omit(n, ['term']) for n in relevant_nodes]))
 
     should_run = all([land_use_type, has_no_prior_land_cover_data, should_run_nodes])
     logShouldRun(site, MODEL, None, should_run, model_key=MODEL_KEY)
-    return should_run_nodes, site_area
+    return should_run_nodes, relevant_nodes, site_area
 
 
 def run(site: dict) -> list:
-    management_nodes = [
-        node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
-        if not _should_group_landCover(node)
-    ]
-    should_run, site_area = _should_run(site=site, management_nodes=management_nodes)
-    return _run(site, management_nodes, site_area) if should_run else []
+    should_run, relevant_nodes, site_area = _should_run(site=site)
+    return _run(site, relevant_nodes, site_area) if should_run else []

hestia_earth/models/hestia/landTransformation100YearAverageDuringCycle.py

@@ -2,7 +2,8 @@ from .resourceUse_utils import run_resource_use
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "Site": {
+        "site": {
+            "@type": "Site",
             "management": [{"@type": "Management", "value": ">=0", "term.termType": "landCover", "endDate": ""}]
         },
         "emissionsResourceUse": [