hestia-earth-models 0.65.5__tar.gz → 0.65.6__tar.gz

{hestia_earth_models-0.65.5 → hestia_earth_models-0.65.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.65.5
+Version: 0.65.6
 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.65.5 → hestia_earth_models-0.65.6}/hestia_earth/models/cml2001Baseline/abioticResourceDepletionFossilFuels.py

@@ -1,7 +1,12 @@
 """
-This model calculates the abiotic resource depletion, fossil fuels. Based on the models CML 2002 (Guinée et al., 2002) and van Oers et al. 2002 (method, v.4.8)
+This model calculates the abiotic resource depletion, fossil fuels. Based on the models CML 2002 (Guinée et al., 2002)
+and van Oers et al. 2002 (method, v.4.8)
 
->The earth contains a finite amount of non-renewable resources, such as fossil fuels like coal, oil and gas. The basic idea behind this impact category is that extracting resources today will force future generations to extract less or different resources. For example, the depletion of V2.0 – 25th August 2023 28 fossil fuels may lead to the non-availability of fossil fuels for future generations. The amount of materials contributing to resource use, fossils, are converted into MJ.
+> The earth contains a finite amount of non-renewable resources, such as fossil fuels like coal, oil and gas.
+The basic idea behind this impact category is that extracting resources today will force future generations to extract
+less or different resources. For example, the depletion of V2.0 – 25th August 2023 28 fossil fuels may lead to the
+non-availability of fossil fuels for future generations. The amount of materials contributing to resource use, fossils,
+are converted into MJ.
 
 Source : [Life Cycle Assessment & the EF methods - Comprehensive coverage of impacts](https://green-business.ec.europa.eu/environmental-footprint-methods/life-cycle-assessment-ef-methods_en)
 
@@ -89,9 +94,8 @@ def download_all_non_renewable_terms(lookup_file_name: str) -> list:
     lookup = download_lookup(lookup_file_name)
     results = lookup[
         lookup[column_name("abioticResourceDepletionFossilFuelsCml2001Baseline")] == True  # noqa: E712
-        ]["termid"]
-    terms_ids: list[str] = [str(entry) for entry in results]
-    return terms_ids
+    ]["termid"]
+    return list(map(str, results))
 
 
 def _valid_resource_indicator(resource: dict) -> bool:

{hestia_earth_models-0.65.5 → hestia_earth_models-0.65.6}/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: