hestia-earth-models 0.66.0__py3-none-any.whl → 0.67.1__py3-none-any.whl

hestia_earth/models/cycle/completeness/freshForage.py

@@ -4,7 +4,8 @@ Completeness Fresh Forage
 This model checks if we have the requirements below and updates the
 [Data Completeness](https://hestia.earth/schema/Completeness#cropResidue) value.
 """
-from hestia_earth.schema import SiteSiteType
+from hestia_earth.schema import SiteSiteType, TermTermType
+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
@@ -46,18 +47,21 @@ ALLOWED_SITE_TYPES = [
 def _valid_input(input: dict): return is_from_model(input) and list_sum(input.get('value', [-1])) >= 0
 
 
+def _inputs(node: dict): return filter_list_term_type(node.get('inputs', []), TermTermType.FORAGE)
+
+
 def run(cycle: dict):
     site_type = cycle.get('site', {}).get('siteType')
     site_type_allowed = site_type in ALLOWED_SITE_TYPES
 
-    cycle_has_added_forage_input = any(map(_valid_input, cycle.get('inputs', [])))
+    cycle_has_added_forage_input = any(map(_valid_input, _inputs(cycle)))
 
     animals = [
         a for a in cycle.get('animals', [])
         if get_lookup_value(a.get('term', {}), 'isGrazingAnimal', model=MODEL, key=MODEL_KEY)
     ]
     all_animals_have_added_forage_input = bool(animals) and all([
-        any(map(_valid_input, animal.get('inputs', []))) for animal in animals
+        any(map(_valid_input, _inputs(animal))) for animal in animals
     ])
 
     logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,

hestia_earth/models/cycle/inorganicFertiliser.py

@@ -49,16 +49,28 @@ UNITS = [
 ]
 VALUE_BY_UNIT = {
     Units.KG_N.value: {
-        Units.KG_K2O.value: lambda value, nContent, p2O5Content, k2OContent: value * k2OContent / nContent,
-        Units.KG_P2O5.value: lambda value, nContent, p2O5Content, k2OContent: value * p2O5Content / nContent
+        Units.KG_K2O.value: lambda data: (
+            data.get('value') / data.get('nitrogenContent-divide')
+        ) * data.get('potassiumContentAsK2O-multiply'),
+        Units.KG_P2O5.value: lambda data: (
+            data.get('value') / data.get('nitrogenContent-divide')
+        ) * data.get('phosphateContentAsP2O5-multiply')
     },
     Units.KG_K2O.value: {
-        Units.KG_N.value: lambda value, nContent, p2O5Content, k2OContent: value / k2OContent * nContent,
-        Units.KG_P2O5.value: lambda value, nContent, p2O5Content, k2OContent: value / k2OContent * p2O5Content
+        Units.KG_N.value: lambda data: (
+            data.get('value') / data.get('potassiumContentAsK2O-divide')
+        ) * data.get('nitrogenContent-multiply'),
+        Units.KG_P2O5.value: lambda data: (
+            data.get('value') / data.get('potassiumContentAsK2O-divide')
+        ) * data.get('phosphateContentAsP2O5-multiply')
     },
     Units.KG_P2O5.value: {
-        Units.KG_N.value: lambda value, nContent, p2O5Content, k2OContent: value / p2O5Content * nContent,
-        Units.KG_K2O.value: lambda value, nContent, p2O5Content, k2OContent: value / p2O5Content * k2OContent
+        Units.KG_N.value: lambda data: (
+            data.get('value') / data.get('phosphateContentAsP2O5-divide')
+        ) * data.get('nitrogenContent-multiply'),
+        Units.KG_K2O.value: lambda data: (
+            data.get('value') / data.get('phosphateContentAsP2O5-divide')
+        ) * data.get('potassiumContentAsK2O-multiply')
     }
 }
 
@@ -81,6 +93,7 @@ def _include_term_ids(term_id: str):
 
 def _run_input(cycle: dict, input: dict):
     term_id = input.get('term', {}).get('@id')
+    input_term_ids = _include_term_ids(term_id)
     nitrogenContent = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent'), 0)
     nitrogenContent_min = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent-min'), None)
     nitrogenContent_max = safe_parse_float(get_term_lookup(term_id, 'nitrogenContent-max'), None)
@@ -96,28 +109,64 @@ def _run_input(cycle: dict, input: dict):
     min_values = non_empty_list([nitrogenContent_min, phosphateContentAsP2O5_min, potassiumContentAsK2O_min])
     max_values = non_empty_list([nitrogenContent_max, phosphateContentAsP2O5_max, potassiumContentAsK2O_max])
 
-    def include_input(input_term_id):
+    def include_input(input_term_id: str):
         to_units = Units.KG_N.value if input_term_id.endswith('KgN') else (
             Units.KG_K2O.value if input_term_id.endswith('KgK2O') else Units.KG_P2O5.value
         )
 
         debugValues(cycle, model=MODEL_LOG, term=input_term_id,
+                    from_input_id=term_id,
                     from_units=from_units,
                     to_units=to_units,
-                    input_value=input_value)
-
-        value = VALUE_BY_UNIT.get(from_units, {}).get(to_units, lambda *args: None)(
-            input_value, nitrogenContent, phosphateContentAsP2O5, potassiumContentAsK2O
+                    input_value=input_value,
+                    nitrogenContent=nitrogenContent,
+                    nitrogenContent_min=nitrogenContent_min,
+                    nitrogenContent_max=nitrogenContent_max,
+                    phosphateContentAsP2O5=phosphateContentAsP2O5,
+                    phosphateContentAsP2O5_min=phosphateContentAsP2O5_min,
+                    phosphateContentAsP2O5_max=phosphateContentAsP2O5_max,
+                    potassiumContentAsK2O=potassiumContentAsK2O,
+                    potassiumContentAsK2O_min=potassiumContentAsK2O_min,
+                    potassiumContentAsK2O_max=potassiumContentAsK2O_max)
+
+        converter = VALUE_BY_UNIT.get(from_units, {}).get(to_units, lambda *args: None)
+        value = converter(
+            {
+                'value': input_value,
+                'nitrogenContent-multiply': nitrogenContent,
+                'nitrogenContent-divide': nitrogenContent,
+                'phosphateContentAsP2O5-multiply': phosphateContentAsP2O5,
+                'phosphateContentAsP2O5-divide': phosphateContentAsP2O5,
+                'potassiumContentAsK2O-multiply': potassiumContentAsK2O,
+                'potassiumContentAsK2O-divide': potassiumContentAsK2O,
+            }
         )
-        min = VALUE_BY_UNIT.get(from_units, {}).get(to_units, lambda *args: None)(
-            input_value, nitrogenContent_min, phosphateContentAsP2O5_min, potassiumContentAsK2O_min
+        min = converter(
+            {
+                'value': input_value,
+                'nitrogenContent-multiply': nitrogenContent_min,
+                'nitrogenContent-divide': nitrogenContent_max,
+                'phosphateContentAsP2O5-multiply': phosphateContentAsP2O5_min,
+                'phosphateContentAsP2O5-divide': phosphateContentAsP2O5_max,
+                'potassiumContentAsK2O-multiply': potassiumContentAsK2O_min,
+                'potassiumContentAsK2O-divide': potassiumContentAsK2O_max,
+            }
         ) if len(min_values) >= 2 else None
-        max = VALUE_BY_UNIT.get(from_units, {}).get(to_units, lambda *args: None)(
-            input_value, nitrogenContent_max, phosphateContentAsP2O5_max, potassiumContentAsK2O_max
+        max = converter(
+            {
+                'value': input_value,
+                'nitrogenContent-multiply': nitrogenContent_max,
+                'nitrogenContent-divide': nitrogenContent_min,
+                'phosphateContentAsP2O5-multiply': phosphateContentAsP2O5_max,
+                'phosphateContentAsP2O5-divide': phosphateContentAsP2O5_min,
+                'potassiumContentAsK2O-multiply': potassiumContentAsK2O_max,
+                'potassiumContentAsK2O-divide': potassiumContentAsK2O_min,
+            }
         ) if len(max_values) >= 2 else None
+
         return _input(input_term_id, value, min, max) if value else None
 
-    return list(map(include_input, _include_term_ids(term_id)))
+    return list(map(include_input, input_term_ids))
 
 
 def _should_run_input(cycle: dict, input: dict):
@@ -130,7 +179,8 @@ def _should_run_input(cycle: dict, input: dict):
     # skip inputs that already have all the inlcuded term with a value
     inputs = cycle.get('inputs', [])
     include_term_ids = [
-        term_id for term_id in _include_term_ids(term_id) if len(find_term_match(inputs, term_id).get('value', [])) == 0
+        term_id for term_id in _include_term_ids(term_id)
+        if len(find_term_match(inputs, term_id).get('value', [])) == 0
     ]
     should_run = all([
         has_value,

hestia_earth/models/cycle/input/hestiaAggregatedData.py

@@ -77,19 +77,22 @@ def _run_seed(cycle: dict, primary_product: dict, seed_input: dict, product_term
     # 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'))
-    match_end_date = [
-        {'match': {'endDate': date - 10}}
-    ]
+    match_end_date = [{'match': {'endDate': date - 10}}]
+    default_product = get_generic_crop()
 
-    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)
+    impact = (
+        find_closest_impact(cycle, date, product, region, country, match_end_date) or
+        find_closest_impact(cycle, date, primary_product.get('term', {}), region, country, match_end_date) or
+        find_closest_impact(cycle, date, default_product, region, country)
+    )
 
+    search_by_product_term_id = (product or primary_product or default_product).get('@id')
+    search_by_region_id = (region or country or {}).get('@id') or 'region-world'
     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'))
+                search_by_product_term_id=search_by_product_term_id,
+                search_by_region_id=search_by_region_id,
+                search_by_end_date=str(date),
+                impact_assessment_id_found=(impact or {}).get('@id'))
 
     return seed_input | {MODEL_KEY: linked_node(impact), 'impactAssessmentIsProxy': True} if impact else None
 

hestia_earth/models/{environmentalFootprintV3 → environmentalFootprintV3_1}/__init__.py

@@ -1,13 +1,14 @@
-from os.path import dirname, abspath
 import sys
 from importlib import import_module
+from os.path import dirname, abspath
 
 from hestia_earth.models.utils.blank_node import run_if_required
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
-MODEL = 'environmentalFootprintV3'
-PKG = '.'.join(['hestia_earth', 'models', MODEL])
+MODEL = 'environmentalFootprintV3-1'
+MODEL_FOLDER = MODEL.replace('-', '_')
+PKG = '.'.join(['hestia_earth', 'models', MODEL_FOLDER])
 
 
 def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/{environmentalFootprintV3 → environmentalFootprintV3_1}/environmentalFootprintSingleOverallScore.py

@@ -8,32 +8,33 @@ summed to obtain the EF single overall score. The number and the name of the imp
 in EF3.0 and EF3.1.
 """
 from typing import List, Optional, Tuple
-
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.lookup import get_table_value, download_lookup, column_name
 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, debugMissingLookup
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.lookup import _node_value
+from hestia_earth.models.utils.blank_node import get_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "impacts": [
-            {
-                "@type": "Indicator",
-                "value": "",
-                "term.name": "PEF indicators only"
-            }
-        ]
+        "impacts": [{
+            "@type": "Indicator",
+            "value": "",
+            "term.name": "PEF indicators only"
+        }]
     }
 }
 
 LOOKUPS = {
     "@doc": "Normalisation factors in PEF v3.1 are calculated using a Global population number of 6,895,889,018",
-    "characterisedIndicator": ["pefTerm-normalisation-v3_1", "pefTerm-weighing-v3_1"]
+    "characterisedIndicator": [
+        "pefTerm-normalisation-v3_1",
+        "pefTerm-weighing-v3_1",
+        "pefTerm-methodModel-whiteList-v3-1"
+    ]
 }
 
 RETURNS = {
@@ -46,32 +47,40 @@ TERM_ID = 'environmentalFootprintSingleOverallScore'
 
 normalisation_column = LOOKUPS['characterisedIndicator'][0]
 weighing_column = LOOKUPS['characterisedIndicator'][1]
+method_model_colum = LOOKUPS['characterisedIndicator'][2]
 
 
-def _is_a_PEF_indicator(indicator_id) -> bool:
-    return (_get_factor(indicator_id, normalisation_column) not in [None, 0, 0.0] and
-            _get_factor(indicator_id, weighing_column) not in [None, 0, 0.0])
+def _is_a_PEF_indicator(indicator: dict) -> bool:
+    term = indicator.get('term', {})
+    indicator_method_model = indicator.get('methodModel', {}).get("@id")
+    return all([
+        indicator_method_model,
+        indicator_method_model in _get_pef_method_model(term),
+        _get_factor(term, normalisation_column) is not None,
+        _get_factor(term, weighing_column) is not None
+    ])
 
 
-def _get_factor(indicator_id: str, column) -> Optional[float]:
-    factor = get_table_value(download_lookup(f"{list(LOOKUPS.keys())[1]}.csv", keep_in_memory=True),
-                             'termid', indicator_id, column_name(column))
-    if factor is None:
-        debugMissingLookup(f"{list(LOOKUPS.keys())[1]}.csv", 'termid', indicator_id, column, None, model=MODEL,
-                           term=TERM_ID)
+def _get_factor(term: dict, column: str) -> Optional[float]:
+    factor = get_lookup_value(term, column, model=MODEL, term=TERM_ID)
     return float(factor) if factor is not None else None
 
 
+def _get_pef_method_model(term: dict) -> List[str]:
+    entries = get_lookup_value(term, method_model_colum, model=MODEL, term=TERM_ID) or ''
+    return entries.split(";")
+
+
 def _normalise(indicator: dict) -> Optional[float]:
-    return (_node_value(indicator) / _get_factor(indicator['term']['@id'], normalisation_column)) \
-        if (_node_value(indicator) is not None and
-            _get_factor(indicator['term']['@id'], normalisation_column) not in [None, 0, 0.0]) else None
+    return (
+        _node_value(indicator) / _get_factor(indicator.get('term', {}), normalisation_column)
+    ) if (_node_value(indicator) is not None and _get_factor(indicator.get('term', {}), normalisation_column)) else None
 
 
 def _weighted_normalise(indicator: dict) -> Optional[float]:
-    return (_normalise(indicator) * (_get_factor(indicator['term']['@id'], weighing_column) / 100)
-            ) if (_normalise(indicator) is not None and
-                  _get_factor(indicator['term']['@id'], weighing_column) not in [None, 0, 0.0]) else None
+    return (
+        _normalise(indicator) * (_get_factor(indicator.get('term', {}), weighing_column) / 100)
+    ) if (_normalise(indicator) is not None and _get_factor(indicator.get('term', {}), weighing_column)) else None
 
 
 def _indicator(value: float) -> dict:
@@ -85,17 +94,15 @@ def _run(indicators: List[dict]):
 
 
 def _valid_indicator(indicator: Optional[dict]) -> bool:
-    return all([indicator is not None,
-                isinstance(_node_value(indicator), (int, float)),
-                _node_value(indicator) is not None,
-                _is_a_PEF_indicator(indicator.get('term', {}).get('@id', ''))])
+    value = None if indicator is None else _node_value(indicator)
+    return isinstance(value, (int, float)) and _is_a_PEF_indicator(indicator)
 
 
 def _should_run(impact_assessment: dict) -> Tuple[bool, list[dict]]:
     indicators = [
         indicator for indicator in
         filter_list_term_type(impact_assessment.get('impacts', []), TermTermType.CHARACTERISEDINDICATOR)
-        if _is_a_PEF_indicator(indicator.get('term', {}).get('@id', ''))
+        if _is_a_PEF_indicator(indicator)
     ]
 
     has_pef_indicators = bool(indicators)
@@ -104,15 +111,13 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list[dict]]:
         "indicator": indicator,
         "valid-indicator": _valid_indicator(indicator),
         "one-indicator-for-category": sum(1 for i in indicators if i['term']['@id'] == indicator['term']['@id']) == 1,
