hestia-earth-models 0.74.0__tar.gz → 0.74.2__tar.gz

{hestia_earth_models-0.74.0 → hestia_earth_models-0.74.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.74.0
+Version: 0.74.2
 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.74.0 → hestia_earth_models-0.74.2}/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-0.74.0 → hestia_earth_models-0.74.2}/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-0.74.0 → hestia_earth_models-0.74.2}/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-0.74.0 → hestia_earth_models-0.74.2}/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-0.74.0 → hestia_earth_models-0.74.2}/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-0.74.0 → hestia_earth_models-0.74.2}/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,