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

hestia_earth/models/agribalyse2016/fuelElectricity.py

@@ -108,7 +108,7 @@ def _should_run(cycle: dict):
     has_operations = len(operations) > 0
 
     logRequirements(cycle, model=MODEL, model_key=MODEL_KEY,
-                    is_incomplete=is_incomplete,
+                    is_term_type_electricityFuel_incomplete=is_incomplete,
                     has_operations=has_operations,
                     operations=';'.join(non_empty_list(map(lambda v: v.get('term', {}).get('@id'), operations))))
 

hestia_earth/models/cache_sites.py

@@ -46,13 +46,13 @@ def _run_values(sites: list, param_type: ParamType, rasters: list = [], vectors:
         'ee_type': 'raster',
         'collections': rasters,
         param_type.value: param_values
-    })
+    }) if rasters else []
 
     vector_results = _run_query({
         'ee_type': 'vector',
         'collections': vectors,
         param_type.value: param_values
-    })
+    }) if vectors else []
 
     def _process_site(site_values: tuple):
         site, area_size = site_values
@@ -114,7 +114,7 @@ def _group_sites(sites: dict, check_has_cache: bool = True):
     }
 
 
-def _run(sites: list, years: list, include_region: bool, years_only: bool = False):
+def _run(sites: list, years: list = [], include_region: bool = False, years_only: bool = False):
     rasters, vectors = list_collections(years, include_region, years_only)
     filtered_data = _group_sites(sites, not years_only)
     return flatten([
@@ -123,15 +123,6 @@ def _run(sites: list, years: list, include_region: bool, years_only: bool = Fals
     ])
 
 
-def _group_years(years: list, years_range: int):
-    batches = sorted(list(set(list(range(years[0], years[-1] + 1, years_range)) + [years[0], years[-1]])))
-    grouped_batches = [batches[i:i+2] for i in range(0, len(batches))]
-    return [
-        # make sure we don't overlap
-        [v[0] + (0 if v[0] == years[0] else 1), v[1]] for v in grouped_batches if len(v) == 2
-    ]
-
-
 def run(sites: list, years: list = None, include_region: bool = False):
     """
     Run all queries at once for the list of provided Sites.
@@ -147,15 +138,15 @@ def run(sites: list, years: list = None, include_region: bool = False):
         Prefecth region IDs.
         This will cache region-level data and will make the request slower. Only use if needed.
     """
-    try:
-        return _run(sites, years, include_region)
-    except Exception as e:
-        # when querying with multiple years, we can reach a compute memory limit, so run the years separately
-        if str(e) == 'User memory limit exceeded.' and years:
-            sites = _run(sites, [], include_region)
-            # query for subranges
-            for sub_years in _group_years(years, years_range=5):
-                sites = _run(sites, sub_years, include_region, years_only=True)
-            return sites
-
-    return []
+    sites = _run(sites, include_region=include_region)
+
+    # avoid memory limit errors by running only a few years at a time
+    unique_years = sorted(list(set(years)))
+    batch_size = 5
+    batches = range(0, len(unique_years), batch_size)
+
+    for batch_index in batches:
+        sub_years = unique_years[batch_index:batch_index + batch_size]
+        sites = _run(sites, sub_years, include_region, years_only=True)
+
+    return sites

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandTransformation.py

@@ -29,8 +29,7 @@ REQUIREMENTS = {
         },
         "optional": {
             "emissionsResourceUse": [
-                {"@type": "Indicator", "value": "", "term.@id": "landTransformationFromForest20YearAverageDuringCycle"},
-                {"@type": "Indicator", "value": "", "term.@id": "landTransformationFromOtherNaturalVegetation20YearAverageDuringCycle"}  # noqa: E501
+                {"@type": "Indicator", "value": "", "term.@id": "landTransformation20YearAverageDuringCycle"}
             ]
         }
     }
@@ -46,11 +45,9 @@ LOOKUPS = {
     "region-siteType-LandTransformationChaudaryBrooks2018CF": "using `country`"
 }
 TERM_ID = 'damageToTerrestrialEcosystemsLandTransformation'