-        "indicator-pef-category": indicator['term']['@id'],
+        "indicator-pef-category": indicator.get('term', {}).get('@id'),
         "value": _node_value(indicator),
         "normalised": _normalise(indicator),
-        "normalisation-used": _get_factor(indicator['term']['@id'], normalisation_column),
+        "normalisation-used": _get_factor(indicator.get('term', {}), normalisation_column),
         "weighted-normalised": _weighted_normalise(indicator),
-        "weighting-used": _get_factor(indicator['term']['@id'], weighing_column),
-    }
-        for indicator in indicators
-    ]
+        "weighting-used": _get_factor(indicator.get('term', {}), weighing_column),
+    } for indicator in indicators]
 
     no_duplicate_indicators = all([indicator['one-indicator-for-category'] for indicator in processed_indicators])
     valid_indicators = [indicator for indicator in processed_indicators if indicator['valid-indicator']]

hestia_earth/models/environmentalFootprintV3_1/marineEutrophicationPotential.py

@@ -0,0 +1,36 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
+from hestia_earth.models.utils.indicator import _new_indicator
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator", "value": "", "term.termType": "emission"}]
+    }
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+LOOKUPS = {
+    "emission": "nEqMarineEutrophicationEnvironmentalFootprintV3"
+}
+
+TERM_ID = 'marineEutrophicationPotential'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    value=value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/environmentalFootprintV3_1/scarcityWeightedWaterUse.py

