hestia-earth-models 0.64.14__tar.gz → 0.65.1__tar.gz

{hestia_earth_models-0.64.14 → hestia_earth_models-0.65.1}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019-2024 Harmonised Environmental Storage and Tracking of the Impacts of Agriculture (HESTIA) Project
+Copyright (c) 2019-2025 Harmonised Environmental Storage and Tracking of the Impacts of Agriculture (HESTIA) Project
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{hestia_earth_models-0.64.14 → hestia_earth_models-0.65.1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.64.14
+Version: 0.65.1
 Summary: HESTIA's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: HESTIA Team
 Author-email: guillaumeroyer.mail@gmail.com
-License: GPL
+License: MIT
 Platform: UNKNOWN
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3.6

{hestia_earth_models-0.64.14 → hestia_earth_models-0.65.1}/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-0.64.14 → hestia_earth_models-0.65.1}/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-0.64.14 → hestia_earth_models-0.65.1}/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-0.64.14 → hestia_earth_models-0.65.1}/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-0.65.1/hestia_earth/models/cycle/pre_checks/cache_sources.py

@@ -0,0 +1,16 @@
+"""
+Pre Checks Cache Sources
+
+This model caches the sources of all Cycle models.
+"""
+from hestia_earth.models.utils.cache_sources import cache_sources
+
+REQUIREMENTS = {
+    "Cycle": {}
+}
+RETURNS = {
+    "Cycle": {}
+}
+
+
+def run(cycle: dict): return cache_sources(cycle)

{hestia_earth_models-0.64.14 → hestia_earth_models-0.65.1}/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-0.64.14 → hestia_earth_models-0.65.1}/hestia_earth/models/ecoinventV3/__init__.py

@@ -134,9 +134,10 @@ def _run_input(cycle: dict):
         logRequirements(cycle, model=MODEL, term=input_term_id,
                         has_ecoinvent_mappings=has_mappings,
                         ecoinvent_mappings=';'.join([v[0] for v in mappings]),
-                        has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions)
+                        has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
+                        input_value=input_value)
 