-LOOKUP_SUFFIX = 'LandTransformationChaudaryBrooks2018CF'
-TRANSFORMATION_TERM_IDS = [
-    'landTransformationFromForest20YearAverageDuringCycle',
-    'landTransformationFromOtherNaturalVegetation20YearAverageDuringCycle'
-]
+
+_LOOKUP_SUFFIX = 'LandTransformationChaudaryBrooks2018CF'
+_TRANSFORMATION_TERM_ID = 'landTransformation20YearAverageDuringCycle'
 
 
 def _indicator(value: float):
@@ -68,8 +65,8 @@ def _value(impact_assessment: dict, term_id: str):
 def _run(impact_assessment: dict):
     cycle = impact_assessment.get('cycle', {})
     product = get_product(impact_assessment)
-    landTransformation = sum_values([_value(impact_assessment, term_id) for term_id in TRANSFORMATION_TERM_IDS])
-    region_factor = get_region_factor(TERM_ID, impact_assessment, LOOKUP_SUFFIX, 'medium_intensity')
+    landTransformation = _value(impact_assessment, _TRANSFORMATION_TERM_ID)
+    region_factor = get_region_factor(TERM_ID, impact_assessment, _LOOKUP_SUFFIX, 'medium_intensity')
     inputs_value = convert_value_from_cycle(
         product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
     )

hestia_earth/models/cycle/input/hestiaAggregatedData.py