@@ -0,0 +1,40 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from . import MODEL
+from ..utils.impact_assessment import impact_country_value
+from ..utils.indicator import _new_indicator
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator",
+                                  "term.@id": "freshwaterWithdrawalsDuringCycle",
+                                  "value": ""
+                                  }],
+        "optional": {"country": {"@type": "Term", "termType": "region"}}
+    }
+}
+
+LOOKUPS = {
+    "region-resourceUse-environmentalFootprintV31WaterUse": ""
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+TERM_ID = 'scarcityWeightedWaterUse'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_country_value(MODEL, TERM_ID, impact_assessment, f"{list(LOOKUPS.keys())[0]}.csv",
+                                 country_fallback=True)
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    value=value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return None if value is None else _indicator(value)

hestia_earth/models/{environmentalFootprintV3 → environmentalFootprintV3_1}/soilQualityIndexLandTransformation.py

@@ -8,7 +8,7 @@ from typing import List, Tuple
 
 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.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
@@ -26,7 +26,7 @@ REQUIREMENTS = {
                 "@type": "Indicator",
                 "term.termType": "resourceUse",
                 "term.@id": "landTransformation20YearAverageDuringCycle",
-                "value": "> 0",
+                "value": ">= 0",
                 "landCover": {"@type": "Term", "term.termType": "landCover"},
                 "previousLandCover": {"@type": "Term", "term.termType": "landCover"}
             }
@@ -38,7 +38,7 @@ REQUIREMENTS = {
                     "@type": "Indicator",
                     "term.termType": "resourceUse",
                     "term.@id": "landTransformation20YearAverageInputsProduction",
-                    "value": "> 0",
+                    "value": ">= 0",
                     "landCover": {"@type": "Term", "term.termType": "landCover"},
                     "previousLandCover": {"@type": "Term", "term.termType": "landCover"}
                 }
@@ -80,7 +80,8 @@ def _indicator(value: float):
 
 def _run(transformations: List[dict]):
     values = [
-        (transformation.get('factor-from', 0) + transformation.get('factor-to', 0)) * transformation.get('area', 0) * 20
+        (transformation.get("factor-from", 0) + transformation.get("factor-to", 0)
+         ) * transformation.get("value", 0) * 20
         for transformation in transformations
     ]
     return _indicator(list_sum(values))
@@ -92,19 +93,22 @@ def _is_valid_indicator(indicator: dict) -> bool:
 
 
 def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
-    resource_uses = filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE)
+    resource_uses = [
+        i for i in filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE) if
+        _is_valid_indicator(i)
+    ]
+
     found_transformations = [
         {
-            'area': _node_value(transformation_indicator),
+            'value': _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', ''),
-            'indicator-is-valid': _is_valid_indicator(transformation_indicator),
             'good-land-cover-term': all([bool(transformation_indicator.get('landCover')),
                                          bool(transformation_indicator.get('previousLandCover'))]),
             'country-id': get_country_id(impact_assessment),
-            'area-is-valid': _node_value(transformation_indicator) is not None and _node_value(
-                transformation_indicator) > 0,
+            'value-is-valid': (_node_value(transformation_indicator) is not None and
+                               _node_value(transformation_indicator) >= 0),
             'lookup-country': fallback_country(get_country_id(impact_assessment),
                                                [download_lookup(from_lookup_file), download_lookup(to_lookup_file)]),
         } for transformation_indicator in resource_uses
@@ -130,8 +134,7 @@ 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['indicator-is-valid'],
+            t['value-is-valid'],
             t['factor-from'] is not None,
             t['factor-to'] is not None
         ])
