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

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/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/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/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],
-            'duration': site_durations[index],
-            '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

@@ -0,0 +1,168 @@
+"""
+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, 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
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+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, _node_value
+from ..utils.term import download_all_land_cover_terms
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "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 = {
+    "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())[0]}.csv"
+to_lookup_file = f"{list(LOOKUPS.keys())[1]}.csv"
+
+LOOKUP = {
+    "from": from_lookup_file,
+    "to": to_lookup_file
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+TERM_ID = 'soilQualityIndexLandTransformation'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(transformations: List[dict]):
+    values = [(transformation['factor-from'] + transformation['factor-to']) * transformation['area'] for transformation
+              in transformations]
+    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 = [term.get("@id") for term in download_all_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-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
+    ]
+
+    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_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)
+
+    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_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_land_transformation_indicators is False or all([has_land_transformation_indicators,
+                                                                     all_transformations_are_valid])
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_transformations_with_coef
+
+
+def run(impact_assessment: dict):
+    should_run, transformations = _should_run(impact_assessment)
+    return _run(transformations) if should_run else None

hestia_earth/models/environmentalFootprintV3/soilQualityIndexTotalLandUseEffects.py

@@ -0,0 +1,77 @@
+"""
+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.utils.tools import list_sum
+
+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(indicators: list):
+    values = [indicator['value'] for indicator in indicators]
+    return _indicator(list_sum(values))
+
+
+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)
+
+    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,
+                    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([has_indicators, has_valid_values,
+                      has_land_occupation_indicator, has_land_transformation_indicator])
+
+    logShouldRun(impactassessment, MODEL, TERM_ID, should_run)
+    return should_run, land_indicators
+
+
+def run(impactassessment: dict):
+    should_run, indicators = _should_run(impactassessment)
+    return _run(indicators) if should_run else None

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/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