hestia-earth-models 0.74.14__tar.gz → 0.74.15__tar.gz

{hestia_earth_models-0.74.14 → hestia_earth_models-0.74.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.74.14
+Version: 0.74.15
 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.74.14 → hestia_earth_models-0.74.15}/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-0.74.14 → hestia_earth_models-0.74.15}/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-0.74.14 → hestia_earth_models-0.74.15}/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-0.74.15/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 []

{hestia_earth_models-0.74.14 → hestia_earth_models-0.74.15}/hestia_earth/models/ipcc2019/aboveGroundBiomass.py

@@ -2,7 +2,7 @@ from enum import Enum
 from functools import reduce
 from numpy import average, copy, random, vstack
 from numpy.typing import NDArray
-from typing import Optional, Union
+from typing import Union
 from hestia_earth.schema import (
     MeasurementMethodClassification,
     MeasurementStatsDefinition,
@@ -12,7 +12,7 @@ from hestia_earth.utils.tools import non_empty_list
 from hestia_earth.utils.stats import gen_seed
 from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 
-from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.log import format_bool, format_float, log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.blank_node import group_nodes_by_year
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
@@ -338,7 +338,7 @@ def _format_inventory(inventory: dict) -> str:
         {
             "year": year,
             **{
-                _format_column_header(category): _format_number(
+                _format_column_header(category): format_float(
                     inventory.get(year, {}).get(_InventoryKey.LAND_COVER_SUMMARY, {}).get(category, 0)
                 ) for category in land_covers
             },
@@ -384,16 +384,6 @@ def _get_loggable_inventory_keys(inventory: dict) -> list:
     return sorted(unique_keys, key=lambda key_: key_order[key_])
 
 
-def _format_bool(value: Optional[bool]) -> str:
-    """Format a bool for logging in a table."""
-    return str(bool(value))
-
-
-def _format_number(value: Optional[float]) -> str:
-    """Format a float for logging in a table."""
-    return f"{value:.1f}" if isinstance(value, (float, int)) else "None"
-
-
 def _format_column_header(value: Union[_InventoryKey, BiomassCategory, str]):
     """Format an enum or str for logging as a table column header."""
     as_string = value.value if isinstance(value, Enum) else str(value)
@@ -401,8 +391,8 @@ def _format_column_header(value: Union[_InventoryKey, BiomassCategory, str]):
 
 
 _INVENTORY_KEY_TO_FORMAT_FUNC = {
-    _InventoryKey.LAND_COVER_CHANGE_EVENT: _format_bool,
-    _InventoryKey.YEARS_SINCE_LCC_EVENT: _format_number
+    _InventoryKey.LAND_COVER_CHANGE_EVENT: format_bool,
+    _InventoryKey.YEARS_SINCE_LCC_EVENT: format_float
 }
 """
 Map inventory keys to format functions. The columns in inventory logged as a table will also be sorted in the order of

{hestia_earth_models-0.74.14 → hestia_earth_models-0.74.15}/hestia_earth/models/ipcc2019/belowGroundBiomass.py

@@ -2,7 +2,7 @@ from enum import Enum
 from functools import reduce
 from numpy import average, copy, random, vstack
 from numpy.typing import NDArray
-from typing import Optional, Union
+from typing import Union
 from hestia_earth.schema import (
     MeasurementMethodClassification,
     MeasurementStatsDefinition,
@@ -12,7 +12,7 @@ from hestia_earth.utils.tools import non_empty_list
 from hestia_earth.utils.stats import gen_seed
 from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 
-from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.log import format_bool, format_float, log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.blank_node import group_nodes_by_year
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
@@ -325,7 +325,7 @@ def _format_inventory(inventory: dict) -> str:
         {
             "year": year,
             **{
-                _format_column_header(category): _format_number(
+                _format_column_header(category): format_float(
                     inventory.get(year, {}).get(_InventoryKey.BIOMASS_CATEGORY_SUMMARY, {}).get(category, 0)
                 ) for category in land_covers
             },
@@ -371,16 +371,6 @@ def _get_loggable_inventory_keys(inventory: dict) -> list:
     return sorted(unique_keys, key=lambda key_: key_order[key_])
 
 
-def _format_bool(value: Optional[bool]) -> str:
-    """Format a bool for logging in a table."""
-    return str(bool(value))
-
-
-def _format_number(value: Optional[float]) -> str:
-    """Format a float for logging in a table."""
-    return f"{value:.1f}" if isinstance(value, (float, int)) else "None"
-
-
 def _format_column_header(value: Union[_InventoryKey, BiomassCategory, str]):
     """Format an enum or str for logging as a table column header."""
     as_string = value.value if isinstance(value, Enum) else str(value)
@@ -388,8 +378,8 @@ def _format_column_header(value: Union[_InventoryKey, BiomassCategory, str]):
 
 
 _INVENTORY_KEY_TO_FORMAT_FUNC = {
-    _InventoryKey.LAND_COVER_CHANGE_EVENT: _format_bool,
-    _InventoryKey.YEARS_SINCE_LCC_EVENT: _format_number
+    _InventoryKey.LAND_COVER_CHANGE_EVENT: format_bool,
+    _InventoryKey.YEARS_SINCE_LCC_EVENT: format_float
 }
 """
 Map inventory keys to format functions. The columns in inventory logged as a table will also be sorted in the order of