hestia-earth-models 0.57.2__py3-none-any.whl → 0.59.0__py3-none-any.whl

hestia_earth/models/pooreNemecek2018/excretaKgVs.py

@@ -96,7 +96,6 @@ LOOKUPS = {
     "liveAquaticSpecies": ["excretaKgVsTermId", "allowedExcretaKgVsTermIds"]
 }
 MODEL_KEY = 'excretaKgVs'
-MODEL_LOG = '/'.join([MODEL, MODEL_KEY])
 
 Conv_AQ_CLW_CO2CR = 1
 Conv_AQ_CLW_CExcr = 0.5
@@ -121,7 +120,9 @@ def _run(excreta_product: dict, mass_balance_items: list, inputs_c: float, alter
 
 def _get_carbonContent(cycle: dict):
     primary_prod = find_primary_product(cycle) or {}
-    return safe_parse_float(get_lookup_value(primary_prod.get('term', {}), 'carbonContent', model=MODEL)) / 100
+    return safe_parse_float(
+        get_lookup_value(primary_prod.get('term', {}), 'carbonContent', model=MODEL, model_key=MODEL_KEY)
+    ) / 100
 
 
 def _get_conv_aq_ocsed(siteType: str):
@@ -146,7 +147,7 @@ def _should_run(cycle: dict):
     carbonContent = _get_carbonContent(cycle)
 
     inputs_feed = get_feed_inputs(cycle)
-    inputs_c = convert_to_carbon(cycle, MODEL_LOG, excreta_term_id, inputs_feed)
+    inputs_c = convert_to_carbon(cycle, MODEL, excreta_term_id, inputs_feed, model_key=MODEL_KEY)
 
     practices = cycle.get('practices', [])
     tsy = list_sum(find_term_match(practices, 'yieldOfPrimaryAquacultureProductLiveweightPerM2').get('value', []))
@@ -162,7 +163,7 @@ def _should_run(cycle: dict):
     excretaKgN = list_sum(excreta_n_product.get('value', [0]))
     vsc = get_node_property(excreta_n_product, 'volatileSolidsContent').get('value', 0)
 
-    logRequirements(cycle, model=MODEL_LOG, term=excreta_term_id,
+    logRequirements(cycle, model=MODEL, term=excreta_term_id, model_key=MODEL_KEY,
                     is_animalFeed_complete=is_animalFeed_complete,
                     is_product_complete=is_product_complete,
                     aqocsed=aqocsed,
@@ -187,8 +188,8 @@ def _should_run(cycle: dict):
     ])
     # only log if the excreta term does not exist to avoid showing failure when it already exists
     if should_add_product:
-        logShouldRun(cycle, MODEL_LOG, excreta_term_id, should_run)
-    logShouldRun(cycle, MODEL_LOG, None, should_run)
+        logShouldRun(cycle, MODEL, excreta_term_id, should_run, model_key=MODEL_KEY)
+    logShouldRun(cycle, MODEL, None, should_run)
     return should_run, excreta_product, mass_balance_items, inputs_c, alternate_items
 
 

hestia_earth/models/pooreNemecek2018/no3ToGroundwaterCropResidueDecomposition.py

@@ -49,9 +49,10 @@ def _emission(value: float):
 def _run(cycle: dict, N_total: float, content_list_of_items: list):
     no3ToGroundwaterSoilFlux = _get_value(cycle, N_total, content_list_of_items, TERM_ID)
     N_crop_residue = get_crop_residue_decomposition_N_total(cycle)
-    return [_emission(N_crop_residue / N_total * no3ToGroundwaterSoilFlux if all([
+    value = N_crop_residue / N_total * no3ToGroundwaterSoilFlux if all([
         N_crop_residue, N_total
-    ]) else 0)]
+    ]) else 0
+    return [_emission(value)]
 
 
 def run(cycle: dict):

hestia_earth/models/pooreNemecek2018/no3ToGroundwaterExcreta.py

@@ -54,9 +54,10 @@ def _emission(value: float):
 def _run(cycle: dict, N_total: float, content_list_of_items: list):
     no3ToGroundwaterSoilFlux = _get_value(cycle, N_total, content_list_of_items, TERM_ID)
     N_excreta = get_excreta_N_total(cycle)
-    return [_emission(N_excreta / N_total * no3ToGroundwaterSoilFlux if all([
+    value = N_excreta / N_total * no3ToGroundwaterSoilFlux if all([
         N_excreta, N_total
-    ]) else 0)]
+    ]) else 0
+    return [_emission(value)]
 
 
 def run(cycle: dict):

hestia_earth/models/pooreNemecek2018/no3ToGroundwaterInorganicFertiliser.py

@@ -49,9 +49,10 @@ def _emission(value: float):
 def _run(cycle: dict, N_total: float, content_list_of_items: list):
     no3ToGroundwaterSoilFlux = _get_value(cycle, N_total, content_list_of_items, TERM_ID)
     N_inorganic_fertiliser = get_inorganic_fertiliser_N_total(cycle)
-    return [_emission(N_inorganic_fertiliser / N_total * no3ToGroundwaterSoilFlux if all([
+    value = N_inorganic_fertiliser / N_total * no3ToGroundwaterSoilFlux if all([
         N_inorganic_fertiliser, N_total
-    ]) else 0)]
+    ]) else 0
+    return [_emission(value)]
 
 
 def run(cycle: dict):

hestia_earth/models/pooreNemecek2018/saplings.py

@@ -12,7 +12,6 @@ REQUIREMENTS = {
     "Cycle": {
         "completeness.other": "False",
         "products": [{"@type": "Product", "value": "", "term.termType": "crop"}],
-        "site": {"@type": "Site", "siteType": ["cropland", "permanent pasture"]},
         "practices": [{"@type": "Practice", "value": "", "term.@id": "plantationLifespan"}]
     }
 }

hestia_earth/models/site/management.py

@@ -0,0 +1,168 @@
+"""
+Management node with data gap-filled data from cycles.
+"""
+from typing import List
+from functools import reduce
+from hestia_earth.schema import SchemaType, TermTermType
+from hestia_earth.utils.api import download_hestia
+from hestia_earth.utils.model import filter_list_term_type, linked_node
+from hestia_earth.utils.tools import flatten
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_blank_nodes_id
+from hestia_earth.models.utils.site import related_cycles
+from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.blank_node import get_node_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "related": {
+            "Cycle": [{
+                "@type": "Cycle",
+                "startDate": "",
+                "endDate": "",
+                "products": [
+                    {
+                        "@type": "Product",
+                        "term.termType": ["crop", "forage", "landCover"]
+                    }
+                ],
+                "practices": [
+                    {
+                        "term.termType": [
+                            "waterRegime",
+                            "tillage",
+                            "cropResidueManagement",
+                            "landUseManagement"
+                        ],
+                        "value": ""
+                    }
+                ]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Management": [{
+        "@type": "Management",
+        "term.termType": [
+            "landCover", "waterRegime", "tillage", "cropResidueManagement", "landUseManagement"
+        ],
+        "value": "",
+        "endDate": "",
+        "startDate": ""
+    }]
+}
+
+MODEL_KEY = 'management'
+LAND_COVER_KEY = 'landCoverId'
+
+
+def management(data: dict):
+    node = {'@type': SchemaType.MANAGEMENT.value}
+    return node | data
+
+
+def _extract_node_value(node: dict) -> dict:
+    return node | {'value': get_node_value(node)}
+
+
+def _include(value: dict, keys: list): return {k: v for k, v in value.items() if k in keys}
+
+
+def _include_start_end(cycle: dict, values: list):
+    return [(_include(cycle, ['startDate', 'endDate']) | v) for v in values]
+
+
+def _copy_item_if_exists(source: dict, keys: List[str] = [], dest: dict = {}) -> dict:
+    return reduce(lambda p, c: p | ({c: source[c]} if c in source else {}), keys, dest)
+
+
+def _get_landCover_term_id(product: dict) -> str:
+    value = get_lookup_value(product.get('term', {}), LAND_COVER_KEY, model=MODEL, model_key=LAND_COVER_KEY)
+    # TODO: what should happen when there are multiple values?
+    return value.split(';')[0] if value else None
+
+
+def _get_items_with_relevant_term_type(cycles: List[dict], item_name: str, relevant_values: list):
+    """Get items from the list of cycles with any of the relevant values. Also adds dates if missing."""
+    return flatten(
+        [
+            _include_start_end(
+                cycle=cycle,
+                values=filter_list_term_type(cycle.get(item_name, []), relevant_values)
+            ) for cycle in cycles
+        ]
+    )
+
+
+def should_run(site: dict):
+    # Only get related cycles once.
+    cycles = related_cycles(site.get("@id"))
+
+    products_land_cover = [
+        _extract_node_value(
+            _include(
+                value=product,
+                keys=["term", "value", "startDate", "endDate", "properties"]
+            )
+        ) for product in _get_items_with_relevant_term_type(
+            cycles=cycles,
+            item_name="products",
+            relevant_values=[TermTermType.LANDCOVER]
+        )
+    ]
+
+    products_crop_forage = _get_items_with_relevant_term_type(
+        cycles=cycles,
+        item_name="products",
+        relevant_values=[TermTermType.CROP, TermTermType.FORAGE]
+    )
+    products_crop_forage = [
+        _copy_item_if_exists(
+            source=product,
+            keys=["startDate", "endDate", "properties"],
+            dest={
+                "term": linked_node(download_hestia(_get_landCover_term_id(product))),
+                "value": 100
+            }
+        )
+        for product in list(filter(_get_landCover_term_id, products_crop_forage))
+    ]
+
+    practices = [
+        _extract_node_value(
+            _include(
+                value=practice,
+                keys=["term", "value", "startDate", "endDate"]
+            )
+        ) for practice in _get_items_with_relevant_term_type(
+            cycles=cycles,
+            item_name="practices",
+            relevant_values=[
+                TermTermType.WATERREGIME,
+                TermTermType.TILLAGE,
+                TermTermType.CROPRESIDUEMANAGEMENT,
+                TermTermType.LANDUSEMANAGEMENT
+            ]
+        )
+    ]
+
+    logRequirements(
+        site,
+        model=MODEL,
+        term=None,
+        model_key=MODEL_KEY,
+        products_crop_forage_ids=log_blank_nodes_id(products_crop_forage),
+        products_land_cover_ids=log_blank_nodes_id(products_land_cover),
+        practice_ids=log_blank_nodes_id(practices)
+    )
+
+    _should_run = any(products_crop_forage + products_land_cover + practices)
+    logShouldRun(site, MODEL, None, should_run=_should_run, model_key=MODEL_KEY)
+    return _should_run, products_crop_forage + products_land_cover, practices
+
+
+def run(site: dict):
+    _should_run, products, practices = should_run(site)
+    return list(map(management, products + practices)) if _should_run else []