hestia-earth-models 0.74.1__py3-none-any.whl → 0.74.2__py3-none-any.whl

hestia_earth/models/hestia/landCover.py

@@ -28,8 +28,7 @@ from .utils import (
     TOTAL_CROPLAND,
     TOTAL_AGRICULTURAL_CHANGE,
     ALL_LAND_USE_TERMS,
-    crop_ipcc_land_use_category,
-    LAND_USE_NAMES_FROM_ID
+    crop_ipcc_land_use_category
 )
 from . import MODEL
 
@@ -839,15 +838,17 @@ def _should_run_historical_land_use_change_single_crop(
         percent_pasture_was=percent_pasture_was
     )
 
+    fao_name = _get_faostat_name(term)
+
     # Cell E8
     expansion_factor = _get_ratio_start_and_end_values(
-        expansion=changes[LAND_USE_NAMES_FROM_ID[term.get("@id")]],
+        expansion=changes[land_use_type],
         fao_name=land_use_type,
         country_id=country_id,
         end_year=end_year
-    ) if term.get("@id") in _TOP_LEVEL_LAND_USE_TYPE_IDS else get_ratio_of_expanded_area(
+    ) if term.get("@id") in _TOP_LEVEL_LAND_USE_TYPE_IDS or fao_name == "" else get_ratio_of_expanded_area(
         country_id=country_id,
-        fao_name=_get_faostat_name(term),
+        fao_name=fao_name,
         end_year=end_year
     )
 

hestia_earth/models/hestia/management.py

@@ -1,9 +1,9 @@
 from typing import List
 from datetime import timedelta, datetime
-from hestia_earth.schema import SchemaType, TermTermType, SiteSiteType, COMPLETENESS_MAPPING
+from hestia_earth.schema import SchemaType, TermTermType, COMPLETENESS_MAPPING
 from hestia_earth.utils.lookup import column_name, get_table_value, download_lookup
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import safe_parse_float, flatten
+from hestia_earth.utils.tools import safe_parse_float, flatten, is_number, is_boolean
 from hestia_earth.utils.blank_node import get_node_value
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
@@ -16,6 +16,7 @@ from hestia_earth.models.utils.site import (
     related_cycles, get_land_cover_term_id as get_landCover_term_id_from_site_type
 )
 from . import MODEL