@@ -144,19 +147,24 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
 
     all_transformations_are_valid = all(
         [
-            all([t['area-is-valid'], t['indicator-is-valid'], t['good-land-cover-term']])
+            all([t['value-is-valid'], t['good-land-cover-term']])
             for t in found_transformations_with_coefficient
         ]
     ) if found_transformations_with_coefficient else False
 
+    has_a_during_cycle_indicator = bool(find_term_match(resource_uses, "landTransformation20YearAverageDuringCycle"))
+
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
-                    has_land_occupation_indicators=has_land_transformation_indicators,
+                    has_land_transformation_indicators=has_land_transformation_indicators,
+                    has_a_during_cycle_indicator=has_a_during_cycle_indicator,
                     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 = all([has_land_transformation_indicators, all_transformations_are_valid])
+    should_run = all([has_land_transformation_indicators,
+                      has_a_during_cycle_indicator,
+                      all_transformations_are_valid])
 
     logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
     return should_run, valid_transformations_with_coef

hestia_earth/models/{environmentalFootprintV3 → environmentalFootprintV3_1}/soilQualityIndexTotalLandUseEffects.py

@@ -42,34 +42,36 @@ def _run(indicators: list):
 
 
 def _should_run(impactassessment: dict) -> tuple[bool, list]:
-    land_indicators = [
+    soil_quality_indicators = [
         i for i in impactassessment.get('emissionsResourceUse', []) if
         i.get('term', {}).get('@id', '') in ['soilQualityIndexLandOccupation', 'soilQualityIndexLandTransformation']
     ]
-    has_indicators = bool(land_indicators)
+    has_soil_quality_indicators = bool(soil_quality_indicators)
 
-    land_occupation_indicator = find_term_match(land_indicators, "soilQualityIndexLandOccupation",
-                                                default_val=None)
-    has_land_occupation_indicator = bool(land_occupation_indicator)
+    soil_quality_occupation_indicator = find_term_match(soil_quality_indicators, "soilQualityIndexLandOccupation",
+                                                        default_val=None)
+    has_soil_quality_land_occupation_indicator = bool(soil_quality_occupation_indicator)
 
-    land_transformation_indicator = find_term_match(land_indicators, "soilQualityIndexLandTransformation",
-                                                    default_val=None)
-    has_land_transformation_indicator = bool(land_transformation_indicator)
+    soil_quality_transformation_indicator = find_term_match(soil_quality_indicators,
+                                                            "soilQualityIndexLandTransformation",
+                                                            default_val=None)
+    has_soil_quality_land_transformation_indicator = bool(soil_quality_transformation_indicator)
 
-    has_valid_values = all([isinstance(indicator.get('value', None), (int, float)) for indicator in land_indicators])
+    has_valid_values = all(
+        [isinstance(indicator.get('value', None), (int, float)) for indicator in soil_quality_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_soil_quality_indicators=has_soil_quality_indicators,
+                    has_soil_quality_land_occupation_indicator=has_soil_quality_land_occupation_indicator,
+                    has_soil_quality_land_transformation_indicator=has_soil_quality_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])
+    should_run = all([has_soil_quality_indicators, has_valid_values,
+                      has_soil_quality_land_occupation_indicator, has_soil_quality_land_transformation_indicator])
 
     logShouldRun(impactassessment, MODEL, TERM_ID, should_run)
-    return should_run, land_indicators
+    return should_run, soil_quality_indicators
 
 
 def run(impactassessment: dict):

hestia_earth/models/hestia/landTransformation100YearAverageDuringCycle.py

@@ -4,7 +4,7 @@ contained within the [ImpactAssesment.cycle](https://hestia.earth/schema/ImpactA
 100 years.
 
 It does this by multiplying the land occupation during the cycle by the
-[Site](https://www-staging.hestia.earth/schema/Site) area 100 years ago and dividing by 100.
+[Site](https://hestia.earth/schema/Site) area 100 years ago and dividing by 100.
 
 Land transformation from [land type] 100 years =
 (Land occupation, during Cycle * Site Percentage Area 100 years ago [land type] / 100) / 100

hestia_earth/models/hestia/landTransformation20YearAverageDuringCycle.py

@@ -4,7 +4,7 @@ contained within the [ImpactAssesment.cycle](https://hestia.earth/schema/ImpactA
 20 years.
 
 It does this by multiplying the land occupation during the cycle by the
-[Site](https://www-staging.hestia.earth/schema/Site) area 20 years ago and dividing by 20.
+[Site](https://hestia.earth/schema/Site) area 20 years ago and dividing by 20.
 
 Land transformation from [land type] 20 years =
 (Land occupation, during Cycle * Site Percentage Area 20 years ago [land type] / 100) / 20

hestia_earth/models/impact_assessment/product/value.py

@@ -25,7 +25,7 @@ MODEL_KEY = 'value'
 
 
 def _run(impact: dict, product: dict):
-    return {**impact.get('product'), MODEL_KEY: product.get(MODEL_KEY, [])}
+    return impact.get('product') | {MODEL_KEY: product.get(MODEL_KEY, [])}
 
 
 def _should_run(impact: dict):

hestia_earth/models/ipcc2019/aboveGroundBiomass.py

@@ -170,7 +170,7 @@ def _should_run(site: dict) -> tuple[bool, dict, dict]:
     inventory = _compile_inventory(land_cover) if should_compile_inventory else {}
     kwargs = {
         "eco_climate_zone": eco_climate_zone,
-        "seed": gen_seed(site)
+        "seed": gen_seed(site, MODEL, TERM_ID)
     }
 
     logRequirements(
@@ -542,7 +542,7 @@ def _measurement(
     max : list[float]
         A list of maximum values representing the maximum modelled biomass stock for each year of the inventory.
     statsDefinition : str
-        The [statsDefinition](https://www-staging.hestia.earth/schema/Measurement#statsDefinition) of the measurement.
+        The [statsDefinition](https://hestia.earth/schema/Measurement#statsDefinition) of the measurement.
     observations : list[int]
         The number of model iterations used to calculate the descriptive statistics.