hestia-earth-models 0.74.14__py3-none-any.whl → 0.74.16__py3-none-any.whl

hestia_earth/models/cache_nodes.py

@@ -144,14 +144,17 @@ def _cache_sites(nodes: list, batch_size: int = _CACHE_BATCH_SIZE):
     return list(nodes_mapping.values())
 
 
-def run(nodes: list):
-    init_gee()
-
+def cache_nodes(nodes: list):
     # cache sites data
-    cached_nodes = _cache_sites(nodes)
+    nodes = _cache_sites(nodes)
 
     # cache related nodes
-    cached_nodes = _cache_related_nodes(cached_nodes) if _ENABLE_CACHE_RELATED_NODES else cached_nodes
+    nodes = _cache_related_nodes(nodes) if _ENABLE_CACHE_RELATED_NODES else nodes
 
     # cache sources
-    return _cache_sources(cached_nodes)
+    return _cache_sources(nodes)
+
+
+def run(nodes: list):
+    init_gee()
+    return cache_nodes(nodes)

hestia_earth/models/config/ImpactAssessment.json

@@ -133,17 +133,6 @@
           "replaceThreshold": ["value", 0.01]
         },
         "stage": 1
-      },
-      {
-        "key": "emissionsResourceUse",
-        "model": "linkedImpactAssessment",
-        "value": "landTransformation100YearAverageInputsProduction",
-        "runStrategy": "add_blank_node_if_missing",
-        "mergeStrategy": "list",
-        "mergeArgs": {
-          "replaceThreshold": ["value", 0.01]
-        },
-        "stage": 1
       }
     ],
     [
@@ -158,17 +147,6 @@
         },
         "stage": 1
       },
-      {
-        "key": "emissionsResourceUse",
-        "model": "hestia",
-        "value": "landTransformation100YearAverageDuringCycle",
-        "runStrategy": "always",
-        "mergeStrategy": "list",
-        "mergeArgs": {
-          "replaceThreshold": ["value", 0.01]
-        },
-        "stage": 1
-      },
       {
         "key": "emissionsResourceUse",
         "model": "cml2001Baseline",

hestia_earth/models/config/Site.json

@@ -416,6 +416,14 @@
       "mergeStrategy": "list",
       "stage": 1
     },
+    {
+      "key": "measurements",
+      "model": "hestia",
+      "value": "soilClassification",
+      "runStrategy": "add_blank_node_if_missing",
+      "mergeStrategy": "list",
+      "stage": 1
+    },
     {
       "key": "management",
       "model": "hestia",
@@ -469,7 +477,7 @@
         "value": "brackishWater",
         "runStrategy": "add_blank_node_if_missing",
         "mergeStrategy": "list",
-        "stage": 1
+        "stage": 2
       },
       {
         "key": "measurements",
@@ -477,7 +485,7 @@
         "value": "freshWater",
         "runStrategy": "add_blank_node_if_missing",
         "mergeStrategy": "list",
-        "stage": 1
+        "stage": 2
       },
       {
         "key": "measurements",
@@ -485,7 +493,7 @@
         "value": "salineWater",
         "runStrategy": "add_blank_node_if_missing",
         "mergeStrategy": "list",
-        "stage": 1
+        "stage": 2
       }
     ],
     [

hestia_earth/models/cycle/completeness/material.py

@@ -9,7 +9,7 @@ REQUIREMENTS = {
         "inputs": [{"@type": "Input", "value": "", "term.@id": "machineryInfrastructureDepreciatedAmountPerCycle"}],
         "site": {
             "@type": "Site",
-            "siteType": ["cropland", "glass or high accessible cover"]
+            "siteType": ["cropland"]
         }
     }
 }
@@ -20,8 +20,7 @@ RETURNS = {
 }
 MODEL_KEY = 'material'
 ALLOWED_SITE_TYPES = [
-    SiteSiteType.CROPLAND.value,
-    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value
+    SiteSiteType.CROPLAND.value
 ]
 
 

hestia_earth/models/emepEea2019/fuelCombustion_utils.py