+from ..utils.property import get_property_lookup_value
 
 REQUIREMENTS = {
     "Site": {
@@ -67,11 +68,12 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
+    "biochar": "inputGapFillManagementTermId",
     "crop": ["landCoverTermId", "maximumCycleDuration"],
     "forage": ["landCoverTermId"],
-    "inorganicFertiliser": "nitrogenContent",
-    "organicFertiliser": "ANIMAL_MANURE",
-    "soilAmendment": "PRACTICE_INCREASING_C_INPUT",
+    "inorganicFertiliser": "inputGapFillManagementTermId",
+    "organicFertiliser": "inputGapFillManagementTermId",
+    "soilAmendment": "inputGapFillManagementTermId",
     "landUseManagement": "GAP_FILL_TO_MANAGEMENT",
     "property": "GAP_FILL_TO_MANAGEMENT"
 }
@@ -87,41 +89,6 @@ _PRACTICES_TERM_TYPES = [
     TermTermType.LANDCOVER
 ]
 _PRACTICES_COMPLETENESS_MAPPING = COMPLETENESS_MAPPING.get(SchemaType.PRACTICE.value, {})
-_ANIMAL_MANURE_USED_TERM_ID = "animalManureUsed"
-_INORGANIC_NITROGEN_FERTILISER_USED_TERM_ID = "inorganicNitrogenFertiliserUsed"
-_ORGANIC_FERTILISER_USED_TERM_ID = "organicFertiliserUsed"
-_AMENDMENT_INCREASING_C_USED_TERM_ID = "amendmentIncreasingSoilCarbonUsed"
-_INPUT_RULES = {
-    TermTermType.INORGANICFERTILISER.value: (
-        (
-            TermTermType.INORGANICFERTILISER.value,  # Lookup column
-            lambda x: safe_parse_float(x, default=0) > 0,  # Condition
-            _INORGANIC_NITROGEN_FERTILISER_USED_TERM_ID  # New term.
-        ),
-    ),
-    TermTermType.SOILAMENDMENT.value: (
-        (
-            TermTermType.SOILAMENDMENT.value,
-            lambda x: bool(x) is True,
-            _AMENDMENT_INCREASING_C_USED_TERM_ID
-        ),
-    ),
-    TermTermType.ORGANICFERTILISER.value: (
-        (
-            TermTermType.SOILAMENDMENT.value,
-            lambda x: bool(x) is True,
-            _ORGANIC_FERTILISER_USED_TERM_ID
-        ),
-        (
-            TermTermType.ORGANICFERTILISER.value,
-            lambda x: bool(x) is True,
-            _ANIMAL_MANURE_USED_TERM_ID
-        )
-    )
-}
-_SKIP_LAND_COVER_SITE_TYPES = [
-    SiteSiteType.CROPLAND.value
-]
 
 
 def management(data: dict):
@@ -135,6 +102,10 @@ def management(data: dict):
     return node
 
 
+def _is_cover_crop(term_id: str) -> bool:
+    return get_property_lookup_value(model=MODEL, term_id=term_id, column="blankNodesGroup") == "Cover crops"
+
+
 def _get_cycle_duration(cycle: dict, land_cover_id: str = None):
     cycle_duration = cycle.get('cycleDuration')
     lookup_value = None if cycle_duration or not land_cover_id else safe_parse_float(get_table_value(
@@ -227,43 +198,63 @@ def _get_relevant_items(cycle: dict, item_name: str, term_types: List[TermTermTy
     ]
 
 
-def _process_rule(node: dict, term: dict) -> list:
-    term_types = []
-    for column, condition, new_term in _INPUT_RULES[term.get('termType')]:
-        lookup_result = get_lookup_value(term, LOOKUPS[column], model=MODEL, term=term.get('@id'), model_key=MODEL_KEY)
+def _input_gap_fill_term_id(input: dict):
+    return get_lookup_value(input.get('term'), 'inputGapFillManagementTermId')
 
-        if condition(lookup_result):
-            term_types.append(node | {'id': new_term})
 
-    return term_types
+def _input_value_valid(input: dict):
+    value = get_node_value(input)
+    return value > 0 if is_number(value) else bool(value) is True if is_boolean(value) else False
 
 
-def _run_from_inputs(site: dict, cycle: dict) -> list:
-    inputs = flatten([
-        _process_rule(node={
+def _run_from_inputs(cycle: dict) -> list:
+    inputs_with_ids = [
+        {
+            'input-id': input.get('term', {}).get('@id'),
+            'input-valid': _input_value_valid(input),
+            'term-id': _input_gap_fill_term_id(input)
+        } for input in cycle.get('inputs', [])
+    ]
+    return [
+        {
+            'id': input.get('term-id'),
             'value': True,
             'startDate': cycle.get('startDate'),
             'endDate': cycle.get('endDate')
-        }, term=input.get('term'))
-        for input in cycle.get('inputs', [])
-        if input.get('term', {}).get('termType') in _INPUT_RULES
+        }
+        for input in inputs_with_ids
+        if all([
+            input.get('term-id'),
+            input.get('input-valid')
+        ])
+    ]
+
+
+def _cycle_has_existing_non_cover_land_cover_nodes(cycle: dict) -> bool:
+    # if there are any landCover blank nodes in Practices without a Property from the
+    # blankNodesGroup = Cover crops lookup, return True, else False
+    return any([
+        practice for practice in cycle.get("practices", [])
+        if practice.get("term", {}).get("termType") == TermTermType.LANDCOVER.value
+        and not any(prop for prop in practice.get("properties", [])
+                    if _is_cover_crop(prop.get("term", {}).get("@id")))
     ])
-    return inputs
 
 
 def _run_from_siteType(site: dict, cycle: dict):
     site_type = site.get('siteType')
-    site_type_id = get_landCover_term_id_from_site_type(site_type) if site_type not in _SKIP_LAND_COVER_SITE_TYPES \
-        else None
+    site_type_id = get_landCover_term_id_from_site_type(site_type)
     start_date = cycle.get('startDate') or _gap_filled_start_date(
         cycle=cycle,
         end_date=cycle.get('endDate'),
         land_cover_id=site_type_id
     ).get('startDate')
+    no_land_cover_blank_node = not _cycle_has_existing_non_cover_land_cover_nodes(cycle)
 
-    should_run = all([site_type_id, start_date])
+    should_run = all([site_type_id, start_date, no_land_cover_blank_node])
     return [{
         'id': site_type_id,
+        'termType': TermTermType.LANDCOVER.value,
         'value': 100,
         'startDate': start_date,
         'endDate': cycle.get('endDate')
@@ -296,7 +287,7 @@ def _run_from_practices(cycle: dict):
 
 
 def _run_cycle(site: dict, cycle: dict):
-    inputs = _run_from_inputs(site, cycle)
+    inputs = _run_from_inputs(cycle)
     site_types = _run_from_siteType(site=site, cycle=cycle)
     practices = _run_from_practices(cycle)
     return [

hestia_earth/models/hestia/utils.py

@@ -35,7 +35,6 @@ LAND_USE_TERMS_FOR_TRANSFORMATION = {
     PERMANENT_PASTURE: ("permanentPasture", "Permanent pasture"),
     OTHER_LAND: ("otherLand", OTHER_LAND)  # Not used yet
 }
-LAND_USE_NAMES_FROM_ID = {v[0]: k for k, v in LAND_USE_TERMS_FOR_TRANSFORMATION.items()} | {"cropland": TOTAL_CROPLAND}
 
 
 def crop_ipcc_land_use_category(

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -225,7 +225,7 @@ def _run_practice(animal: dict, values: dict, meanDE: float, meanECHHV: float, R
         ])
         has_positive_feed_values = all([NEm_feed >= 0, NEg_feed >= 0])
 
-        logRequirements(animal, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
+        logRequirements(animal, model=MODEL, term=input_term_id, animalId=animal.get('animalId'), model_key=MODEL_KEY,
                         feed_logs=log_as_table(log_feed),
                         has_positive_feed_values=has_positive_feed_values,
                         animal_logs=logs,
@@ -233,7 +233,7 @@ def _run_practice(animal: dict, values: dict, meanDE: float, meanECHHV: float, R
                         animal_properties=animal_properties)
 
         should_run = all([has_positive_feed_values])
-        logShouldRun(animal, MODEL, input_term_id, should_run, model_key=MODEL_KEY)
+        logShouldRun(animal, MODEL, input_term_id, should_run, animalId=animal.get('animalId'), model_key=MODEL_KEY)
 
         return _input(input_term_id, value) if should_run else None
 
@@ -278,32 +278,37 @@ def _should_run(cycle: dict, animals: list, practices: dict):
     REM = calculate_REM(meanDE)
     REG = calculate_REG(meanDE)
 
+    has_practice_termType_system = len(systems) > 0
+    has_practice_pastureGrass_with_landCover_key = len(practices) > 0
+
     should_run = all([
         animalFeed_complete,
         animalPopulation_complete,
         freshForage_incomplete,
         no_cycle_inputs_feed,
         all_animals_have_value,
-        len(systems) > 0,
-        len(practices) > 0,
+        has_practice_termType_system,
+        has_practice_pastureGrass_with_landCover_key,
         meanDE > 0,
         meanECHHV > 0
     ])
 
     for term_id in [MODEL_KEY] + [practice_input_id(p) for p in practices]:
         for animal in animals:
-            logRequirements(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
+            logRequirements(cycle, model=MODEL, term=term_id, animalId=animal.get('animalId'), model_key=MODEL_KEY,
                             term_type_animalFeed_complete=animalFeed_complete,
                             term_type_animalPopulation_complete=animalPopulation_complete,
                             term_type_freshForage_incomplete=freshForage_incomplete,
                             no_cycle_inputs_feed=no_cycle_inputs_feed,
                             all_animals_have_value=all_animals_have_value,
+                            has_practice_termType_system=has_practice_termType_system,
+                            has_practice_pastureGrass_with_landCover_key=has_practice_pastureGrass_with_landCover_key,
                             grass_MeanDE=calculate_meanDE(practices, term=term_id),
                             grass_MeanECHHV=calculate_meanECHHV(practices, term=term_id),
                             grass_REM=REM,
                             grass_REG=REG)
 
-            logShouldRun(animal, MODEL, term_id, should_run, model_key=MODEL_KEY)
+            logShouldRun(cycle, MODEL, term_id, should_run, animalId=animal.get('animalId'), model_key=MODEL_KEY)
 
     return should_run, meanDE, meanECHHV, REM, REG, systems
 

hestia_earth/models/ipcc2019/animal/utils.py

@@ -62,7 +62,7 @@ def should_run_by_productivity_lookup(
         practice = value.get('practice')
         animal_term_id = animal.get('term').get('@id')
 
-        logRequirements(cycle, model=MODEL, term=animal_term_id, property=term_id,
+        logRequirements(cycle, model=MODEL, term=animal_term_id, animalId=animal.get('animalId'), property=term_id,
                         country_id=country_id,
                         **({
                             lookup_col.replace('-', '_'): lookup_value
@@ -75,7 +75,7 @@ def should_run_by_productivity_lookup(
             not practice_column or bool(practice),
             lookup_value is not None
         ])
-        logShouldRun(cycle, MODEL, animal_term_id, should_run, property=term_id)
+        logShouldRun(cycle, MODEL, animal_term_id, should_run, animalId=animal.get('animalId'), property=term_id)
 
         return should_run
 

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -233,14 +233,17 @@ def _should_run(cycle: dict, practices: dict):
     REM = calculate_REM(meanDE)
     REG = calculate_REG(meanDE)
 
+    has_practice_termType_system = len(systems) > 0
+    has_practice_pastureGrass_with_landCover_key = len(practices) > 0
+
     should_run = all([
         animalFeed_complete,
         animalPopulation_complete,
         freshForage_incomplete,
         has_cycle_inputs_feed,
         all_animals_have_value,
-        len(systems) > 0,
-        len(practices) > 0,
+        has_practice_termType_system,
+        has_practice_pastureGrass_with_landCover_key,
         meanDE > 0,
         meanECHHV > 0
     ])
@@ -252,6 +255,8 @@ def _should_run(cycle: dict, practices: dict):
                         term_type_freshForage_incomplete=freshForage_incomplete,
                         has_cycle_inputs_feed=has_cycle_inputs_feed,
                         all_animals_have_value=all_animals_have_value,
+                        has_practice_termType_system=has_practice_termType_system,
+                        has_practice_pastureGrass_with_landCover_key=has_practice_pastureGrass_with_landCover_key,
                         grass_MeanDE=calculate_meanDE(practices, term=term_id),
                         grass_MeanECHHV=calculate_meanECHHV(practices, term=term_id),
                         grass_REM=REM,