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

hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -3,7 +3,7 @@ This model calculates the scarcity weighted water use based on the geospatial AW
 (see UNEP (2016); Boulay et al (2016); Boulay et al (2020); EC-JRC (2017)).
 """
 from hestia_earth.schema import SiteSiteType
-from hestia_earth.utils.lookup import download_lookup, _get_single_table_value, column_name, get_table_value
+from hestia_earth.utils.lookup import download_lookup, _get_single_table_value, column_name
 from hestia_earth.utils.tools import safe_parse_float
 
 from hestia_earth.models.log import logRequirements, debugMissingLookup, logShouldRun
@@ -13,6 +13,7 @@ from hestia_earth.models.utils.impact_assessment import (
     convert_value_from_cycle, emission_value, get_product, get_site, get_region_id
 )
 from hestia_earth.models.utils.input import sum_input_impacts
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -40,8 +41,8 @@ RETURNS = {
 }
 LOOKUPS = {
     "@doc": "Different lookup files are used depending on the situation",
-    "awareWaterBasinId": "using `awareWaterBasinId` and `YR_IRRI` (for `cropland`, `glass or high accessible cover`, or `permanent pasture`) or `YR_NONIRRI`",  # noqa: E501
-    "region-aware-factors": "using `region` and `YR_IRRI` (for `cropland`, `glass or high accessible cover` or `permanent pasture`) or `YR_NONIRRI`"  # noqa: E501
+    "awareWaterBasinId": "",
+    "region-aware-factors": ""
 }
 TERM_ID = 'scarcityWeightedWaterUse'
 AWARE_KEY = 'awareWaterBasinId'
@@ -71,11 +72,9 @@ def _get_factor_from_region(impact_assessment: dict, site: dict):
     region_id = get_region_id(impact_assessment)
     site_type = site.get('siteType')
     lookup_name = 'region-aware-factors.csv'
-    lookup = download_lookup(lookup_name)
     lookup_suffix = 'unspecified' if not site_type else ('irri' if site_type in IRRIGATED_SITE_TYPES else 'non_irri')
     column = f"Agg_CF_{lookup_suffix}"
-    value = get_table_value(lookup, 'termid', region_id, column_name(column))
-    debugMissingLookup(lookup_name, 'termid', region_id, column, value, model=MODEL, term=TERM_ID)
+    value = get_region_lookup_value(lookup_name, region_id, column, model=MODEL, term=TERM_ID)
     return safe_parse_float(value, None)
 
 

hestia_earth/models/blonkConsultants2016/ch4ToAirNaturalVegetationBurning.py

@@ -34,7 +34,7 @@ REQUIREMENTS = {
 }
 LOOKUPS = {
     "crop": ["isPlantation", "cropGroupingFaostatArea"],
-    "region-crop-cropGroupingFaostatArea-ch4forestBiomassBurning": "use crop grouping above or default to site.siteType"
+    "region-crop-cropGroupingFaostatArea-ch4forestBiomassBurning": ""
 }
 RETURNS = {
     "Emission": [{

hestia_earth/models/blonkConsultants2016/co2ToAirAboveGroundBiomassStockChangeLandUseChange.py

@@ -34,7 +34,7 @@ REQUIREMENTS = {
 }
 LOOKUPS = {
     "crop": ["isPlantation", "cropGroupingFaostatArea"],
-    "region-crop-cropGroupingFaostatArea-co2LandUseChange": "use crop grouping above or default to site.siteType"
+    "region-crop-cropGroupingFaostatArea-co2LandUseChange": ""
 }
 RETURNS = {
     "Emission": [{

hestia_earth/models/blonkConsultants2016/n2OToAirNaturalVegetationBurningDirect.py

@@ -34,7 +34,7 @@ REQUIREMENTS = {
 }
 LOOKUPS = {
     "crop": ["isPlantation", "cropGroupingFaostatArea"],
-    "region-crop-cropGroupingFaostatArea-n2oforestBiomassBurning": "use crop grouping above or default to site.siteType"
+    "region-crop-cropGroupingFaostatArea-n2oforestBiomassBurning": ""
 }
 RETURNS = {
     "Emission": [{

hestia_earth/models/blonkConsultants2016/utils.py

@@ -1,9 +1,10 @@
 from hestia_earth.utils.model import find_primary_product
-from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
+from hestia_earth.utils.lookup import extract_grouped_data
 from hestia_earth.utils.tools import safe_parse_float
 
-from hestia_earth.models.log import debugMissingLookup, logger
+from hestia_earth.models.log import logger
 from hestia_earth.models.utils.crop import FAOSTAT_AREA_LOOKUP_COLUMN, get_crop_grouping_faostat_area
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from . import MODEL
 
 
@@ -18,13 +19,12 @@ def get_emission_factor(term_id: str, cycle: dict, factor: str):
                  MODEL, country_id, product_id, f"'{crop_grouping}'")
 
     lookup_name = f"region-crop-{FAOSTAT_AREA_LOOKUP_COLUMN}-{factor}.csv"
-    lookup = download_lookup(lookup_name)
-    value = get_table_value(lookup, 'termid', country_id, column_name(crop_grouping)) if crop_grouping else None
-    debugMissingLookup(lookup_name, 'termid', country_id, crop_grouping, value, model=MODEL, term=term_id)
+    value = get_region_lookup_value(
+        lookup_name, country_id, crop_grouping, model=MODEL, term=term_id
+    ) if crop_grouping else get_region_lookup_value(
+        lookup_name, country_id, 'NONE', model=MODEL, term=term_id
+    )
 
     data = safe_parse_float(value, None)
     # fallback to site.siteType data if possible
-    return data if data is not None else safe_parse_float(
-        extract_grouped_data(get_table_value(lookup, 'termid', country_id, column_name('NONE')), site.get('siteType')),
-        None
-    )
+    return data if data is not None else safe_parse_float(extract_grouped_data(value, site.get('siteType')), None)

hestia_earth/models/cache_sites.py

@@ -2,7 +2,7 @@ from functools import reduce
 from enum import Enum
 from pydash.objects import merge
 from hestia_earth.utils.api import download_hestia
-from hestia_earth.utils.tools import flatten
+from hestia_earth.utils.tools import flatten, non_empty_list
 
 from .log import logger
 from .utils import CACHE_KEY, cached_value
@@ -30,14 +30,24 @@ _VALUE_AS_PARAM = {
 }
 
 
+def _value_as_param(param_type: ParamType = None): return _VALUE_AS_PARAM.get(param_type, lambda *args: None)
+
+
 def _cache_results(results: list, collections: list, index: int):
     start = index * len(collections)
     end = start + len(collections)
     return cache_site_results(results[start:end], collections)
 
 
-def _run_values(sites: list, param_type: ParamType, rasters: list = [], vectors: list = [], years: list = None):
-    param_values = list(map(_VALUE_AS_PARAM.get(param_type), sites))
+def _run_values(
+    sites: list,
+    param_type: ParamType = None,
+    rasters: list = [],
+    vectors: list = [],
+    years: list = None
+):
+    get_param_values = _value_as_param(param_type)
+    param_values = non_empty_list(map(get_param_values, sites))
     # unique list
     param_values = list(set(param_values)) if param_type == ParamType.GADM_IDS else list({
         str(v): v for v in param_values
@@ -59,13 +69,13 @@ def _run_values(sites: list, param_type: ParamType, rasters: list = [], vectors:
         site, area_size = site_values
 
         # get real index in values to handle duplicates
-        param_value = _VALUE_AS_PARAM.get(param_type)([site])
-        index = param_values.index(param_value)
+        param_value = get_param_values([site])
+        index = param_values.index(param_value) if param_value is not None else None
 
-        cached_data = {
+        cached_data = ({
             **_cache_results(raster_results, rasters, index),
             **_cache_results(vector_results, vectors, index)
-        } | ({CACHE_AREA_SIZE: area_size} if area_size is not None else {})
+        } if index is not None else {}) | ({CACHE_AREA_SIZE: area_size} if area_size is not None else {})
         cached_data = merge(cached_value(site, CACHE_GEOSPATIAL_KEY, {}), cached_data)
         site_cache = merge(
             site.get(CACHE_KEY, {}),
@@ -96,33 +106,35 @@ def _group_sites(sites: dict, check_has_cache: bool = True):
         (n, ) + (_should_run(n, area_size=get_region_area_size(n), check_has_cache=check_has_cache)) for n in sites
     ]
     # restrict sites based on should_cache result
-    sites = [(site, area_size) for site, should_cache, area_size in sites if should_cache]
+    sites_run = [(site, area_size) for site, should_cache, area_size in sites if should_cache]
+    # will only cache area and years
+    sites_no_run = [(site, area_size) for site, should_cache, area_size in sites if not should_cache]
 
     with_coordinates = [
-        (site, area_size) for site, area_size in sites if has_coordinates(site)
+        (site, area_size) for site, area_size in sites_run if has_coordinates(site)
     ]
     with_boundaries = [
-        (site, area_size) for site, area_size in sites if not has_coordinates(site) and has_boundary(site)
+        (site, area_size) for site, area_size in sites_run if not has_coordinates(site) and has_boundary(site)
     ]
     with_gadm_ids = [
-        (site, area_size) for site, area_size in sites if not has_coordinates(site) and not has_boundary(site)
+        (site, area_size) for site, area_size in sites_run if not has_coordinates(site) and not has_boundary(site)
     ]
 
     return {
         ParamType.COORDINATES: with_coordinates,
         ParamType.BOUNDARIES: with_boundaries,
         ParamType.GADM_IDS: with_gadm_ids
-    }
+    }, sites_no_run
 
 
 def _run(sites: list, years: list = [], years_only: bool = False):
     rasters = list_rasters(years=years, years_only=years_only)
     vectors = [] if years_only else list_vectors(sites)
-    filtered_data = _group_sites(sites, not years_only)
+    filtered_data, sites_no_run = _group_sites(sites, not years_only)
     return flatten([
         _run_values(filtered_data.get(param_type), param_type, rasters, vectors, years)
         for param_type in [e for e in ParamType] if len(filtered_data.get(param_type)) > 0
-    ])
+    ] + _run_values(sites_no_run, years=years))
 
 
 def run(sites: list, years: list = None):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandOccupation.py

@@ -53,8 +53,8 @@ RETURNS = {
 }
 LOOKUPS = {
     "@doc": "Different lookup files are used depending on the situation",
-    "ecoregion-siteType-LandOccupationChaudaryBrooks2018CF": "using `ecoregion`",
-    "region-siteType-LandOccupationChaudaryBrooks2018CF": "using `country`"
+    "ecoregion-siteType-LandOccupationChaudaryBrooks2018CF": "",
+    "region-siteType-LandOccupationChaudaryBrooks2018CF": ""
 }
 TERM_ID = 'damageToTerrestrialEcosystemsLandOccupation'
 LOOKUP_SUFFIX = 'LandOccupationChaudaryBrooks2018CF'

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandTransformation.py

@@ -41,8 +41,8 @@ RETURNS = {
 }
 LOOKUPS = {
     "@doc": "Different lookup files are used depending on the situation",
-    "ecoregion-siteType-LandTransformationChaudaryBrooks2018CF": "using `ecoregion`",
-    "region-siteType-LandTransformationChaudaryBrooks2018CF": "using `country`"
+    "ecoregion-siteType-LandTransformationChaudaryBrooks2018CF": "",
+    "region-siteType-LandTransformationChaudaryBrooks2018CF": ""
 }
 TERM_ID = 'damageToTerrestrialEcosystemsLandTransformation'
 

hestia_earth/models/chaudharyBrooks2018/utils.py

@@ -3,14 +3,14 @@ from hestia_earth.utils.tools import safe_parse_float
 
 from hestia_earth.models.log import debugMissingLookup, logRequirements
 from hestia_earth.models.utils.impact_assessment import get_site, get_country_id
+from hestia_earth.models.utils.lookup import get_region_lookup_value
 from . import MODEL
 
 
-def _lookup_value(term_id: str, lookup_name: str, col_match: str, col_val: str, column: str, group_key: str = None):
-    value = get_table_value(download_lookup(f"{lookup_name}.csv"), col_match, col_val, column_name(column))
-    value = extract_grouped_data(value, group_key) if group_key else value
-    debugMissingLookup(f"{lookup_name}.csv", col_match, col_val, column, value, model=MODEL, term=term_id)
-    return safe_parse_float(value)
+def _lookup_value(term_id: str, lookup_name: str, col_match: str, col_val: str, column: str):
+    value = get_table_value(download_lookup(lookup_name), col_match, col_val, column_name(column))
+    debugMissingLookup(lookup_name, col_match, col_val, column, value, model=MODEL, term=term_id)
+    return value
 
 
 def get_region_factor(term_id: str, impact_assessment: dict, lookup_suffix: str, group_key: str = None):
@@ -20,12 +20,17 @@ def get_region_factor(term_id: str, impact_assessment: dict, lookup_suffix: str,
     site_type = site.get('siteType')
 
     lookup_prefix = 'ecoregion' if ecoregion else 'region' if country_id else None
-    col_name = 'ecoregion' if ecoregion else 'termid'
-    col_val = ecoregion or country_id
+    lookup_name = f"{lookup_prefix}-siteType-{lookup_suffix}.csv"
 
     logRequirements(impact_assessment, model=MODEL, term=term_id,
                     site_type=site_type,
                     ecoregion=ecoregion,
                     country_id=country_id)
 
-    return _lookup_value(term_id, f"{lookup_prefix}-siteType-{lookup_suffix}", col_name, col_val, site_type, group_key)
+    value = get_region_lookup_value(
+        lookup_name, country_id, site_type, model=MODEL, term=term_id
+    ) if lookup_prefix == 'region' else _lookup_value(
+        term_id, lookup_name, 'ecoregion', ecoregion, site_type
+    )
+    value = extract_grouped_data(value, group_key) if group_key else value
+    return safe_parse_float(value)

hestia_earth/models/cml2001Baseline/abioticResourceDepletionFossilFuels.py

@@ -17,7 +17,7 @@ Source: [JRC Technical reports Suggestions for updating the Product Environmenta
 Source: [Differences between EF model versions](https://eplca.jrc.ec.europa.eu/EFVersioning.html)
 """  # noqa: E501
 from itertools import chain