-        should_run = all([has_mappings, has_no_gap_filled_background_emissions])
+        should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
         grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
         return [

{hestia_earth_models-0.64.14 → hestia_earth_models-0.65.1}/hestia_earth/models/ecoinventV3/utils.py

@@ -1,5 +1,5 @@
 from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import list_sum, flatten, non_empty_list
+from hestia_earth.utils.tools import flatten, non_empty_list
 
 from hestia_earth.models.utils.term import get_lookup_value
 
@@ -12,7 +12,6 @@ def _animal_inputs(animal: dict):
 def _should_run_input(products: list):
     def should_run(input: dict):
         return all([
-            list_sum(input.get('value', [])) > 0,
             # make sure Input is not a Product as well or we might double-count emissions
             find_term_match(products, input.get('term', {}).get('@id'), None) is None,
             # ignore inputs which are flagged as Product of the Cycle

{hestia_earth_models-0.64.14 → hestia_earth_models-0.65.1}/hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -122,9 +122,10 @@ def _run_input(cycle: dict):
 
         logRequirements(cycle, model=MODEL, term=input_term_id,
                         has_ecoinvent_mappings=has_mappings,
-                        ecoinvent_mappings=';'.join([v[0] for v in mappings]))
+                        ecoinvent_mappings=';'.join([v[0] for v in mappings]),
+                        input_value=input_value)
 
-        should_run = all([electricity_complete, has_mappings])
+        should_run = all([electricity_complete, has_mappings, input_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
 
         grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}

{hestia_earth_models-0.64.14 → hestia_earth_models-0.65.1}/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"}}
@@ -68,54 +67,33 @@ def _indicator(value: float):
 
 
 def _run(transformations: List[dict]):
-    values = [(transformation['factor-from'] + transformation['factor-to']) * transformation['area'] for transformation
-              in transformations]
+    values = [
+        (transformation.get('factor-from', 0) + transformation.get('factor-to', 0)) * transformation.get('area', 0) * 20
+        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 = 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),
+            'area': _node_value(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 = [
         transformation | {
-            "using-fallback-country-region-world-CFs": transformation['lookup-country'] != transformation['country-id'],
+            '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'],
@@ -134,17 +112,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-0.65.1/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-0.65.1/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 []

{hestia_earth_models-0.64.14 → hestia_earth_models-0.65.1}/hestia_earth/models/faostat2018/utils.py

@@ -1,14 +1,16 @@
+from numpy import recarray
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data_closest_date
-from hestia_earth.utils.tools import safe_parse_float
-from numpy import recarray
+from hestia_earth.utils.tools import safe_parse_float, flatten
 
-from hestia_earth.models.log import logger, debugMissingLookup
+from hestia_earth.models.log import logger, debugMissingLookup, logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.animalProduct import (
     FAO_LOOKUP_COLUMN, FAO_EQUIVALENT_LOOKUP_COLUMN, get_animalProduct_lookup_value
 )
 from hestia_earth.models.utils.product import convert_product_to_unit
+from hestia_earth.models.utils.impact_assessment import get_country_id, impact_end_year
+from hestia_earth.models.utils.indicator import _new_indicator
 from . import MODEL
 
 LOOKUP_PREFIX = f"{TermTermType.REGION.value}-{TermTermType.ANIMALPRODUCT.value}-{FAO_LOOKUP_COLUMN}"
@@ -140,3 +142,45 @@ def get_change_in_harvested_area_for_crop(country_id: str, crop_name: str, start
         return _split_delta(
             get_table_value(lookup, 'termid', country_id, column_name(crop_name)), start_year, end_year
         )
+
+
+def should_run_landTransformationFromCropland(term_id: str, impact: dict):
+    indicators = [
+        i for i in impact.get('emissionsResourceUse', [])
+        if all([
+            i.get('term', {}).get('@id') == term_id,
+            i.get('previousLandCover', {}).get('@id') == 'cropland',
+            (i.get('value') or -1) > 0
+        ])
+    ]
+    has_cropland = bool(indicators)
+
+    should_run = all([has_cropland])
+    logRequirements(impact, model=MODEL, term=term_id,
+                    has_cropland_indicators=has_cropland)
+    logShouldRun(impact, MODEL, term_id, should_run)
+
+    return should_run, indicators
+
+
+def run_landTransformationFromCropland(term_id: str, impact: dict, indicators: list, years: int):
+    country_id = get_country_id(impact)
+    end_year = impact_end_year(impact)
+    total, permanent, temporary = get_cropland_ratio(country_id, end_year - years, end_year)
+
+    debugValues(impact, model=MODEL, term_id=term_id,
+                diff_temporary_area=temporary,
+                diff_permanent_area=permanent,
+                diff_total_area=total)
+
+    return flatten([
+        [
+            _new_indicator(term_id, MODEL, indicator.get('landCover', {}).get('@id'), 'annualCropland') | {
+                'value': indicator.get('value') * temporary / total
+            },
+            _new_indicator(term_id, MODEL, indicator.get('landCover', {}).get('@id'), 'permanentCropland') | {
+                'value': indicator.get('value') * permanent / total
+            }
+        ]
+        for indicator in indicators
+    ]) if total is not None else []

{hestia_earth_models-0.64.14 → hestia_earth_models-0.65.1}/hestia_earth/models/hestia/landCover.py

@@ -198,14 +198,14 @@ def _estimate_maximum_forest_change(
         pasture_change=pasture_change,
         total_cropland_change=total_cropland_change
     ) if not positive_change else (
-        total_agricultural_change
+        -total_agricultural_change
         if -min(forest_change, 0) > total_agricultural_change else
         min(forest_change, 0)
     )
 
 
 def _negative_agricultural_land_change(forest_change, pasture_change, total_cropland_change):
-    return pasture_change if 0 < pasture_change < -min(forest_change, 0) \
+    return -pasture_change if 0 < pasture_change < -min(forest_change, 0) \
         else min(forest_change, 0) if pasture_change > 0 \
         else -total_cropland_change if 0 < total_cropland_change < -min(forest_change, 0) \
         else min(forest_change, 0) if 0 < total_cropland_change \
@@ -432,7 +432,7 @@ def _run_make_management_nodes(existing_nodes: list, percentage_transformed_from
                 LAND_USE_TERMS_FOR_TRANSFORMATION[land_type], f"{start_year}-01-01", f"{start_year}-12-31"
             ),
             "land_type": land_type,
-            "percentage": 0.0 if ratio == -0.0 else to_precision(
+            "percentage": 0 if ratio == -0.0 else to_precision(
                 number=ratio * 100,
                 digits=OUTPUT_SIGNIFICANT_DIGITS
             )
@@ -462,7 +462,7 @@ def get_ratio_of_expanded_area(country_id: str, fao_name: str, end_year: int) ->
         faostat_name=fao_name
     )
     return 0.0 if any([expansion is None, end_value is None]) else max(
-        0.0, _safe_divide(numerator=expansion, denominator=(end_value - expansion))
+        0.0, _safe_divide(numerator=expansion, denominator=end_value)
     )
 
 
@@ -619,7 +619,7 @@ def _should_run_historical_land_use_change_single_crop(
         other_land_loss_to_pasture=other_land_loss_to[PERMANENT_PASTURE]
     )
 
-    # BA to BD
+    # C14-G14
     shares_of_expansion = _get_shares_of_expansion(
         land_use_type=land_use_type,
         percent_annual_cropland_was=percent_annual_cropland_was,