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

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/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/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/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/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

hestia_earth/models/ipcc2019/biocharOrganicCarbonPerHa.py

@@ -11,7 +11,7 @@ from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 from hestia_earth.utils.stats import gen_seed, truncated_normal_1d
 from hestia_earth.utils.tools import non_empty_list
 
-from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.log import format_nd_array, format_str, log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import group_nodes_by_year, filter_list_term_type
 from hestia_earth.models.utils.measurement import _new_measurement
 from hestia_earth.models.utils.property import get_node_property
@@ -280,17 +280,17 @@ def _format_inventory(inventory: dict) -> str:
     return log_as_table(
         {
             "year": year,
-            "stable-oc-from-biochar": _format_factor(inventory.get(year))
+            "stable-oc-from-biochar": format_nd_array(inventory.get(year))
         } for year in inventory_years
     ) if should_run else "None"
 
 
 def _format_logs(logs: dict):
     """
-    Format model logs. Format method selected based on dict key, with `_format_str` as fallback.
+    Format model logs. Format method selected based on dict key, with `format_str` as fallback.
     """
     return {
-        _format_str(key): _LOG_KEY_TO_FORMAT_FUNC.get(key, _format_str)(value) for key, value in logs.items()
+        format_str(key): _LOG_KEY_TO_FORMAT_FUNC.get(key, format_str)(value) for key, value in logs.items()
     }
 
 
@@ -303,45 +303,11 @@ def _format_factor_cache(factor_cache: dict) -> str:
     return log_as_table(
         {
             "term-id": term_id,
-            **{_format_str(key): _format_factor(value) for key, value in factor_dict.items()}
+            **{format_str(key): format_nd_array(value) for key, value in factor_dict.items()}
         } for term_id, factor_dict in factor_cache.items()
     ) if should_run else "None"
 
 
-def _format_factor(value) -> str:
-    """
-    Format a model factor. Method selected based on factor type (ndarray, int or float).
-    """
-    format_func = next(
-        (func for type, func in _TYPE_TO_FORMAT_FUNC.items() if isinstance(value, type)),
-        None
-    )
-    return format_func(value) if format_func else "None"
-
-
-def _format_nd_array(value) -> str:
-    return f"{np.mean(value):.3g} ± {np.std(value):.3g}"
-
-
-def _format_number(value) -> str:
-    return f"{value:.3g}"
-
-
-_INVALID_CHARS = {"_", ":", ",", "="}
-_REPLACEMENT_CHAR = "-"
-
-
-def _format_str(value: str, *_) -> 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))
-
-
-_TYPE_TO_FORMAT_FUNC = {
-    np.ndarray: _format_nd_array,
-    (float, int): _format_number
-}
-
-
 _LOG_KEY_TO_FORMAT_FUNC = {
     "factor_cache": _format_factor_cache
 }