hestia-earth-models 0.74.5__py3-none-any.whl → 0.74.7__py3-none-any.whl

hestia_earth/models/hestia/default_resourceUse.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import IndicatorMethodTier, TermTermType
+from hestia_earth.schema import TermTermType
 from hestia_earth.utils.tools import flatten, safe_parse_float
 
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
@@ -8,6 +8,8 @@ from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.input import unique_background_inputs
+from hestia_earth.models.utils.impact_assessment import get_product
+from hestia_earth.models.utils.crop import get_landCover_term_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -29,8 +31,7 @@ REQUIREMENTS = {
 RETURNS = {
     "Indicator": [{
         "value": "",
-        "inputs": "",
-        "methodTier": "background"
+        "inputs": ""
     }]
 }
 LOOKUPS = {
@@ -38,14 +39,12 @@ LOOKUPS = {
     "organicFertiliser": "backgroundEmissionsResourceUseDefaultValue"
 }
 MODEL_KEY = 'default_resourceUse'
-TIER = IndicatorMethodTier.BACKGROUND.value
 
 
-def _indicator(term_id: str, value: float, input: dict):
-    indicator = _new_indicator(term_id, MODEL)
+def _indicator(term_id: str, value: float, input: dict, land_cover_id: str):
+    indicator = _new_indicator(term_id, MODEL, land_cover_id)
     indicator['value'] = value
     indicator['inputs'] = [input]
-    indicator['methodTier'] = TIER
     return indicator
 
 
@@ -53,8 +52,12 @@ def _default_value(input: dict):
     return safe_parse_float(get_lookup_value(input.get('term', {}), LOOKUPS['organicFertiliser']), default=None)
 
 
-def _run_input(impact: dict):
+def _run_input(impact: dict, land_cover_id: str):
     required_resourceUse_term_ids = background_emissions_in_system_boundary(impact, TermTermType.RESOURCEUSE)
+    # remove landTransformation as need `previousLandCover` to be valid
+    required_resourceUse_term_ids = [
+        v for v in required_resourceUse_term_ids if not v.startswith('landTransformation')
+    ]
 
     def run(input: dict):
         input_term = input.get('input').get('term')
@@ -62,14 +65,14 @@ def _run_input(impact: dict):
         value = input.get('default-value-from-lookup')
 
         for emission_id in required_resourceUse_term_ids:
-            logShouldRun(impact, MODEL, term_id, True, methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)
+            logShouldRun(impact, MODEL, term_id, True, model_key=MODEL_KEY, emission_id=emission_id)
             debugValues(impact, model=MODEL, term=emission_id,
                         value=value,
                         coefficient=1,
                         input=term_id)
 
         return [
-            _indicator(term_id, value, input_term) for term_id in required_resourceUse_term_ids
+            _indicator(term_id, value, input_term, land_cover_id) for term_id in required_resourceUse_term_ids
         ]
 
     return run
@@ -95,18 +98,21 @@ def _should_run(impact: dict):
         ])
     ]
 
-    should_run = all([bool(valid_inputs)])
+    landCover_term_id = get_landCover_term_id(get_product(impact).get("term", {}))
+
+    should_run = all([bool(valid_inputs), landCover_term_id])
 
     for input in inputs:
         term_id = input.get('input').get('term', {}).get('@id')
 
         logRequirements(impact, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                        **_omit(input, ['input', 'input-value']))
-        logShouldRun(impact, MODEL, term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
+                        **_omit(input, ['input', 'input-value']),
+                        landCover_term_id=landCover_term_id)
+        logShouldRun(impact, MODEL, term_id, should_run, model_key=MODEL_KEY)
 
-    return should_run, valid_inputs
+    return should_run, valid_inputs, landCover_term_id
 
 
 def run(impact: dict):
-    should_run, grouped_inputs = _should_run(impact)
-    return flatten(map(_run_input(impact), grouped_inputs)) if should_run else []
+    should_run, grouped_inputs, landCover_term_id = _should_run(impact)
+    return flatten(map(_run_input(impact, landCover_term_id), grouped_inputs)) if should_run else []

hestia_earth/models/hestia/landOccupationDuringCycle.py

@@ -120,7 +120,7 @@ def _extract_site_data(cycle: dict, land_cover_id: dict):
         duration=cycle.get("siteDuration"),
         unused_duration=cycle.get("siteUnusedDuration"),
         country_id=site.get("country", {}).get("@id"),
-        land_cover_id=land_cover_id or get_landCover_term_id_from_site_type(site.get("siteType", {}))
+        land_cover_id=land_cover_id or get_landCover_term_id_from_site_type(site.get("siteType"))
     )
 
     is_valid = _should_run_site_data(site_data)