@@ -15,7 +15,7 @@ _TIER = EmissionMethodTier.TIER_1.value
 
 def _run_inputs(inputs: list, tier: str, term_id: str):
     total_value = list_sum([
-        (i.get('input-value') or 0) * (i.get('operation-factor') or i.get('input-default-factor') or 0)
+        (i.get('input-value') or 0) * (i.get('operation-factor') or i.get('input-factor') or 0)
         for i in inputs
     ])
     input_term = {
@@ -45,37 +45,35 @@ def _fuel_input_data(term_id: str, lookup_col: str, input: dict):
     operation_term = input.get('operation', {})
     input_value = list_sum(input.get('value', []), None)
 
-    operation_factor = extract_grouped_data(
-        data=get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id),
-        key=input_term_id
-    ) if operation_term else None
-    input_factor = get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id)
+    operation_factor = safe_parse_float(
+        extract_grouped_data(
+            data=get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id),
+            key=input_term_id
+        ) if operation_term else None,
+        default=None
+    )
+    input_factor = safe_parse_float(get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id), default=None)
 
     return {
         'input-id': input_term_id,
         'input-termType': input_term.get('termType'),
         'input-units': input_term.get('units'),
         'input-value': input_value,
-        'input-default-factor': safe_parse_float(input_factor, default=None),
+        'input-factor': input_factor,
+        'is-valid': all([input_value is not None, (input_factor or operation_factor) is not None])
+    } | ({
         'operation-id': operation_term.get('@id'),
         'operation-termType': operation_term.get('termType'),
         'operation-units': operation_term.get('units'),
-        'operation-factor': safe_parse_float(operation_factor, default=None)
-    }
+        'operation-factor': operation_factor,
+    } if operation_term else {})
 
 
 def get_fuel_inputs(term_id: str, cycle: dict, lookup_col: str):
-    inputs = [
+    return [
         _fuel_input_data(term_id, lookup_col, i)
         for i in filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
     ]
-    valid_inputs = [
-        i for i in inputs if all([
-            i.get('input-value') is not None,
-            (i.get('operation-factor') or i.get('input-default-factor')) is not None
-        ])
-    ]
-    return inputs, valid_inputs
 
 
 def group_fuel_inputs(inputs: list):
@@ -84,15 +82,17 @@ def group_fuel_inputs(inputs: list):
 
 def _should_run(cycle: dict, term_id: str, lookup_prefix: str = None):
     electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
-    fuel_inputs, valid_inputs = get_fuel_inputs(term_id, cycle, f"{lookup_prefix or term_id}EmepEea2019")
+    fuel_inputs = get_fuel_inputs(term_id, cycle, f"{lookup_prefix or term_id}EmepEea2019")
+    all_valid_inputs = all([v['is-valid'] for v in fuel_inputs])
 
     logRequirements(cycle, model=MODEL, term=term_id,
                     termType_electricityFuel_complete=electricity_complete,
-                    fuel_inputs=log_as_table(fuel_inputs))
+                    fuel_inputs=log_as_table(fuel_inputs),
+                    all_valid_inputs=all_valid_inputs)
 
-    should_run = any([bool(valid_inputs), electricity_complete])
+    should_run = all([all_valid_inputs, electricity_complete])
     logShouldRun(cycle, MODEL, term_id, should_run, methodTier=_TIER)
-    return should_run, group_fuel_inputs(valid_inputs)
+    return should_run, group_fuel_inputs(fuel_inputs)
 
 
 def run(cycle: dict, term_id: str, lookup_prefix: str = None):

hestia_earth/models/hestia/landOccupationDuringCycle.py

@@ -2,7 +2,7 @@ from functools import reduce
 from itertools import zip_longest
 from typing import NamedTuple
 
-from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.log import format_float, format_str, logRequirements, logShouldRun, log_as_table
 
 from hestia_earth.models.utils import hectar_to_square_meter
 from hestia_earth.models.utils.constant import DAYS_IN_YEAR
@@ -178,33 +178,15 @@ def _should_run_site_data(site_data: SiteData) -> bool:
     ])
 
 