@@ -5,12 +5,20 @@ This model adds `impactAssessment` to inputs based on data which has been aggreg
 Note: to get more accurate impacts, we recommend setting the
 [input.impactAssessment](https://hestia.earth/schema/Input#impactAssessment)
 instead of the region-level averages using this model.
+
+For `seed` inputs, we will match ImpactAssessment in the following order of priority:
+- match using the value from the lookup `linkedImpactAssessmentTermId`;
+- match using the primary crop product;
+- match using the "generic" crop product term.
 """
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import find_primary_product, find_term_match, linked_node
+from hestia_earth.utils.api import download_hestia
+from hestia_earth.utils.model import find_primary_product, linked_node, filter_list_term_type
+from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils.crop import valid_site_type
+from hestia_earth.models.utils.blank_node import get_lookup_value
 from hestia_earth.models.utils.term import get_generic_crop
 from hestia_earth.models.utils.aggregated import (
     should_link_input_to_impact, link_inputs_to_impact, find_closest_impact, aggregated_end_date
@@ -55,28 +63,35 @@ RETURNS = {
         "impactAssessmentIsProxy": "True"
     }]
 }
+LOOKUPS = {
+    "seed": "linkedImpactAssessmentTermId"
+}
 MODEL_ID = 'hestiaAggregatedData'
 MODEL_KEY = 'impactAssessment'
-SEED_TERM_ID = 'seed'
 
 
-def _run_seed(cycle: dict, primary_product: dict, seed_input: dict):
+def _run_seed(cycle: dict, primary_product: dict, seed_input: dict, product_term_id: str):
+    product = download_hestia(product_term_id)
     region = seed_input.get('region')
     country = seed_input.get('country')
     # to avoid double counting seed => aggregated impact => seed, we need to get the impact of the previous decade
     # if the data does not exist, use the aggregated impact of generic crop instead
     date = aggregated_end_date(cycle.get('endDate'))
-    impact = find_closest_impact(cycle, date, primary_product, region, country, [
+    match_end_date = [
         {'match': {'endDate': date - 10}}
-    ]) or find_closest_impact(cycle, date, {'term': get_generic_crop()}, region, country)
+    ]
+
+    impact = find_closest_impact(cycle, date, {'term': product}, region, country, match_end_date) or \
+        find_closest_impact(cycle, date, primary_product, region, country, match_end_date) or \
+        find_closest_impact(cycle, date, {'term': get_generic_crop()}, region, country)
 
-    debugValues(cycle, model=MODEL_ID, term=SEED_TERM_ID, key=MODEL_KEY,
+    debugValues(cycle, model=MODEL_ID, term=seed_input.get('term', {}).get('@id'), key=MODEL_KEY,
                 input_region=(region or {}).get('@id'),
                 input_country=(country or {}).get('@id'),
                 date=date,
                 impact=(impact or {}).get('@id'))
 
-    return [{**seed_input, MODEL_KEY: linked_node(impact), 'impactAssessmentIsProxy': True}] if impact else []
+    return seed_input | {MODEL_KEY: linked_node(impact), 'impactAssessmentIsProxy': True} if impact else None
 
 
 def _should_run_seed(cycle: dict):
@@ -84,27 +99,33 @@ def _should_run_seed(cycle: dict):
     product_id = primary_product.get('term', {}).get('@id')
     term_type = primary_product.get('term', {}).get('termType')
     is_crop_product = term_type == TermTermType.CROP.value
-    input = find_term_match(cycle.get('inputs', []), SEED_TERM_ID, None)
-    has_input = input is not None
     site_type_valid = valid_site_type(cycle, True)
 
-    should_run = all([site_type_valid, is_crop_product, has_input])
+    seed_inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.SEED)
+    seed_inputs = [
+        {
+            'input': seed_input,
+            'product': get_lookup_value(seed_input.get('term', {}), LOOKUPS['seed'], key=MODEL_KEY)
+        }
+        for seed_input in seed_inputs
+    ]
+
+    should_run = all([site_type_valid, is_crop_product, bool(seed_inputs)])
 
-    # ignore logs if seed is not present
-    if has_input:
-        debugValues(cycle, model=MODEL_ID, term=SEED_TERM_ID, key=MODEL_KEY,
-                    primary_product_id=product_id,
-                    primary_product_term_type=term_type)
+    for seed_input in seed_inputs:
+        term_id = seed_input.get('input').get('term', {}).get('@id')
+        linked_product_id = seed_input.get('product')
 
-        logRequirements(cycle, model=MODEL_ID, term=SEED_TERM_ID, key=MODEL_KEY,
+        logRequirements(cycle, model=MODEL_ID, term=term_id, key=MODEL_KEY,
                         site_type_valid=site_type_valid,
                         is_crop_product=is_crop_product,
-                        has_input=has_input)
+                        primary_product_id=product_id,
+                        linked_product_id=linked_product_id)
 
-        logShouldRun(cycle, MODEL_ID, SEED_TERM_ID, should_run)
-        logShouldRun(cycle, MODEL_ID, SEED_TERM_ID, should_run, key=MODEL_KEY)  # show specifically under Input
+        logShouldRun(cycle, MODEL_ID, term_id, should_run)
+        logShouldRun(cycle, MODEL_ID, term_id, should_run, key=MODEL_KEY)  # show specifically under Input
 
-    return should_run, primary_product, input
+    return should_run, primary_product, seed_inputs
 
 
 def _should_run(cycle: dict):
@@ -124,9 +145,12 @@ def _should_run(cycle: dict):
 
 def run(cycle: dict):
     should_run, inputs = _should_run(cycle)
-    should_run_seed, primary_product, seed_input = _should_run_seed(cycle)
+    should_run_seed, primary_product, seed_inputs = _should_run_seed(cycle)
     return (
         link_inputs_to_impact(MODEL_ID, cycle, inputs) if should_run else []
     ) + (
-        _run_seed(cycle, primary_product, seed_input) if should_run_seed else []
+        non_empty_list([
+            _run_seed(cycle, primary_product, seed_input.get('input'), seed_input.get('product'))
+            for seed_input in seed_inputs
+        ]) if should_run_seed else []
     )

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/pre_checks/cache_sources.py

@@ -1,11 +1,9 @@
 """
 Pre Checks Cache Sources
 
-This model caches the sources of all models.
+This model caches the sources of all Cycle models.
 """
-from hestia_earth.models.log import debugValues
-from hestia_earth.models.utils import CACHE_KEY, cached_value
-from hestia_earth.models.utils.source import CACHE_SOURCES_KEY, find_sources
+from hestia_earth.models.utils.cache_sources import cache_sources
 
 REQUIREMENTS = {
     "Cycle": {}
@@ -15,24 +13,4 @@ RETURNS = {
 }
 
 
-def _should_run(site: dict):
-    sources = find_sources()
-    has_cache = cached_value(site, CACHE_SOURCES_KEY) is not None
-
-    debugValues(site,
-                sources=';'.join([str(title) for title in sources.keys()]),
-                has_cache=has_cache)
-
-    should_run = all([
-        not has_cache,
-        len(sources) > 0
-    ])
-    return should_run, sources
-
-
-def run(site: dict):
-    should_run, sources = _should_run(site)
-    return {
-        **site,
-        CACHE_KEY: cached_value(site) | {CACHE_SOURCES_KEY: sources}
-    } if should_run else site
+def run(cycle: dict): return cache_sources(cycle)

hestia_earth/models/cycle/product/economicValueShare.py

@@ -140,7 +140,7 @@ def _should_run_by_revenue(cycle: dict, products: list):
     for p in products:
         term_id = p.get('term', {}).get('@id')
         logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
-                        is_complete=is_complete,
+                        is_term_type_product_complete=is_complete,
                         total_economicValueShare=total_economicValueShare,
                         below_threshold=below_threshold,
                         all_with_revenue=all_with_revenue,
@@ -168,7 +168,7 @@ def _should_run_single_missing_evs(cycle: dict, products: list):
     term_id = missing_values[0].get('term', {}).get('@id') if single_missing_value else None
 
     logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
-                    is_complete=is_complete,
+                    is_term_type_product_complete=is_complete,
                     total_value=total_value,
                     below_threshold=below_threshold,
                     single_missing_value=single_missing_value)

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -4,7 +4,7 @@ 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, Tuple, Optional
+from typing import List, Tuple
 
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.lookup import download_lookup
@@ -18,18 +18,17 @@ from ..utils.impact_assessment import get_country_id
 from ..utils.indicator import _new_indicator
 from ..utils.landCover import get_pef_grouping
 from ..utils.lookup import fallback_country, _node_value
-from ..utils.term import get_land_cover_terms
 
 REQUIREMENTS = {
     "ImpactAssessment": {
         "emissionsResourceUse": [
             {
                 "@type": "Indicator",
-                "term.units": "m2 / year",
                 "term.termType": "resourceUse",
-                "term.name": "Land transformation from",
+                "term.name": "Land transformation",
                 "value": "> 0",
-                "landCover": {"@type": "Term", "term.termType": "landCover"}
+                "landCover": {"@type": "Term", "term.termType": "landCover"},
+                "previousLandCover": {"@type": "Term", "term.termType": "landCover"}
             }
         ],
         "optional": {"country": {"@type": "Term", "termType": "region"}}
@@ -73,44 +72,21 @@ def _run(transformations: List[dict]):
     return _indicator(list_sum(values))
 
 
-def _extract_land_cover_from_indicator_id(indicator: dict) -> Optional[str]:
-    """
-    Given a indicator with term type `resourceUse` return the equivalent `landCover` term
-    """
-    term_in_id = indicator.get('term', {}).get('@id', '') \
-        .removeprefix("landTransformationFrom") \
-        .removesuffix("20YearAverageInputsProduction") \
-        .removesuffix("20YearAverageDuringCycle")
-    term_in_id = term_in_id[0].lower() + term_in_id[1:] if term_in_id else None
-    return term_in_id
-
-
-def _is_valid_indicator(indicator: dict, land_cover_term_ids: list[str]) -> bool:
-    term_id = _extract_land_cover_from_indicator_id(indicator)
-    return term_id in land_cover_term_ids
-
-
 def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     resource_uses = filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE)
-    land_cover_term_ids = get_land_cover_terms() if resource_uses else []
-
-    land_transformation_indicators = [i for i in resource_uses if _is_valid_indicator(i, land_cover_term_ids)]
-
     found_transformations = [
         {
             'area': _node_value(transformation_indicator) * 20,
-            'area-unit': transformation_indicator.get('term', {}).get("units"),
-            'land-cover-id-from': _extract_land_cover_from_indicator_id(transformation_indicator),
+            'land-cover-id-from': transformation_indicator.get('previousLandCover', {}).get("@id"),
             'land-cover-id-to': transformation_indicator.get('landCover', {}).get("@id"),
             'indicator-id': transformation_indicator.get('term', {}).get('@id', ''),
             'good-land-cover-term': transformation_indicator.get('landCover', {}).get('termType') == 'landCover',
             'country-id': get_country_id(impact_assessment),
             'area-is-valid': _node_value(transformation_indicator) is not None and _node_value(
                 transformation_indicator) > 0,
-            'area-unit-is-valid': transformation_indicator.get('term', {}).get("units") == "m2 / year",
             'lookup-country': fallback_country(get_country_id(impact_assessment),
                                                [download_lookup(from_lookup_file), download_lookup(to_lookup_file)]),
-        } for transformation_indicator in land_transformation_indicators
+        } for transformation_indicator in resource_uses
     ]
 
     found_transformations_with_coefficient = [
@@ -134,17 +110,19 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     valid_transformations_with_coef = [
         t for t in found_transformations_with_coefficient if all([
             t['area-is-valid'],
-            t['area-unit-is-valid'],
             t['factor-from'] is not None,
             t['factor-to'] is not None
         ])
     ]
 
-    has_land_transformation_indicators = bool(land_transformation_indicators)
+    has_land_transformation_indicators = any([
+        indicator.get('term', {}).get('@id').startswith('landTransformation')
+        for indicator in resource_uses
+    ])
 
     all_transformations_are_valid = all(
         [
-            all([t['area-is-valid'], t['area-unit-is-valid'], t['good-land-cover-term']])
+            all([t['area-is-valid'], t['good-land-cover-term']])
             for t in found_transformations_with_coefficient
         ]
     ) if found_transformations_with_coefficient else False

hestia_earth/models/faostat2018/landTransformation100YearAverageDuringCycle.py

@@ -0,0 +1,34 @@
+from .utils import should_run_landTransformationFromCropland, run_landTransformationFromCropland
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "endDate": "",
+        "country": {"@type": "Term", "termType": "region"},
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "term.@id": "landTransformation100YearAverageDuringCycle",
+            "value": "",
+            "previousLandCover": {
+                "@type": "Term",
+                "termType": "landCover",
+                "@id": "cropland"
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-faostatArea": ""
+}
+RETURNS = {
+    "Indicator": [{
+        "value": "",
+        "landCover": "",
+        "previousLandCover": ""
+    }]
+}
+TERM_ID = 'landTransformation100YearAverageDuringCycle'
+
+
+def run(impact: dict):
+    should_run, indicators = should_run_landTransformationFromCropland(TERM_ID, impact)
+    return run_landTransformationFromCropland(TERM_ID, impact, indicators, 100) if should_run else []

hestia_earth/models/faostat2018/landTransformation20YearAverageDuringCycle.py

@@ -0,0 +1,34 @@
+from .utils import should_run_landTransformationFromCropland, run_landTransformationFromCropland
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "endDate": "",
+        "country": {"@type": "Term", "termType": "region"},
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "term.@id": "landTransformation20YearAverageDuringCycle",
+            "value": "",
+            "previousLandCover": {
+                "@type": "Term",
+                "termType": "landCover",
+                "@id": "cropland"
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-faostatArea": ""
+}
+RETURNS = {
+    "Indicator": [{
+        "value": "",
+        "landCover": "",
+        "previousLandCover": ""
+    }]
+}
+TERM_ID = 'landTransformation20YearAverageDuringCycle'
+
+
+def run(impact: dict):
+    should_run, indicators = should_run_landTransformationFromCropland(TERM_ID, impact)
+    return run_landTransformationFromCropland(TERM_ID, impact, indicators, 20) if should_run else []