hestia-earth-models 0.65.5__py3-none-any.whl → 0.65.7__py3-none-any.whl

hestia_earth/models/hestia/landCover.py

@@ -6,6 +6,8 @@ functionality of the Blonk model.
 """
 import math
 from collections import defaultdict
+from datetime import datetime, timedelta
+
 from hestia_earth.schema import SiteSiteType, TermTermType
 from hestia_earth.utils.lookup import (
     download_lookup, get_table_value, column_name,
@@ -32,6 +34,8 @@ from .utils import (
     crop_ipcc_land_use_category,
 )
 from . import MODEL
+from ..utils.blank_node import _node_date, DatestrFormat
+from ..utils.constant import DAYS_IN_YEAR
 
 REQUIREMENTS = {
     "Site": {
@@ -90,6 +94,7 @@ SITE_TYPES = {
     SiteSiteType.PERMANENT_PASTURE.value
 }
 DEFAULT_WINDOW_IN_YEARS = 20
+DATE_TOLERANCE_IN_YEARS = 2
 OUTPUT_SIGNIFICANT_DIGITS = 3
 
 
@@ -115,16 +120,6 @@ def site_area_sum_to_100(dict_of_percentages: dict):
          math.isclose(sum(dict_of_percentages.values()), 0.0, rel_tol=0.01))
 
 
-def _lookup_land_use_type(nodes: list) -> str:
-    """Look up the land use type from a management node."""
-    return "" if nodes == [] else get_lookup_value(
-        lookup_term=nodes[0].get("term", {}),
-        column=LOOKUPS.get("landCover")[1],
-        model=MODEL,
-        term=nodes[0].get("term", {})
-    )
-
-
 def get_changes(country_id: str, end_year: int) -> dict:
     """
     For each entry in ALL_LAND_USE_TERMS, creates a key: value in output dictionary, also TOTAL
@@ -512,14 +507,13 @@ def _get_net_expansion_cultivated_vs_harvested(annual_crops_net_expansion, chang
     return net_expansion_cultivated_vs_harvested
 
 
-def _should_run_historical_land_use_change(site: dict, land_use_type: str) -> tuple[bool, dict]:
-    management_nodes = filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+def _should_run_historical_land_use_change(site: dict, nodes: list, land_use_type: str) -> tuple[bool, dict]:
     # Assume a single management node for single-cropping.
     return _should_run_historical_land_use_change_single_crop(
         site=site,
-        term=management_nodes[0].get("term", {}),
+        term=nodes[0].get("term", {}),
         country_id=site.get("country", {}).get("@id"),
-        end_year=int(management_nodes[0].get("endDate")[:4]),
+        end_year=int(nodes[0].get("endDate")[:4]),
         land_use_type=land_use_type
     )
 
@@ -688,18 +682,72 @@ def _should_run_historical_land_use_change_single_crop(
     return should_run, site_area
 
 
+def _get_land_use_term_from_node(node: dict) -> str:
+    return get_lookup_value(
+        lookup_term=node.get("term", {}),
+        column=LOOKUPS.get("landCover")[1],
+        model=MODEL,
+        term=node.get("term", {})
+    )
+
+
+def _collect_land_use_types(nodes: list) -> list:
+    """Look up the land use type from management nodes."""
+    return [
+        {
+            "id": node.get("term", {}).get("@id"),
+            "land-use-type": _get_land_use_term_from_node(node),
+            "endDate": node.get("endDate")
+        } for node in nodes
+    ]
+
+
+def _no_prior_land_cover_data(nodes: list, end_date: str) -> bool:
+    target_date = (
+        datetime.strptime(end_date, DatestrFormat.YEAR_MONTH_DAY.value)
+        - timedelta(days=DEFAULT_WINDOW_IN_YEARS * DAYS_IN_YEAR)
+    )
+    previous_nodes = [
+        node for node in nodes
+        if abs(_node_date(node) - target_date) < timedelta(days=DATE_TOLERANCE_IN_YEARS * DAYS_IN_YEAR)
+    ]
+    return len(previous_nodes) == 0
+
+
 def _should_run(site: dict) -> tuple[bool, dict]:
     management_nodes = filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
-    land_use_type = _lookup_land_use_type(nodes=management_nodes)
-    should_run_result, site_area = (
-        (False, {}) if land_use_type not in {ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE}
-        else _should_run_historical_land_use_change(
-            site=site,
-            land_use_type=land_use_type
-        )
+    summarised_nodes = _collect_land_use_types(management_nodes)
+    allowed_land_use_types = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE]
+    relevant_nodes = sorted(
+        [
+            node for node in summarised_nodes
+            if node["land-use-type"] in allowed_land_use_types
+        ],
+        key=lambda n: n.get("endDate")
     )
+    land_use_type = relevant_nodes[0].get("land-use-type") if relevant_nodes else None
 
-    return should_run_result, site_area
+    has_no_prior_land_cover_data = _no_prior_land_cover_data(
+        nodes=management_nodes,
+        end_date=relevant_nodes[-1:][0].get("endDate")
+    ) if relevant_nodes else None
+
+    should_run_nodes, site_area = _should_run_historical_land_use_change(
+        site=site,
+        nodes=management_nodes,
+        land_use_type=land_use_type
+    ) if all([land_use_type, has_no_prior_land_cover_data]) else (False, {})
+
+    logRequirements(site, model=MODEL, model_key=MODEL_KEY,
+                    has_management_nodes=bool(management_nodes),
+                    land_use_type=land_use_type,
+                    allowed_land_use_types=';'.join(allowed_land_use_types),
+                    has_no_prior_land_cover_data=has_no_prior_land_cover_data,
+                    summarised_nodes=log_as_table(summarised_nodes))
+
+    should_run = all([land_use_type, has_no_prior_land_cover_data, should_run_nodes])
+    logShouldRun(site, MODEL, None, should_run, model_key=MODEL_KEY)
+    return should_run_nodes, site_area
 
 
 def run(site: dict) -> list:

hestia_earth/models/ipcc2019/animal/hoursWorkedPerDay.py

@@ -0,0 +1,38 @@
+from .utils import should_run_by_productivity_lookup, run_animal_by_productivity
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "none": {
+                "properties": [{
+                    "@type": "Property",
+                    "value": "",
+                    "term.@id": "hoursWorkedPerDay"
+                }]
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-liveAnimal-hoursWorkedPerDay": "hours worked per day"
+}
+RETURNS = {
+    "Animal": [{
+        "properties": [{
+            "@type": "Property",
+            "value": ""
+        }]
+    }]
+}
+TERM_ID = 'hoursWorkedPerDay'
+
+
+def run(cycle: dict):
+    animals = should_run_by_productivity_lookup(TERM_ID, cycle, list(LOOKUPS.keys())[0])
+    return list(map(run_animal_by_productivity(TERM_ID), animals))