@@ -145,7 +145,7 @@ def _extract_other_sites_data(cycle: dict, land_cover_id: dict):
             duration=duration,
             unused_duration=unused_duration,
             country_id=site.get("country", {}).get("@id"),
-            land_cover_id=land_cover_id or get_landCover_term_id_from_site_type(site.get("siteType", {}))
+            land_cover_id=land_cover_id or get_landCover_term_id_from_site_type(site.get("siteType"))
         ) for (
             site,
             area,

hestia_earth/models/hestia/seed_emissions.py

@@ -12,7 +12,7 @@ from hestia_earth.models.utils import _omit, group_by
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.site import valid_site_type
 from hestia_earth.models.utils.cycle import cycle_end_year
-from hestia_earth.models.utils.crop import get_crop_grouping_faostat_production, get_landCover_term_id
+from hestia_earth.models.utils.crop import get_crop_lookup_value, get_landCover_term_id
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.lookup import get_region_lookup_value
@@ -59,6 +59,7 @@ LOOKUPS = {
     "crop": [
         "correspondingSeedTermIds",
         "cropGroupingFaostatProduction",
+        "cropGroupingFaostatProductionProxy",
         "global_economic_value_share",
         "landCoverTermId"
     ],
@@ -154,23 +155,38 @@ def _filter_emissions(cycle: dict):
     )), emissions_per_group
 
 
-def _evs(product: dict):
-    return safe_parse_float(
-        get_lookup_value(product.get('term', {}), 'global_economic_value_share', model=MODEL, model_key=MODEL_KEY),
-        default=None
-    ) or product.get('economicValueShare')
+def _crop_data(product: dict, country_id: str, end_year: int):
+    term = product.get('term', {})
+    term_id = term.get('@id')
 
+    crop_grouping = get_crop_lookup_value(MODEL, term_id, term_id, 'cropGroupingFaostatProduction')
+    crop_grouping_proxy = get_crop_lookup_value(MODEL, term_id, term_id, 'cropGroupingFaostatProductionProxy')
 
-def _faostat_yield(country_id: str, end_year: int, product: dict):
-    grouping = get_crop_grouping_faostat_production(MODEL, product.get('term', {}))
-    value = extract_grouped_data_closest_date(get_region_lookup_value(
+    faostat_yield = safe_parse_float(extract_grouped_data_closest_date(get_region_lookup_value(
         'region-crop-cropGroupingFaostatProduction-yield.csv',
         country_id,
-        grouping,
+        crop_grouping_proxy or crop_grouping,
         model=MODEL,
         model_key=MODEL_KEY
-    ), end_year)
-    return safe_parse_float(value, default=None)
+    ), end_year), default=None)
+
+    # when using proxy, we cannot use the lookup value as it won't correspond to the primary product
+    global_evs = None if crop_grouping_proxy else safe_parse_float(
+        get_lookup_value(product.get('term', {}), 'global_economic_value_share', model=MODEL, model_key=MODEL_KEY),
+        default=None
+    )
+    product_evs = product.get('economicValueShare')
+
+    return {
+        'product-id': term_id,
+        'seed-id': get_lookup_value(term, 'correspondingSeedTermIds', model=MODEL, model_key=MODEL_KEY) or None,
+        'economicValueShare': global_evs or product_evs,
+        'FAOSTAT-yield': faostat_yield,
+        'landCover-id': get_landCover_term_id(term, model=MODEL, model_key=MODEL_KEY)
+    } | (
+        # skip using product yield if proxy is used
+        {} if crop_grouping_proxy else {'product-yield': list_sum(product.get('value'))}
+    )
 
 
 def _group_seed_inputs(inputs: list):
@@ -191,18 +207,7 @@ def _should_run(cycle: dict):
     country_id = cycle.get('site', {}).get('country', {}).get('@id')
 
     # only keep the crop products that map to a seed
-    crop_products = [
-        {
-            'product': product.get('term', {}).get('@id'),
-            'seed-id': get_lookup_value(
-                product.get('term', {}), 'correspondingSeedTermIds', model=MODEL, model_key=MODEL_KEY) or None,
-            'economicValueShare': _evs(product),
-            'FAOSTAT-yield': _faostat_yield(country_id, end_year, product),
-            'product-yield': list_sum(product.get('value')),
-            'landCover-id': get_landCover_term_id(product.get('term', {}), model=MODEL, model_key=MODEL_KEY)
-        }
-        for product in crop_products
-    ]
+    crop_products = [_crop_data(product, country_id, end_year) for product in crop_products]
     valid_crop_products = [
         value for value in crop_products if all([
             value.get('seed-id'),