hestia-earth-models 0.74.4__py3-none-any.whl → 0.74.5__py3-none-any.whl

hestia_earth/models/ipcc2019/co2ToAirSoilOrganicCarbonStockChange.py

@@ -1,7 +1,6 @@
-from hestia_earth.schema import CycleFunctionalUnit, EmissionMethodTier, SiteSiteType
+from hestia_earth.schema import EmissionMethodTier
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match
 from hestia_earth.models.utils.emission import _new_emission
 
 from .organicCarbonPerHa_tier_1 import _assign_ipcc_land_use_category, get_valid_management_nodes
@@ -19,7 +18,7 @@ REQUIREMENTS = {
                     "dates": "",
                     "depthUpper": "0",
                     "depthLower": "30",
-                    "term.@id": " organicCarbonPerHa"
+                    "term.@id": "organicCarbonPerHa"
                 }
             ]
         },
@@ -52,13 +51,6 @@ _DEPTH_LOWER = 30
 
 _CARBON_STOCK_TERM_ID = 'organicCarbonPerHa'
 
-_SITE_TYPE_SYSTEMS_MAPPING = {
-    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value: [
-        "protectedCroppingSystemSoilBased",
-        "protectedCroppingSystemSoilAndSubstrateBased"
-    ]
-}
-
 
 def _emission(
     *,
@@ -119,14 +111,16 @@ def run(cycle: dict) -> list[dict]:
     -------
     list[dict]
         A list of [Emission nodes](https://www.hestia.earth/schema/Emission) containing model results.
+
     """
     should_run_exec = create_should_run_function(
-        carbon_stock_term_id=_CARBON_STOCK_TERM_ID,
+        _CARBON_STOCK_TERM_ID,
+        depth_upper=_DEPTH_UPPER,
+        depth_lower=_DEPTH_LOWER,
+        measurements_mandatory=False,  # Model can allocate zero emissions to LUC with enough landCover data
         get_valid_management_nodes_func=get_valid_management_nodes,
-        should_compile_inventory_func=_should_compile_inventory_func,
         summarise_land_use_func=lambda nodes: _assign_ipcc_land_use_category(nodes, None),
-        detect_land_use_change_func=lambda a, b: a != b,
-        should_run_measurement_func=_should_run_measurement_func,
+        detect_land_use_change_func=lambda a, b: a != b
     )
 
     run_exec = create_run_function(
@@ -135,81 +129,10 @@ def run(cycle: dict) -> list[dict]:
         management_change_emission_term_id=_MG_EMISSION_TERM_ID
     )
 
-    should_run, kwargs, logs = should_run_exec(cycle)
+    should_run, cycle_id, inventory, logs = should_run_exec(cycle)
 
     for term_id in [_LU_EMISSION_TERM_ID, _MG_EMISSION_TERM_ID]:
         logRequirements(cycle, model=MODEL, term=term_id, **logs)
         logShouldRun(cycle, MODEL, term_id, should_run)
 
-    return run_exec(**kwargs) if should_run else []
-
-
-def _should_run_measurement_func(node: dict) -> bool:
-    """
-    Validate a [Measurement](https://www.hestia.earth/schema/Measurement) to determine whether it is a valid
-    `organicCarbonPerHa` node.
-
-    Parameters
-    ----------
-    node : dict
-        The node to be validated.
-
-    Returns
-    -------
-    bool
-        `True` if the node passes all validation criteria, `False` otherwise.
-    """
-    return all([
-        node.get("depthLower") == _DEPTH_LOWER,
-        node.get("depthUpper") == _DEPTH_UPPER
-    ])
-
-
-def _should_compile_inventory_func(
-    site: dict, cycles: list[dict], carbon_stock_measurements: list[dict]
-) -> tuple[bool, dict]:
-    """
-    Determine whether a site is suitable and has enough data to compile a carbon stock inventory.
-
-    Parameters
-    ----------
-    site : dict
-        A HESTIA (Site node)[https://www.hestia.earth/schema/Site]
-    cycles : list[dict]
-        A list of HESTIA (Cycle nodes)[https://www.hestia.earth/schema/Cycle] that are related to the site.
-    carbon_stock_measurements : list[dict]
-        A list of HESTIA carbon stock (Measurement nodes)[https://www.hestia.earth/schema/Measurement] that are related
-        to the site.
-
-    Returns
-    -------
-    tuple[bool, dict]
-        `(should_run, logs)`.
-    """
-    site_type = site.get("siteType")
-    has_soil = site_type not in _SITE_TYPE_SYSTEMS_MAPPING or all(
-        cumulative_nodes_term_match(
-            cycle.get("practices", []),
-            target_term_ids=_SITE_TYPE_SYSTEMS_MAPPING[site_type],
-            cumulative_threshold=0
-        ) for cycle in cycles
-    )
-
-    has_cycles = len(cycles) > 0
-    has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
-
-    should_run = all([
-        has_soil,
-        has_cycles,
-        has_functional_unit_1_ha
-    ])
-
-    logs = {
-        "site_type": site_type,
-        "has_soil": has_soil,
-        "carbon_stock_term": _CARBON_STOCK_TERM_ID,
-        "has_cycles": has_cycles,
-        "has_functional_unit_1_ha": has_functional_unit_1_ha,
-    }
-
-    return should_run, logs
+    return run_exec(cycle_id, inventory) if should_run else []

hestia_earth/models/mocking/__init__.py

@@ -7,9 +7,9 @@ CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
 RESULTS_PATH = os.path.join(CURRENT_DIR, 'search-results.json')
 
 
-def enable_mock(filepath: str, node: dict = None):
+def enable_mock(filepath: str, node: dict = None, keep_in_memory: bool = False):
     # apply mocks on search results
-    mock_search(filepath)
+    mock_search(filepath, keep_in_memory)
 
     if node is not None:
         # skip fetch bibliography data

hestia_earth/models/mocking/mock_search.py

@@ -1,4 +1,5 @@
 import json
+from functools import cache
 
 from hestia_earth.models.utils import term
 
@@ -6,31 +7,40 @@ _original_search_func = term.search
 _original_find_node_func = term.find_node
 
 
-def _load_results(filepath: str):
+def _load_results(filepath: str) -> dict:
     with open(filepath) as f:
         return json.load(f)
 
 
-def _find_search_result(filepath: str, query: dict):
-    search_results = _load_results(filepath)
+_load_results_cached = cache(_load_results)
+
+
+def _find_search_result(filepath: str, query: dict, keep_in_memory: bool):
+    _load_results_func = _load_results_cached if keep_in_memory else _load_results
+    search_results = _load_results_func(filepath)
     res = next((n for n in search_results if n['query'] == query), None)
     return None if res is None else res.get('results', [])
 
 
-def _mocked_search(filepath: str):
+def _mocked_search(filepath: str, keep_in_memory: bool):
     def mock(query: dict, **kwargs):
-        result = _find_search_result(filepath, query)
+        result = _find_search_result(filepath, query, keep_in_memory)
         return _original_search_func(query, **kwargs) if result is None else result
     return mock
 
 
-def _mocked_find_node(filepath: str):
+def _mocked_find_node(filepath: str, keep_in_memory: bool):
     def mock(node_type: str, query: dict, **kwargs):
-        result = _find_search_result(filepath, query)
+        result = _find_search_result(filepath, query, keep_in_memory)
         return _original_find_node_func(node_type, query, **kwargs) if result is None else result
     return mock
 
 
-def mock(filepath: str):
-    term.search = _mocked_search(filepath)
-    term.find_node = _mocked_find_node(filepath)
+def mock(filepath: str, keep_in_memory: bool):
+    term.search = _mocked_search(filepath, keep_in_memory)
+    term.find_node = _mocked_find_node(filepath, keep_in_memory)
+
+
+def unmock():
+    term.search = _original_search_func
+    term.find_node = _original_find_node_func