-def _format_float(value: float, unit: str = "", default: str = "None") -> str:
-    return " ".join(
-        string for string in [f"{value}", unit] if string
-    ) if isinstance(value, (float, int)) else default
-
-
-_INVALID_CHARS = {"_", ":", ",", "="}
-_REPLACEMENT_CHAR = "-"
-
-
-def _format_str(value: str, default: str = "None") -> str:
-    """Format a string for logging in a table. Remove all characters used to render the table on the front end."""
-    return (
-        reduce(lambda x, char: x.replace(char, _REPLACEMENT_CHAR), _INVALID_CHARS, str(value))
-        if value else default
-    )
-
-
 def _format_inventory(inventory: list[SiteData], default: str = "None") -> str:
     return log_as_table(
         {
-            "site-id": _format_str(site_data.id),
-            "site-area": _format_float(site_data.area, "ha"),
-            "site-duration": _format_float(site_data.duration, "days"),
-            "site-unused-duration": _format_float(site_data.unused_duration, "days"),
-            "land-cover-id": _format_str(site_data.land_cover_id),
-            "country-id": _format_str(site_data.country_id)
+            "site-id": format_str(site_data.id),
+            "site-area": format_float(site_data.area, "ha"),
+            "site-duration": format_float(site_data.duration, "days"),
+            "site-unused-duration": format_float(site_data.unused_duration, "days"),
+            "land-cover-id": format_str(site_data.land_cover_id),
+            "country-id": format_str(site_data.country_id)
         } for site_data in inventory
     ) if inventory else default
 
@@ -238,8 +220,8 @@ def _should_run(impact_assessment: dict):
         model=MODEL,
         term=TERM_ID,
         functional_unit=functional_unit,
-        product_yield=_format_float(product_yield, product.get("term", {}).get("units")),
-        economic_value_share=_format_float(economic_value_share, "pct"),
+        product_yield=format_float(product_yield, product.get("term", {}).get("units")),
+        economic_value_share=format_float(economic_value_share, "pct"),
         valid_inventory=valid_inventory,
         site_data_is_valid=site_data_is_valid,
         **site_logs,

hestia_earth/models/hestia/resourceUse_utils.py

@@ -1,10 +1,12 @@
 from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.tools import list_sum
+from hestia_earth.utils.tools import list_sum, flatten
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
-from hestia_earth.models.utils.blank_node import _gapfill_datestr, DatestrGapfillMode, DatestrFormat, _str_dates_match
+from hestia_earth.models.utils.blank_node import (
+    _gapfill_datestr, DatestrGapfillMode, DatestrFormat, _str_dates_match
+)
 from hestia_earth.models.utils.impact_assessment import get_site
 from hestia_earth.models.utils.indicator import _new_indicator
 from .utils import LAND_USE_TERMS_FOR_TRANSFORMATION, crop_ipcc_land_use_category
@@ -42,7 +44,17 @@ def _find_closest_node_date(
     return filtered_dates[min(filtered_dates.keys())] if filtered_dates else ""
 
 
-def should_run(impact_assessment: dict, term_id: str, historic_date_offset: int) -> tuple[bool, dict, str, str]:
+def _get_current_nodes(management_nodes: list, ia_date_str: str) -> list:
+    return [
+        node for node in management_nodes
+        if (
+                node.get("startDate") and node.get("endDate")
+                and node.get("startDate") <= ia_date_str <= node.get("endDate")
+        )
+    ]
+
+
+def should_run(impact_assessment: dict, term_id: str, historic_date_offset: int) -> tuple[bool, list]:
     cycle = impact_assessment.get('cycle', {})
     has_otherSites = len(cycle.get('otherSites') or []) != 0
 
@@ -64,26 +76,45 @@ def should_run(impact_assessment: dict, term_id: str, historic_date_offset: int)
         node_date_field=match_date
     )
     closest_start_date, closest_end_date = (closest_date, None) if match_date == "startDate" else (None, closest_date)
-    current_node_index = next(
-        (i for i, node in enumerate(filtered_management_nodes)
-         if _str_dates_match(
-            date_str_one=node.get(match_date, ""),
-            date_str_two=impact_assessment.get(match_date, ""),
-            mode=match_mode
-        )),
-        None
-    )
-    current_node = filtered_management_nodes.pop(current_node_index) if current_node_index is not None else None
-    landCover_term_id = (current_node or {}).get('term', {}).get('@id')
-
     prior_management_nodes = [
         node for node in filtered_management_nodes
         if _str_dates_match(node.get("endDate", ""), closest_end_date) or
         _str_dates_match(node.get("startDate", ""), closest_start_date)
     ]
 
-    ipcc_land_use_category = crop_ipcc_land_use_category(landCover_term_id)
+    current_nodes = _get_current_nodes(
+        management_nodes=filtered_management_nodes,
+        ia_date_str=_gapfill_datestr(impact_assessment.get(match_date, ""), mode=match_mode)[:10],
+    )
 
