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

hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -64,7 +64,7 @@ RETURNS = {
 }
 LOOKUPS = {
     "electricity": "ecoinventMapping",
-    "region-ember-energySources": "using `country`",
+    "region-ember-energySources": "",
     "ember-ecoinvent-mapping": ["ember", "ecoinventId", "ecoinventName"]
 }
 

hestia_earth/models/ecoinventV3AndEmberClimate/utils.py

@@ -1,8 +1,8 @@
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
 from hestia_earth.utils.tools import safe_parse_float
 
-from hestia_earth.models.log import debugMissingLookup
 from hestia_earth.models.utils.cycle import cycle_end_year
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 
 EMBER_ECOINVENT_LOOKUP_NAME = "ember-ecoinvent-mapping.csv"
 REGION_EMBER_SOURCES_LOOKUP_NAME = "region-ember-energySources.csv"
@@ -17,10 +17,6 @@ def get_input_coefficient(model: str, cycle: dict, country_id: str, ecoinventNam
     source_name = get_table_value(ember_ecoinvent_lookup, column_name('ecoinventName'), ecoinventName, 'ember')
 
     # find the ratio for the country / year
-    region_ember_sources_lookup = download_lookup(REGION_EMBER_SOURCES_LOOKUP_NAME)
-    data = get_table_value(region_ember_sources_lookup, 'termid', country_id, column_name(source_name))
+    data = get_region_lookup_value(REGION_EMBER_SOURCES_LOOKUP_NAME, country_id, source_name, model=model)
     percentage = extract_grouped_data(data, str(year))
-    debugMissingLookup(REGION_EMBER_SOURCES_LOOKUP_NAME,
-                       'termid', country_id, source_name, percentage, year=year, model=model)
-
     return safe_parse_float(percentage, 0) / 100

hestia_earth/models/emissionNotRelevant/__init__.py

@@ -3,8 +3,8 @@ Emission not relevant
 
 The emission is not relevant for this Site, Cycle, or Product.
 """
-from hestia_earth.schema import NodeType, TermTermType, EmissionMethodTier
-from hestia_earth.utils.emission import emission_is_in_system_boundary
+from hestia_earth.schema import NodeType, EmissionMethodTier
+from hestia_earth.utils.lookup_utils import is_in_system_boundary
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
@@ -38,8 +38,8 @@ def _emission(term_id: str):
 
 def _should_run_emission(cycle: dict):
     def run(term_id: str):
-        is_not_relevant = not _run_required(MODEL, {'@id': term_id, 'termType': TermTermType.EMISSION.value}, cycle)
-        in_system_boundary = emission_is_in_system_boundary(term_id)
+        is_not_relevant = not _run_required(MODEL, term_id, cycle)
+        in_system_boundary = is_in_system_boundary(term_id)
 
         should_run = all([is_not_relevant, in_system_boundary])
         if should_run:

hestia_earth/models/environmentalFootprintV3_1/environmentalFootprintSingleOverallScore.py

@@ -10,30 +10,32 @@ 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, debugValues
+from hestia_earth.models.utils.blank_node import get_lookup_value
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.lookup import _node_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 +48,54 @@ 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 _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
-
-
-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
+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 _indicator_factors(impact_assessment: dict, indicator: dict):
+    value = _node_value(indicator)
+    normalisation_factor = _get_factor(indicator.get('term', {}), normalisation_column)
+    weighting_factor = _get_factor(indicator.get('term', {}), weighing_column)
+    coefficient = 0 if all([
+        weighting_factor == 0,
+        normalisation_factor == 0
+    ]) else (weighting_factor / 100) / normalisation_factor if all([
+        weighting_factor is not None,
+        normalisation_factor is not None
+    ]) else None
+
+    debugValues(impact_assessment, model=MODEL, term=TERM_ID,
+                node=indicator['term']['@id'],
+                value=value,
+                coefficient=coefficient)
+
+    return {
+        "value": value,
+        "normalisation-used": normalisation_factor,
+        "weighting-used": weighting_factor,
+        "coefficient": coefficient,
+        "weighted-value": value * coefficient if all([value is not None, coefficient is not None]) else None,
+    }
 
 
 def _indicator(value: float) -> dict:
@@ -81,38 +105,28 @@ def _indicator(value: float) -> dict:
 
 
 def _run(indicators: List[dict]):
-    return _indicator(value=list_sum([indicator["weighted-normalised"] for indicator in indicators]))
+    return _indicator(value=list_sum([indicator["weighted-value"] for indicator in indicators]))
 
 
 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)
 
     processed_indicators = [{
-        "indicator": indicator,
+        "indicator": indicator['term']['@id'],
         "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'],
-        "value": _node_value(indicator),
-        "normalised": _normalise(indicator),
-        "normalisation-used": _get_factor(indicator['term']['@id'], normalisation_column),
-        "weighted-normalised": _weighted_normalise(indicator),
-        "weighting-used": _get_factor(indicator['term']['@id'], weighing_column),
-    }
-        for indicator in indicators
-    ]
+        "indicator-pef-category": indicator.get('term', {}).get('@id'),
+    } | _indicator_factors(impact_assessment, indicator) 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/photochemicalOzoneCreationPotentialHumanHealthNmvocEq.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": "nmvocEqPhotochemicalOzoneFormationEnvironmentalFootprintV3-1"
+}
+TERM_ID = 'photochemicalOzoneCreationPotentialHumanHealthNmvocEq'
+
+
+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

@@ -1,7 +1,7 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.impact_assessment import impact_country_value
+from hestia_earth.models.utils.indicator import _new_indicator
 from . import MODEL
-from ..utils.impact_assessment import impact_country_value
-from ..utils.indicator import _new_indicator
 
 REQUIREMENTS = {
     "ImpactAssessment": {

hestia_earth/models/environmentalFootprintV3_1/soilQualityIndexLandOccupation.py

@@ -7,16 +7,14 @@ Factors version 2.5 (Horn and Meier, 2018).
 from typing import 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.tools import list_sum
 
 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.landCover import get_pef_grouping
-from hestia_earth.models.utils.lookup import fallback_country, _node_value
+from hestia_earth.models.utils.lookup import fallback_country, _node_value, get_region_lookup_value
 from . import MODEL
-from .utils import get_coefficient_factor
 from ..utils.impact_assessment import get_country_id
 
 REQUIREMENTS = {
@@ -75,16 +73,19 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
         'area-by-year-is-valid': _node_value(land_occupation_indicator) is not None and _node_value(
             land_occupation_indicator) > 0,
         'area-unit-is-valid': land_occupation_indicator.get('term', {}).get("units") == "m2*year",
-        'used-country': fallback_country(get_country_id(impact_assessment), [download_lookup(LOOKUP)]),
+        'used-country': fallback_country(get_country_id(impact_assessment), [LOOKUP]),
+        'pef-grouping': get_pef_grouping(land_occupation_indicator.get('landCover', {}).get("@id"))
 
     } for land_occupation_indicator in land_occupation_indicators]
 
     found_indicators_with_coefficient = [
         indicator | {
-            'coefficient': get_coefficient_factor(
-                LOOKUP, indicator['used-country'],
-                get_pef_grouping(indicator['land-cover-id']),
-                term_id=TERM_ID
+            'coefficient': get_region_lookup_value(
+                model=MODEL,
+                term=TERM_ID,
+                lookup_name=LOOKUP,
+                term_id=indicator['used-country'],
+                column=indicator['pef-grouping']
             ),
             "using-fallback-country-region-world-CFs": indicator['used-country'] != indicator['country-id']
         } for indicator in found_land_occupation_indicators

hestia_earth/models/environmentalFootprintV3_1/soilQualityIndexLandTransformation.py

@@ -7,17 +7,15 @@ Factors version 2.5 (Horn and Meier, 2018).
 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
+from hestia_earth.models.utils.impact_assessment import get_country_id
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.landCover import get_pef_grouping
+from hestia_earth.models.utils.lookup import fallback_country, _node_value, get_region_lookup_value
 from . import MODEL
-from .utils import get_coefficient_factor
-from ..utils.impact_assessment import get_country_id
-from ..utils.indicator import _new_indicator
-from ..utils.landCover import get_pef_grouping
-from ..utils.lookup import fallback_country, _node_value
 
 REQUIREMENTS = {
     "ImpactAssessment": {
@@ -26,7 +24,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 +36,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"}
                 }
@@ -50,8 +48,8 @@ REQUIREMENTS = {
 # Note: CFs in `region-pefTermGrouping-landTransformation-from.csv` appear to be the opposite values as those in
 # `region-pefTermGrouping-landTransformation-to.csv` but can be different in some cases.
 LOOKUPS = {
-    "region-pefTermGrouping-landTransformation-from": "using country and `pefTermGrouping` from `landCover`",
-    "region-pefTermGrouping-landTransformation-to": "using country and `pefTermGrouping` from `landCover`",
+    "region-pefTermGrouping-landTransformation-from": "",
+    "region-pefTermGrouping-landTransformation-to": "",
     "landCover": "pefTermGrouping"
 }
 
@@ -80,7 +78,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,46 +91,53 @@ 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'))]),
+            '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,
-            'lookup-country': fallback_country(get_country_id(impact_assessment),
-                                               [download_lookup(from_lookup_file), download_lookup(to_lookup_file)]),
+            '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), [from_lookup_file, to_lookup_file]),
         } for transformation_indicator in resource_uses
     ]
 
     found_transformations_with_coefficient = [
         transformation | {
             'using-fallback-country-region-world-CFs': transformation['lookup-country'] != transformation['country-id'],
-            'factor-from': get_coefficient_factor(
+            'factor-from': get_region_lookup_value(
+                model=MODEL,
+                term=TERM_ID,
                 lookup_name=from_lookup_file,
-                country_id=transformation['lookup-country'],
-                term_id=TERM_ID,
-                occupation_type=get_pef_grouping(transformation['land-cover-id-from'])) if
+                term_id=transformation['lookup-country'],
+                column=get_pef_grouping(transformation['land-cover-id-from'])) if
             transformation['land-cover-id-from'] else None,
-            'factor-to': get_coefficient_factor(
+            'factor-to': get_region_lookup_value(
+                model=MODEL,
+                term=TERM_ID,
                 lookup_name=to_lookup_file,
-                country_id=transformation['lookup-country'],
-                term_id=TERM_ID,
-                occupation_type=get_pef_grouping(transformation['land-cover-id-to'])) if
+                term_id=transformation['lookup-country'],
+                column=get_pef_grouping(transformation['land-cover-id-to'])) if
             transformation['land-cover-id-to'] else None
         } for transformation in found_transformations
     ]
 
     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 +150,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

@@ -4,7 +4,8 @@ based on an updated [LANCA model (De Laurentiis et al. 2019)](
 http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
 Factors version 2.5 (Horn and Meier, 2018).
 """
-from hestia_earth.utils.model import find_term_match
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
@@ -13,7 +14,7 @@ from ..utils.indicator import _new_indicator
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "emissionsResourceUse": [
+        "impacts": [
             {"@type": "Indicator", "value": "", "term.@id": "soilQualityIndexLandOccupation"},
             {"@type": "Indicator", "value": "", "term.@id": "soilQualityIndexLandTransformation"}
         ]
@@ -32,44 +33,46 @@ TERM_ID = 'soilQualityIndexTotalLandUseEffects'
 
 def _indicator(value: float):
     indicator = _new_indicator(TERM_ID, MODEL)
-    indicator['value'] = value
+    indicator["value"] = value
     return indicator
 
 
 def _run(indicators: list):
-    values = [indicator['value'] for indicator in indicators]
+    values = [indicator["value"] for indicator in indicators]
     return _indicator(list_sum(values))
 
 
 def _should_run(impactassessment: dict) -> tuple[bool, list]:
-    land_indicators = [
-        i for i in impactassessment.get('emissionsResourceUse', []) if
-        i.get('term', {}).get('@id', '') in ['soilQualityIndexLandOccupation', 'soilQualityIndexLandTransformation']
+    soil_quality_indicators = [
+        i for i in filter_list_term_type(impactassessment.get("impacts", []), TermTermType.CHARACTERISEDINDICATOR) 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/faostat2018/coldCarcassWeightPerHead.py

@@ -22,8 +22,8 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-animalProduct-animalProductGroupingFAO-productionQuantity": "production quantity",
-    "region-animalProduct-animalProductGroupingFAO-head": "number of heads"
+    "region-animalProduct-animalProductGroupingFAO-productionQuantity": "",
+    "region-animalProduct-animalProductGroupingFAO-head": ""
 }
 RETURNS = {
     "Product": [{

hestia_earth/models/faostat2018/coldDressedCarcassWeightPerHead.py

@@ -25,8 +25,8 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-animalProduct-animalProductGroupingFAO-productionQuantity": "production quantity",
-    "region-animalProduct-animalProductGroupingFAO-head": "number of heads"
+    "region-animalProduct-animalProductGroupingFAO-productionQuantity": "",
+    "region-animalProduct-animalProductGroupingFAO-head": ""
 }
 RETURNS = {
     "Product": [{

hestia_earth/models/faostat2018/liveweightPerHead.py

@@ -1,14 +1,15 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.api import download_hestia
-from hestia_earth.utils.lookup import get_table_value, column_name, download_lookup, extract_grouped_data_closest_date
+from hestia_earth.utils.lookup import extract_grouped_data_closest_date
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import non_empty_list, safe_parse_date, safe_parse_float
 
-from hestia_earth.models.log import logRequirements, logShouldRun, debugMissingLookup
+from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.constant import Units
+from hestia_earth.models.utils.term import download_term
 from hestia_earth.models.utils.property import _new_property, node_has_no_property
 from hestia_earth.models.utils.product import convert_product_to_unit
 from hestia_earth.models.utils.animalProduct import FAO_LOOKUP_COLUMN, get_animalProduct_lookup_value
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from .utils import get_liveAnimal_to_animalProduct_id
 from . import MODEL
 
@@ -29,7 +30,7 @@ REQUIREMENTS = {
 LOOKUPS = {
     "liveAnimal": ["primaryMeatProductFaoProductionTermId"],
     "animalProduct": ["animalProductGroupingFAOEquivalent", "animalProductGroupingFAO"],
-    "region-animalProduct-animalProductGroupingFAO-averageColdCarcassWeight": "use value from above"
+    "region-animalProduct-animalProductGroupingFAO-averageColdCarcassWeight": ""
 }
 RETURNS = {
     "Product": [{
@@ -53,9 +54,7 @@ def _product_value(product: dict, year: int, country_id: str):
     product_id = product.get('term', {}).get('@id')
     groupingFAO = get_animalProduct_lookup_value(MODEL, product_id, FAO_LOOKUP_COLUMN)
 
-    lookup = download_lookup(LOOKUP_WEIGHT)
-    data = get_table_value(lookup, 'termid', country_id, column_name(groupingFAO))
-    debugMissingLookup(LOOKUP_WEIGHT, 'termid', country_id, groupingFAO, data, model=MODEL, term=TERM_ID)
+    data = get_region_lookup_value(LOOKUP_WEIGHT, country_id, groupingFAO, model=MODEL, term=TERM_ID)
     average_carcass_weight = safe_parse_float(extract_grouped_data_closest_date(data, year), None)
     # average_carcass_weight is in hg, divide by 10 to go back to kg
     kg_carcass_weight = average_carcass_weight / 10 if average_carcass_weight else None
@@ -77,7 +76,7 @@ def _run_liveAnimal(cycle: dict, product: dict, year: int, country_id: str):
     product_id = product.get('term', {}).get('@id')
     animal_product_id = get_liveAnimal_to_animalProduct_id(product_id, LOOKUPS['liveAnimal'][0], term=TERM_ID)
 
-    animal_product_term = download_hestia(animal_product_id) if animal_product_id else {}
+    animal_product_term = download_term(animal_product_id, TermTermType.ANIMALPRODUCT) if animal_product_id else {}
     kg_liveweight, groupingFAO = _product_value({**product, 'term': animal_product_term}, year, country_id)
 
     logRequirements(cycle, model=MODEL, term=product_id, property=TERM_ID,