-from hestia_earth.utils.lookup import download_lookup, column_name
+from hestia_earth.utils.lookup import download_lookup, column_name, find_term_ids_by
 from hestia_earth.utils.tools import list_sum, flatten
 
 from hestia_earth.models.log import logShouldRun, logRequirements, log_as_table
@@ -66,8 +66,7 @@ def get_all_non_renewable_terms(lookup_file_name: str, column: str) -> list:
     returns all non renewable term ids in lookup files like `electricity.csv` or `fuel.csv`
     """
     lookup = download_lookup(lookup_file_name)
-    results = lookup[lookup[column_name(column)] == True]["termid"]  # noqa: E712
-    return list(map(str, results))
+    return find_term_ids_by(lookup, column_name(column), True)
 
 
 def _valid_resource_indicator(resource: dict) -> bool:

hestia_earth/models/cml2001Baseline/abioticResourceDepletionMineralsAndMetals.py

@@ -95,7 +95,7 @@ def _should_run(impact_assessment: dict) -> tuple[bool, list]:
                     "indicator-input-is-valid": _valid_input(input),
                     "value": _node_value(resource_indicator),
                     "coefficient": get_table_value(
-                        array=download_lookup(filename=f"{input.get('termType')}.csv"),
+                        lookup=download_lookup(filename=f"{input.get('termType')}.csv"),
                         col_match='termid',
                         col_match_with=input.get('@id'),
                         col_val=column_name(LOOKUPS.get(input.get('termType'), ''))) if input else None

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/config/Cycle.json

@@ -1183,6 +1183,21 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "ipcc2019",
+        "value": "nonCo2EmissionsToAirNaturalVegetationBurning",
+        "runStrategy": "always",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
       {
         "key": "emissions",
         "model": "schmidt2007",

hestia_earth/models/config/ImpactAssessment.json

@@ -865,7 +865,20 @@
       },
       "stage": 1
     },
-
+    {
+      "key": "impacts",
+      "model": "environmentalFootprintV3-1",
+      "value": "photochemicalOzoneCreationPotentialHumanHealthNmvocEq",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": [
+          "value",
+          0.01
+        ]
+      },
+      "stage": 1
+    },
     {
       "key": "impacts",
       "model": "environmentalFootprintV3-1",

hestia_earth/models/config/Site.json

@@ -340,6 +340,14 @@
         "runStrategy": "add_blank_node_if_missing",
         "mergeStrategy": "list",
         "stage": 1
+      },
+      {
+        "key": "measurements",
+        "model": "geospatialDatabase",
+        "value": "altitude",
+        "runStrategy": "add_blank_node_if_missing",
+        "mergeStrategy": "list",
+        "stage": 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/cycle/excretaKgMass.py

@@ -4,12 +4,12 @@ Excreta (kg)
 This model calculates the amount of excreta in `kg` based on the amount of excreta in `kg N` or `kg Vs`.
 """
 from hestia_earth.schema import NodeType, TermTermType
