hestia-earth-models 0.64.8__py3-none-any.whl → 0.64.9__py3-none-any.whl

hestia_earth/models/cycle/siteArea.py

@@ -9,6 +9,7 @@ from hestia_earth.utils.model import filter_list_term_type, find_term_match
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import square_meter_to_hectare
 from . import MODEL
 
 REQUIREMENTS = {
@@ -48,7 +49,7 @@ def _run(cycle: dict):
     animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
     stocking_density = find_term_match(
         cycle.get('practices', []), 'stockingDensityAnimalHousingAverage', {}).get('value', [])
-    return round(list_sum([a.get('value') for a in animals]) / list_sum(stocking_density), 7)
+    return square_meter_to_hectare(round(list_sum([a.get('value') for a in animals]) / list_sum(stocking_density), 7))
 
 
 def _should_run(cycle: dict, site: dict, key=MODEL_KEY):

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandOccupation.py

@@ -1,41 +1,37 @@
+"""
+Characterises [soilQualityIndexLandOccupation](https://hestia.earth/term/soilQualityIndexLandOccupation)
+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 Tuple
+
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.lookup import download_lookup
-from hestia_earth.utils.tools import list_sum, non_empty_list
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
-from hestia_earth.models.utils import hectar_to_square_meter, days_to_years
-from hestia_earth.models.utils.blank_node import most_relevant_blank_node_by_type
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.landCover import get_pef_grouping
-from hestia_earth.models.utils.lookup import fallback_country
+from hestia_earth.models.utils.lookup import fallback_country, _node_value
 from . import MODEL
 from .utils import get_coefficient_factor
+from ..utils.impact_assessment import get_country_id
 
 REQUIREMENTS = {
     "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"}
-                }]
-            }
-        }
+        "optional": {"country": {"@type": "Term", "termType": "region"}},
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "value": ">0",
+            "term.@id": ["landOccupationInputsProduction", "landOccupationDuringCycle"],
+            "term.units": "m2*year",
+            "landCover": {"@type": "Term", "term.termType": "landCover"}
+        }]
     }
 }
+
 LOOKUPS = {
     "@doc": "Performs lookup on landCover.csv for column headers and region-pefTermGrouping-landOccupation.csv for CFs",
     "region-pefTermGrouping-landOccupation": "",
@@ -50,6 +46,8 @@ RETURNS = {
 TERM_ID = 'soilQualityIndexLandOccupation'
 LOOKUP = f"{list(LOOKUPS.keys())[1]}.csv"
 
+authorised_indicators = ["landOccupationInputsProduction", "landOccupationDuringCycle"]
+
 
 def _indicator(value: float):
     indicator = _new_indicator(TERM_ID, MODEL)
@@ -57,73 +55,66 @@ def _indicator(value: float):
     return indicator
 
 
-def _run(sites: list):
-    values = [site['coeff'] * hectar_to_square_meter(site['area']) * days_to_years(site['duration']) for site in sites]
-    return _indicator(list_sum(values)) if values else None
-
-
-def _should_run(impact_assessment: dict):
-    cycle = impact_assessment.get('cycle', {})
-    end_date = cycle.get('endDate')
-
-    has_site = bool(cycle.get('site', False))
-    has_other_sites = bool(cycle.get('otherSites', []))
+def _run(land_occupation_indicators: list):
+    values = [indicator['coefficient'] * indicator['area-by-year'] for indicator in land_occupation_indicators]
+    return _indicator(list_sum(values))
 
-    all_sites = non_empty_list([cycle.get('site')] + cycle.get('otherSites', []))
-    site_areas = [cycle.get('siteArea')] + cycle.get('otherSitesArea', [])
-    site_durations = [cycle.get('siteDuration')] + cycle.get('otherSitesDuration', [])
 
-    sites = [
-        {
-            'site-type': site.get('siteType'),
-            'country-id': site.get('country', {}).get('@id'),
-            '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,
-                date=end_date
-            ) or {}).get('term', {}).get('@id'),
-        }
-        for index, site in enumerate(all_sites)
+def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
+    land_occupation_indicators = [
+        i for i in filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE) if
+        i.get('landCover', {}).get('termType') == TermTermType.LANDCOVER.value and
+        i.get('term', {}).get('@id', '') in authorised_indicators
     ]
 
-    sites = [
-        site for site in sites
-        if all([
-            (site.get('area') or 0) > 0,
-            (site.get('duration') or 0) > 0,
-            site.get('landCover-id')
-        ])
-    ]
-
-    sites = [
-        site |
-        {
-            'coeff': get_coefficient_factor(
-                LOOKUP,
-                fallback_country(site.get('country-id'), [download_lookup(LOOKUP)]),
-                get_pef_grouping(site.get('landCover-id')),
+    found_land_occupation_indicators = [{
+        'area-by-year': _node_value(land_occupation_indicator),
+        'area-unit': land_occupation_indicator.get('term', {}).get("units"),
+        'land-cover-id': land_occupation_indicator.get('landCover', {}).get("@id"),
+        'country-id': get_country_id(impact_assessment),
+        'area-by-year-is-valid': _node_value(land_occupation_indicator) is not None and _node_value(
+            land_occupation_indicator) > 0,
+        'area-unit-is-valid': land_occupation_indicator.get('term', {}).get("units") == "m2*year",
+        'used-country': fallback_country(get_country_id(impact_assessment), [download_lookup(LOOKUP)]),
+
+    } for land_occupation_indicator in land_occupation_indicators]
+
+    found_indicators_with_coefficient = [
+        indicator | {
+            'coefficient': get_coefficient_factor(
+                LOOKUP, indicator['used-country'],
+                get_pef_grouping(indicator['land-cover-id']),
                 term_id=TERM_ID
-            )
-        } for site in sites
+            ),
+            "using-fallback-country-region-world-CFs": indicator['used-country'] != indicator['country-id']
+        } for indicator in found_land_occupation_indicators
     ]
-    valid_sites = [site for site in sites if site.get('coeff') is not None]
 
-    has_valid_sites = bool(valid_sites)
+    has_valid_land_occupations = all(
+        [
+            indicator['area-by-year-is-valid'] and indicator['area-unit-is-valid']
+            for indicator in found_land_occupation_indicators
+        ]) if found_land_occupation_indicators else False
+
+    valid_indicator_with_coef = [indicator for indicator in found_indicators_with_coefficient if
+                                 indicator['coefficient'] is not None and
+                                 indicator['area-by-year-is-valid'] and
+                                 indicator['area-unit-is-valid']]
 
-    logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_valid_sites=has_valid_sites,
-                    has_site=has_site,
-                    has_other_sites=has_other_sites,
-                    valid_sites=log_as_table(valid_sites),
+    has_land_occupation_indicators = bool(land_occupation_indicators)
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_land_occupation_indicators=has_land_occupation_indicators,
+                    has_valid_land_occupations=has_valid_land_occupations,
+                    land_occupation_indicators=log_as_table(found_indicators_with_coefficient)
                     )
 
-    should_run = all([has_valid_sites])
-    logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, valid_sites
+    should_run = has_land_occupation_indicators and has_valid_land_occupations
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_indicator_with_coef
 
 
 def run(impact_assessment: dict):
-    should_run, sites = _should_run(impact_assessment)
-    return _run(sites) if should_run else None
+    should_run, land_occupation_indicators = _should_run(impact_assessment)
+    return _run(land_occupation_indicators) if should_run else None

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -4,53 +4,53 @@ 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 typing import List, Tuple, Optional
 
 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.utils.tools import list_sum
 
 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.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
+from ..utils.lookup import fallback_country, _node_value
+from ..utils.term import download_all_land_cover_terms
 
 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"}}
-                }]
+        "emissionsResourceUse": [
+            {
+                "@type": "Indicator",
+                "term.units": "m2 / year",
+                "term.termType": "resourceUse",
+                "term.name": "Land transformation from",
+                "value": "> 0",
+                "landCover": {"@type": "Term", "term.termType": "landCover"}
             }
-        }
+        ],
+        "optional": {"country": {"@type": "Term", "termType": "region"}}
     }
 }
 
+# Note: 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.
 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": "",
+    "region-pefTermGrouping-landTransformation-from": "using country and `pefTermGrouping` from `landCover`",
+    "region-pefTermGrouping-landTransformation-to": "using country and `pefTermGrouping` from `landCover`",
     "landCover": "pefTermGrouping"
 }
 
-from_lookup_file = f"{list(LOOKUPS.keys())[1]}.csv"
-to_lookup_file = f"{list(LOOKUPS.keys())[2]}.csv"
+from_lookup_file = f"{list(LOOKUPS.keys())[0]}.csv"
+to_lookup_file = f"{list(LOOKUPS.keys())[1]}.csv"
+
+LOOKUP = {
+    "from": from_lookup_file,
+    "to": to_lookup_file
+}
 
 RETURNS = {
     "Indicator": {
@@ -67,116 +67,102 @@ def _indicator(value: float):
     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 _run(transformations: List[dict]):
+    values = [(transformation['factor-from'] + transformation['factor-to']) * transformation['area'] for transformation
+              in transformations]
+    return _indicator(list_sum(values))
 
 
-def _should_run(impact_assessment: dict):
-    cycle = impact_assessment.get('cycle', {})
+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
 
-    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', []))
+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
 
-    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)
-    ]
+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 = [term.get("@id") for term in download_all_land_cover_terms()] if resource_uses else []
 
-    sites = [
-        site for site in sites
-        if all([
-            (site.get('area') or 0) > 0,
-            site.get('transformation_pairs', [])
-        ])
-    ]
+    land_transformation_indicators = [i for i in resource_uses if _is_valid_indicator(i, land_cover_term_ids)]
 
-    sites = [
-        site |
+    found_transformations = [
         {
-            '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
+            '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-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
     ]
 
-    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
+    found_transformations_with_coefficient = [
+        transformation | {
+            "using-fallback-country-region-world-CFs": transformation['lookup-country'] != transformation['country-id'],
+            'factor-from': get_coefficient_factor(
+                lookup_name=from_lookup_file,
+                country_id=transformation['lookup-country'],
+                term_id=TERM_ID,
+                occupation_type=get_pef_grouping(transformation['land-cover-id-from'])) if
+            transformation['land-cover-id-from'] else None,
+            'factor-to': get_coefficient_factor(
+                lookup_name=to_lookup_file,
+                country_id=transformation['lookup-country'],
+                term_id=TERM_ID,
+                occupation_type=get_pef_grouping(transformation['land-cover-id-to'])) if
+            transformation['land-cover-id-to'] else None
+        } for transformation in found_transformations
     ]
 
-    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
+    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
+        ])
     ]
 
-    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]
+    has_land_transformation_indicators = bool(land_transformation_indicators)
+
+    all_transformations_are_valid = all(
+        [
+            all([t['area-is-valid'], t['area-unit-is-valid'], t['good-land-cover-term']])
+            for t in found_transformations_with_coefficient
+        ]
+    ) if found_transformations_with_coefficient else False
 
     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)
+                    has_land_occupation_indicators=has_land_transformation_indicators,
+                    all_transformations_are_valid=all_transformations_are_valid,
+                    has_valid_transformations_with_coef=bool(valid_transformations_with_coef),
+                    found_transformations=log_as_table(found_transformations_with_coefficient)
                     )
-    should_run = has_valid_sites
 
-    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    should_run = has_land_transformation_indicators is False or all([has_land_transformation_indicators,
+                                                                     all_transformations_are_valid])
 
-    return should_run, valid_sites
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_transformations_with_coef
 
 
 def run(impact_assessment: dict):
-    should_run, sites = _should_run(impact_assessment)
-    return _run(sites) if should_run else None
+    should_run, transformations = _should_run(impact_assessment)
+    return _run(transformations) if should_run else None

hestia_earth/models/environmentalFootprintV3/soilQualityIndexTotalLandUseEffects.py

@@ -5,6 +5,7 @@ http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LAN
 Factors version 2.5 (Horn and Meier, 2018).
 """
 from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from . import MODEL
@@ -35,32 +36,42 @@ def _indicator(value: float):
     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 _run(indicators: list):
+    values = [indicator['value'] for indicator in indicators]
+    return _indicator(list_sum(values))
 
 
-def _should_run(impactassessment: dict):
-    land_occupation_indicator = find_term_match(impactassessment.get('emissionsResourceUse', []),
-                                                "soilQualityIndexLandOccupation")
-    transformation_indicator = find_term_match(impactassessment.get('emissionsResourceUse', []),
-                                               "soilQualityIndexLandTransformation")
+def _should_run(impactassessment: dict) -> tuple[bool, list]:
+    land_indicators = [
+        i for i in impactassessment.get('emissionsResourceUse', []) if
+        i.get('term', {}).get('@id', '') in ['soilQualityIndexLandOccupation', 'soilQualityIndexLandTransformation']
+    ]
+    has_indicators = bool(land_indicators)
 
-    has_valid_values = all([isinstance(land_occupation_indicator.get('value', None), (int, float)),
-                            isinstance(transformation_indicator.get('value', None), (int, float))])
+    land_occupation_indicator = find_term_match(land_indicators, "soilQualityIndexLandOccupation",
+                                                default_val=None)
+    has_land_occupation_indicator = bool(land_occupation_indicator)
+
+    land_transformation_indicator = find_term_match(land_indicators, "soilQualityIndexLandTransformation",
+                                                    default_val=None)
+    has_land_transformation_indicator = bool(land_transformation_indicator)
+
+    has_valid_values = all([isinstance(indicator.get('value', None), (int, float)) for indicator in land_indicators])
 
     logRequirements(impactassessment, model=MODEL, term=TERM_ID,
-                    transformation_indicator=transformation_indicator,
-                    land_occupation_indicator=land_occupation_indicator,
+                    has_indicators=has_indicators,
+                    has_land_occupation_indicator=has_land_occupation_indicator,
+                    has_land_transformation_indicator=has_land_transformation_indicator,
                     has_valid_values=has_valid_values
                     )
 
-    should_run = all([transformation_indicator, land_occupation_indicator, has_valid_values])
+    should_run = all([has_indicators, has_valid_values,
+                      has_land_occupation_indicator, has_land_transformation_indicator])
 
     logShouldRun(impactassessment, MODEL, TERM_ID, should_run)
-    return should_run, land_occupation_indicator, transformation_indicator
+    return should_run, land_indicators
 
 
 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
+    should_run, indicators = _should_run(impactassessment)
+    return _run(indicators) if should_run else None

hestia_earth/models/faostat2018/landTransformationFromCropland100YearAverage.py

@@ -20,7 +20,8 @@ LOOKUPS = {
 }
 RETURNS = {
     "Indicator": [{
-        "value": ""
+        "value": "",
+        "landCover": ""
     }]
 }
 TERM_ID = 'landTransformationFromTemporaryCropland100YearAverageDuringCycle,landTransformationFromPermanentCropland100YearAverageDuringCycle'  # noqa: E501
@@ -30,7 +31,7 @@ PERMANENT_TERM_ID = 'landTransformationFromPermanentCropland100YearAverageDuring
 
 
 def _indicator(term_id: str, value: float):
-    indicator = _new_indicator(term_id, MODEL)
+    indicator = _new_indicator(term_id, MODEL, 'cropland')
     indicator['value'] = value
     return indicator
 

hestia_earth/models/faostat2018/landTransformationFromCropland20YearAverage.py

@@ -20,7 +20,8 @@ LOOKUPS = {
 }
 RETURNS = {
     "Indicator": [{
-        "value": ""
+        "value": "",
+        "landCover": ""
     }]
 }
 TERM_ID = 'landTransformationFromTemporaryCropland20YearAverageDuringCycle,landTransformationFromPermanentCropland20YearAverageDuringCycle'  # noqa: E501
@@ -30,7 +31,7 @@ PERMANENT_TERM_ID = 'landTransformationFromPermanentCropland20YearAverageDuringC
 
 
 def _indicator(term_id: str, value: float):
-    indicator = _new_indicator(term_id, MODEL)
+    indicator = _new_indicator(term_id, MODEL, 'cropland')
     indicator['value'] = value
     return indicator