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

hestia_earth/models/cml2001Baseline/resourceUseEnergyDepletionDuringCycle.py

@@ -1,6 +1,6 @@
 """
 This model converts all "energy" terms found in a `Cycle > Inputs` to `MJ` using optional
-`energyContentHigherHeatingValue` and `density` properties or the term's "defaultProperties",
+`energyContentLowerHeatingValue` and `density` properties or the term's "defaultProperties",
  aggregates them, and places them inside a 'resourceUseEnergyDepletionDuringCycle' indicator per aggregated input id.
 """
 from collections import defaultdict
@@ -12,7 +12,7 @@ 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 Units
+from hestia_earth.models.utils import Units, _include
 from hestia_earth.models.utils.blank_node import convert_unit
 from hestia_earth.models.utils.indicator import _new_indicator
 from . import MODEL
@@ -31,7 +31,7 @@ REQUIREMENTS = {
                         {
                             "@type": "Property",
                             "value": "",
-                            "term.@id": "energyContentHigherHeatingValue",
+                            "term.@id": "energyContentLowerHeatingValue",
                             "term.units": "MJ / kg"
                         },
                         {
@@ -57,7 +57,7 @@ RETURNS = {
 }
 
 LOOKUPS = {
-    "fuel": ["energyContentHigherHeatingValue", "density"]
+    "fuel": ["energyContentLowerHeatingValue", "density"]
 }
 
 TERM_ID = 'resourceUseEnergyDepletionDuringCycle'
@@ -123,12 +123,7 @@ def _should_run(cycle: dict) -> Tuple[bool, dict]:
         grouped_energy_terms[k].extend(list(v))
 
     logs = [
-        {
-            'id': input.get('@id'),
-            'units': input.get('units'),
-            'termType': input.get('termType'),
-            'value': input.get('value'),
-            'value-in-MJ': input.get('value-in-MJ'),
+        _include(input, ['id', 'units', 'termType', 'value', 'value-in-MJ']) | {
             'properties': "    ".join([
                 f"{p.get('term', {}).get('@id')}= {p.get('value')} ({p.get('term', {}).get('units')})"
                 for p in input.get('properties', [])

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/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/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_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/ipcc2019/aboveGroundBiomass.py

@@ -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.
 

hestia_earth/models/ipcc2019/belowGroundBiomass.py

@@ -525,7 +525,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.
 

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_1_utils.py

@@ -96,7 +96,7 @@ def _measurement(
     Build a HESTIA `Measurement` node to contain a value and descriptive statistics calculated by the models.
 
     The `descriptive_stats_dict` parameter should include the following keys and values from the
-    [Measurement](https://www-staging.hestia.earth/schema/Measurement) schema:
+    [Measurement](https://hestia.earth/schema/Measurement) schema:
     ```
     {
         "value": list[float],
@@ -874,9 +874,9 @@ def _compile_inventory(
     site_id : str
         The `@id` of the site.
     site_type : str
-        A valid [site type](https://www-staging.hestia.earth/schema/Site#siteType).
+        A valid [site type](https://hestia.earth/schema/Site#siteType).
     management_nodes : list[dict]
-        A list of [Management nodes](https://www-staging.hestia.earth/schema/Management).
+        A list of [Management nodes](https://hestia.earth/schema/Management).
     ipcc_soil_category : IpccSoilCategory
         The site's assigned IPCC soil category.
 
@@ -949,7 +949,7 @@ def _assign_ipcc_soil_category(
     Parameters
     ----------
     measurement_nodes : list[dict]
-        List of A list of [Measurement nodes](https://www-staging.hestia.earth/schema/Measurement)..
+        List of A list of [Measurement nodes](https://hestia.earth/schema/Measurement)..
     default : IpccSoilCategory, optional
         The default soil category if none matches, by default IpccSoilCategory.LOW_ACTIVITY_CLAY_SOILS.
 

hestia_earth/models/ipcc2019/organicCarbonPerHa_tier_2_utils.py

@@ -110,7 +110,7 @@ def _measurement(
     Build a HESTIA `Measurement` node to contain a value and descriptive statistics calculated by the models.
 
     The `descriptive_stats_dict` parameter should include the following keys and values from the
-    [Measurement](https://www-staging.hestia.earth/schema/Measurement) schema:
+    [Measurement](https://hestia.earth/schema/Measurement) schema:
     ```
     {
         "value": list[float],