-from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import filter_list_term_type, find_term_match
 from hestia_earth.utils.tools import non_empty_list, list_sum
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils import get_kg_term_id, get_kg_N_term_id, get_kg_VS_term_id
+from hestia_earth.models.utils.term import download_term
 from hestia_earth.models.utils.constant import Units
 from hestia_earth.models.utils.product import _new_product, convert_product_to_unit
 from . import MODEL
@@ -68,7 +68,7 @@ def _run_product(cycle: dict, product_term_id: str):
     ]
 
     # convert to 1kg first, then apply ratio to current value
-    term = download_hestia(product_term_id)
+    term = download_term(product_term_id, TermTermType.EXCRETA)
     product = {
         'term': term,
         'value': [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/cycle/materialAndSubstrate.py

@@ -5,7 +5,7 @@ This model gap-fills depreciated amount per Cycle from Site Infrastructure node.
 """
 from typing import Union
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.lookup import download_lookup
+from hestia_earth.utils.lookup import download_lookup, lookup_term_ids
 from hestia_earth.utils.tools import to_precision, flatten, list_sum
 from hestia_earth.utils.model import filter_list_term_type
 
@@ -100,7 +100,8 @@ def _run_input(cycle: dict, input_node: dict) -> dict:
 
 def _has_depreciated_term(term: dict):
     lookup = download_lookup(f"{term.get('termType')}.csv")
-    return term.get('@id') + _ID_SUFFIX in list(lookup.termid)
+    term_ids = lookup_term_ids(lookup)
+    return term.get('@id') + _ID_SUFFIX in term_ids
 
 
 def _should_run_input(cycle: dict, input_node: dict) -> bool:

hestia_earth/models/cycle/pastureGrass.py

@@ -1,9 +1,9 @@
-from hestia_earth.schema import SiteSiteType
-from hestia_earth.utils.api import download_hestia
+from hestia_earth.schema import SiteSiteType, TermTermType
 from hestia_earth.utils.model import linked_node
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.practice import _new_practice
+from hestia_earth.models.utils.term import download_term
 from . import MODEL
 
 REQUIREMENTS = {
@@ -27,7 +27,7 @@ KEY_TERM_ID = 'genericGrassPlant'
 def _practice():
     node = _new_practice(TERM_ID)
     node['value'] = [100]
-    node['key'] = linked_node(download_hestia(KEY_TERM_ID))
+    node['key'] = linked_node(download_term(KEY_TERM_ID, TermTermType.LANDCOVER))
     return node
 
 

hestia_earth/models/dammgen2009/noxToAirExcreta.py

@@ -15,7 +15,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "excretaManagement": "EF_NON-N"
+    "excretaManagement": "EF_NO-N"
 }
 RETURNS = {
     "Emission": [{