hestia-earth-models 0.67.0__tar.gz → 0.67.1__tar.gz

{hestia_earth_models-0.67.0 → hestia_earth_models-0.67.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.67.0
+Version: 0.67.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

{hestia_earth_models-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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-0.67.0 → hestia_earth_models-0.67.1}/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],