+    should_run_node_results = [
+        should_run_node(
+            current_node=node,
+            closest_end_date=closest_end_date,
+            closest_start_date=closest_start_date,
+            has_otherSites=has_otherSites,
+            impact_assessment=impact_assessment,
+            prior_management_nodes=prior_management_nodes,
+            term_id=term_id
+        )
+        for node in current_nodes
+    ]
+    should_run_result = all([n[0] for n in should_run_node_results])
+    logShouldRun(impact_assessment, MODEL, term=term_id, should_run=should_run_result)
+    return should_run_result, flatten([n[1] for n in should_run_node_results])
+
+
+def should_run_node(
+    current_node,
+    closest_end_date,
+    closest_start_date,
+    has_otherSites: bool,
+    impact_assessment: dict,
+    prior_management_nodes: list,
+    term_id: str
+) -> tuple[bool, list]:
+    landCover_term_id = (current_node or {}).get('term', {}).get('@id')
+    ipcc_land_use_category = crop_ipcc_land_use_category(landCover_term_id)
     total_landOccupationDuringCycle = list_sum([
         node.get("value") for node in impact_assessment.get("emissionsResourceUse", [])
         if node.get("term", {}).get("@id", "") == _RESOURCE_USE_TERM_ID
@@ -112,15 +143,13 @@ def should_run(impact_assessment: dict, term_id: str, historic_date_offset: int)
                     ipcc_land_use_category=ipcc_land_use_category,
                     indicators=log_as_table(indicators))
 
-    should_run_result = all([
+    should_run_node_result = all([
         not has_otherSites,
         ipcc_land_use_category,
         total_landOccupationDuringCycle is not None,
         valid_indicators
     ])
-    logShouldRun(impact_assessment, MODEL, term=term_id, should_run=should_run_result)
-
-    return should_run_result, valid_indicators
+    return should_run_node_result, valid_indicators
 
 
 def run_resource_use(

hestia_earth/models/hestia/soilClassification.py

@@ -0,0 +1,314 @@
+from functools import reduce
+from typing import NamedTuple, Optional
+from pydash import merge
+
+from hestia_earth.schema import MeasurementMethodClassification, TermTermType
+from hestia_earth.utils.blank_node import get_node_value, flatten
+from hestia_earth.utils.model import filter_list_term_type
+
+from hestia_earth.models.hestia.soilMeasurement import STANDARD_DEPTHS
+from hestia_earth.models.ipcc2019.organicCarbonPerHa_utils import (
+    IPCC_SOIL_CATEGORY_TO_SOIL_TYPE_LOOKUP_VALUE, IpccSoilCategory
+)
+from hestia_earth.models.log import format_bool, format_float, format_str, log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.utils import split_on_condition
+from hestia_earth.models.utils.blank_node import node_lookup_match, split_nodes_by_dates
+from hestia_earth.models.utils.measurement import _new_measurement
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "optional": {
+            "measurements": [{
+                "@type": "Measurement",
+                "value": "",
+                "depthUpper": "",
+                "depthLower": "",
+                "term.termType": "soilType",
+                "optional": {
+                    "dates": ""
+                }
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Measurement": [{
+        "value": "",
+        "depthUpper": "",
+        "depthLower": "",
+        "methodClassification": "modelled using other measurements"
+    }]
+}
+LOOKUPS = {
+    "soilType": "IPCC_SOIL_CATEGORY"
+}
+TERM_ID = 'organicSoils,mineralSoils'
+
+MEASUREMENT_TERM_IDS = TERM_ID.split(',')
+ORGANIC_SOILS_TERM_ID = MEASUREMENT_TERM_IDS[0]
+MINERAL_SOILS_TERM_ID = MEASUREMENT_TERM_IDS[1]
+METHOD = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
+
+TARGET_LOOKUP_VALUE = IPCC_SOIL_CATEGORY_TO_SOIL_TYPE_LOOKUP_VALUE[IpccSoilCategory.ORGANIC_SOILS]
+
+IS_100_THRESHOLD = 99.5
+
+
+def _measurement(term_id: str, **kwargs):
+    measurement = _new_measurement(term_id)
+    return measurement | {
+        **{k: v for k, v in kwargs.items()},
+        "methodClassification": METHOD
+    }
+
+
+class _SoilTypeDatum(NamedTuple):
+    term_id: str
+    depth_upper: float
+    depth_lower: float
+    dates: list[str]
+    value: float
+    is_organic: bool
+    is_complete_depth: bool
+    is_standard_depth: bool
+
+
+class _InventoryKey(NamedTuple):
+    depth_upper: float
+    depth_lower: float
+    date: Optional[str]
+
+
+_InventoryGroup = dict[str, float]
+
+_SoilTypeInventory = dict[_InventoryKey, _InventoryGroup]
+
+
+_DEFAULT_INVENTORY: _SoilTypeInventory = {
+    _InventoryKey(None, None, None): {
+        "organicSoils": 0,
+        "mineralSoils": 100
+    }
+}
+
+
+def _soil_type_data_to_inventory_keys(datum: _SoilTypeDatum):
+    return (
+        [_InventoryKey(datum.depth_upper, datum.depth_lower, date) for date in dates]
+        if len((dates := datum.dates)) > 0
+        else [_InventoryKey(datum.depth_upper, datum.depth_lower, None)]
+    )
+
+
+def _extract_soil_type_data(node: dict) -> _SoilTypeDatum:
+    depth_upper = node.get("depthUpper")
+    depth_lower = node.get("depthLower")
+    depth_interval = (depth_upper, depth_lower)
+
+    return _SoilTypeDatum(
+        term_id=node.get("term", {}).get("@id"),
+        depth_upper=depth_upper,
+        depth_lower=depth_lower,
+        dates=node.get("dates", []),
+        value=get_node_value(node),
+        is_organic=node_lookup_match(node, LOOKUPS["soilType"], TARGET_LOOKUP_VALUE),
+        is_complete_depth=all(depth is not None for depth in depth_interval),
+        is_standard_depth=depth_interval in STANDARD_DEPTHS,
+    )
+
+
+def _classify_soil_type_data(soil_type_data: list[_SoilTypeDatum]):
+    """
+    Calculate the values of `organicSoils` and `mineralSoils` from `soilType` measurements for each unique combination
+    of depth interval and date.
+    """
+
+    def classify(inventory: _SoilTypeInventory, datum: _SoilTypeDatum) -> _SoilTypeInventory:
+        """
+        Sum the values of organic and mineral `soilType` Measurements by depth interval and date.
+        """
+        keys = _soil_type_data_to_inventory_keys(datum)
+
+        inner_key = ORGANIC_SOILS_TERM_ID if datum.is_organic else MINERAL_SOILS_TERM_ID
+
+        update_dict = {
+            key: (inner := inventory.get(key, {})) | {
+                inner_key: min(inner.get(inner_key, 0) + datum.value, 100)
+            } for key in keys
+        }
+
+        return merge(dict(), inventory, update_dict)
+
+    inventory = _select_most_complete_groups(reduce(classify, soil_type_data, {}))
+
+    return {
+        key: {
+            ORGANIC_SOILS_TERM_ID: (org := group.get(ORGANIC_SOILS_TERM_ID, 0)),
+            MINERAL_SOILS_TERM_ID: 100 - org
+        } for key, group in inventory.items()
+    }
+
+
+def _group_keys_by_depth(inventory: _SoilTypeInventory) -> dict[tuple, list[_InventoryKey]]:
+
+    def group(result: dict[tuple, list[_InventoryKey]], key: _InventoryKey) -> dict[tuple, list[_InventoryKey]]:
+        depth_interval = (key.depth_upper, key.depth_lower)
+        update_dict = {depth_interval: result.get(depth_interval, []) + [key]}
+        return result | update_dict
+
+    return reduce(group, inventory.keys(), {})
+
+
+def _select_most_complete_groups(inventory: _SoilTypeInventory):
+    """
+    For each depth interval, we need to choose the inventory items that have the most complete information.
+
+    Items should be prioritised in the following order:
+
+    - If only dated items are available, use dated
+    - If only undated items are available, use undated
+    - If there are a mix of dated and undated items:
+        - If dated items include organic soils measurements, use dated
+        - If undated items include organic soils measurements, use undated
+        - Otherwise, use dated
+    """
+    grouped = _group_keys_by_depth(inventory)
+
+    def select(result: set[_InventoryKey], keys: list[_InventoryKey]) -> set[_InventoryKey]:
+        with_dates, without_dates = split_on_condition(set(keys), lambda k: k.date is not None)
+
+        with_dates_have_org_value = any(
+            (
+                ORGANIC_SOILS_TERM_ID in (group := inventory.get(key, {}))
+                or group.get(MINERAL_SOILS_TERM_ID, 0) >= IS_100_THRESHOLD
+            ) for key in with_dates
+        )
+
+        without_dates_have_org_value = any(
+            (
+                ORGANIC_SOILS_TERM_ID in (group := inventory.get(key, {}))
+                or group.get(MINERAL_SOILS_TERM_ID, 0) >= IS_100_THRESHOLD
+            ) for key in without_dates
+        )
+
+        run_with_dates = (
+            with_dates_have_org_value
+            or (with_dates and not without_dates_have_org_value)
+        )
+
+        return result | (with_dates if run_with_dates else without_dates)
+
+    selected_keys = reduce(select, grouped.values(), set())
+
+    return {k: v for k, v in inventory.items() if k in selected_keys}
+
+
+def _format_dates(dates: list[str]):
+    """Format a list of datestrings for logging."""
+    return " ".join(format_str(date) for date in dates) if isinstance(dates, list) and len(dates) else "None"
+
+
+_DATUM_KEY_TO_FORMAT_FUNC = {
+    "depth_upper": lambda x: format_float(x, "cm"),
+    "depth_lower": lambda x: format_float(x, "cm"),
+    "dates": _format_dates,
+    "value": lambda x: format_float(x, "pct area"),
+    "is_organic": format_bool,
+    "is_complete_depth": format_bool,
+    "is_standard_depth": format_bool,
+}
+DEFAULT_FORMAT_FUNC = format_str
+
+
+def _format_soil_data(data: list[_SoilTypeDatum]):
+    return log_as_table(
+        {
+            format_str(k): _DATUM_KEY_TO_FORMAT_FUNC.get(k, DEFAULT_FORMAT_FUNC)(v) for k, v in datum._asdict().items()
+        } for datum in data
+    ) if data else "None"
+
+
+_FILTER_BY = (
+    "is_standard_depth",
+    "is_complete_depth"
+)
+
+
+def _filter_data_by_depth_availability(data: list[_SoilTypeDatum]):
+    """
+    If measurements with depth available -> discard measurements without depth
+    If measurements with standard depth available -> discard non-standard depths
+    Else, use measurements with depth
+    """
+    return next(
+        (
+            (filter_, result) for filter_ in _FILTER_BY
+            if (result := [datum for datum in data if datum.__getattribute__(filter_)])
+        ),
+        (None, data)
+    )
+
+
+def _should_run(site: dict):
+    soil_type_nodes = split_nodes_by_dates(
+        filter_list_term_type(site.get("measurements", []), TermTermType.SOILTYPE)
+    )
+
+    filtered_by, soil_type_data = _filter_data_by_depth_availability(
+        [_extract_soil_type_data(node) for node in soil_type_nodes]
+    )
+
+    inventory = _classify_soil_type_data(soil_type_data) if soil_type_data else _DEFAULT_INVENTORY
+
+    should_run = all([
+        inventory
+    ])
+
+    for term_id in MEASUREMENT_TERM_IDS:
+
+        logRequirements(
+            site,
+            model=MODEL,
+            term=term_id,
+            soil_type_data=_format_soil_data(soil_type_data),
+            filtered_by=format_str(filtered_by)
+        )
+
+        logShouldRun(site, MODEL, term_id, should_run)
+
+    return should_run, inventory
+
+
+_INVENTORY_KEY_TO_FIELD_KEY = {
+    "depth_upper": "depthUpper",
+    "depth_lower": "depthLower",
+    "date": "dates"
+}
+_INVENTORY_KEY_TO_FIELD_VALUE = {
+    "date": lambda x: [x]
+}
+
+
+def _key_to_measurement_fields(key: _InventoryKey):
+    return {
+        _INVENTORY_KEY_TO_FIELD_KEY.get(k, k): _INVENTORY_KEY_TO_FIELD_VALUE.get(k, lambda x: x)(v)
+        for k, v in key._asdict().items() if v is not None
+    }
+
+
+def _run(inventory: _SoilTypeInventory) -> list[dict]:
+    return flatten(
+        [
+            _measurement(
+                term_id,
+                value=[value],
+                **_key_to_measurement_fields(key)
+            ) for term_id, value in value.items()
+        ] for key, value in inventory.items()
+    )
+
+
+def run(site: dict):
+    should_run, valid_inventory = _should_run(site)
+    return _run(valid_inventory) if should_run else []