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

hestia_earth/models/ipcc2019/nonCo2EmissionsToAirNaturalVegetationBurning.py

@@ -10,7 +10,10 @@ from hestia_earth.utils.tools import safe_parse_float
 from hestia_earth.utils.stats import gen_seed, repeat_single, truncated_normal_1d
 from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 
-from hestia_earth.models.log import debugMissingLookup, log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.log import (
+    debugMissingLookup, format_bool, format_decimal_percentage, format_float, format_nd_array, format_str, log_as_table,
+    logRequirements, logShouldRun
+)
 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
 from hestia_earth.models.utils.emission import _new_emission
@@ -670,60 +673,28 @@ def _compile_inventory(
     return should_run, inventory, logs
 
 
-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], unit: Optional[str] = None) -> str:
-    """Format a float for logging in a table."""
-    return f"{value:.1f}{f' {unit}' if unit else ''}" if isinstance(value, (float, int)) else "None"
-
-
-def _format_nd_array(value: Optional[npt.NDArray], unit: Optional[str] = None) -> str:
-    """Format a numpy array for logging in a table."""
-    return (
-        f"{_format_number(value.mean())} ± {_format_number(value.std())}" + f"{f' {unit}' if unit else ''}"
-        if isinstance(value, np.ndarray) else "None"
-    )
-
-
-def _format_decimal_percentage(value: Optional[float], unit: Optional[str] = "pct") -> str:
-    """Format a decimal percentage (0-1) as a percentage (0-100%) for logging in a table."""
-    return _format_number(value * 100, unit) if isinstance(value, (float, int)) else "None"
-
-
-_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))
-
-
 def _format_column_header(*keys: tuple[Union[Enum, str], ...]) -> str:
     """Format a variable number of enums and strings for logging as a table column header."""
-    return " ".join(_format_str(k.value if isinstance(k, Enum) else str(k)) for k in keys)
+    return " ".join(format_str(k.value if isinstance(k, Enum) else format_str(k)) for k in keys)
 
 
 def _format_eco_climate_zone(value: EcoClimateZone) -> str:
     """Format an eco-climate zone for logging."""
     return (
-        _format_str(str(value.name).lower().replace("_", " ").capitalize()) if isinstance(value, EcoClimateZone)
+        format_str(str(value.name).lower().replace("_", " ").capitalize()) if isinstance(value, EcoClimateZone)
         else "None"
     )
 
 
 _LOGS_FORMAT_DATA: dict[str, Callable] = {
-    "has_valid_site_type": _format_bool,
+    "has_valid_site_type": format_bool,
     "eco_climate_zone": _format_eco_climate_zone,
-    "has_valid_eco_climate_zone": _format_bool,
-    "has_land_cover_nodes": _format_bool,
-    "should_compile_inventory": _format_bool,
-    "percent_burned": lambda x: _format_number(x, "pct"),
+    "has_valid_eco_climate_zone": format_bool,
+    "has_land_cover_nodes": format_bool,
+    "should_compile_inventory": format_bool,
+    "percent_burned": lambda x: format_float(x, "pct"),
 }
-_DEFAULT_FORMAT_FUNC = _format_str
+_DEFAULT_FORMAT_FUNC = format_str
 
 
 def _format_logs(logs: dict) -> dict[str, str]:
@@ -735,23 +706,23 @@ def _format_logs(logs: dict) -> dict[str, str]:
 
 _INVENTORY_FORMAT_DATA: dict[_InventoryKey, dict[Literal["filter_by", "format_func"], Any]] = {
     "fuel_burnt_per_category": {
-        "format_func": lambda x: _format_nd_array(x, "kg")
+        "format_func": lambda x: format_nd_array(x, "kg")
     },
     "annual_emissions": {
         "filter_by": ("term_id", ),
-        "format_func": lambda x: _format_nd_array(x, "kg")
+        "format_func": lambda x: format_nd_array(x, "kg")
     },
     "amortised_emissions": {
         "filter_by": ("term_id", ),
-        "format_func": lambda x: _format_nd_array(x, "kg")
+        "format_func": lambda x: format_nd_array(x, "kg")
     },
     "share_of_emissions": {
         "filter_by": ("cycle_id", ),
-        "format_func": _format_decimal_percentage
+        "format_func": format_decimal_percentage
     },
     "allocated_emissions": {
         "filter_by": ("term_id", "cycle_id"),
-        "format_func": lambda x: _format_nd_array(x, "kg")
+        "format_func": lambda x: format_nd_array(x, "kg")
     }
 }
 """

hestia_earth/models/ipcc2019/organicCarbonPerHa.py

@@ -2,9 +2,9 @@ from functools import reduce
 from pydash.objects import merge
 from types import ModuleType
 
-from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
+from hestia_earth.models.log import format_bool, format_enum, format_float, log_as_table, logRequirements, logShouldRun
 
-from .organicCarbonPerHa_utils import format_bool, format_bool_list, format_enum, format_number, format_number_list
+from .organicCarbonPerHa_utils import format_bool_list, format_float_list
 from . import organicCarbonPerHa_tier_1 as tier_1
 from . import organicCarbonPerHa_tier_2 as tier_2
 from . import MODEL  # noqa
@@ -204,20 +204,20 @@ def _get_unique_inventory_keys(inventory: dict) -> list:
 
 _INVENTORY_KEY_TO_FORMAT_FUNC = {
     tier_2._InventoryKey.SHOULD_RUN: format_bool,
-    tier_2._InventoryKey.TEMP_MONTHLY: format_number_list,
-    tier_2._InventoryKey.PRECIP_MONTHLY: format_number_list,
-    tier_2._InventoryKey.PET_MONTHLY: format_number_list,
+    tier_2._InventoryKey.TEMP_MONTHLY: format_float_list,
+    tier_2._InventoryKey.PRECIP_MONTHLY: format_float_list,
+    tier_2._InventoryKey.PET_MONTHLY: format_float_list,
     tier_2._InventoryKey.IRRIGATED_MONTHLY: format_bool_list,
-    tier_2._InventoryKey.SAND_CONTENT: format_number,
-    tier_2._InventoryKey.CARBON_INPUT: format_number,
-    tier_2._InventoryKey.N_CONTENT: format_number,
-    tier_2._InventoryKey.LIGNIN_CONTENT: format_number,
+    tier_2._InventoryKey.SAND_CONTENT: format_float,
+    tier_2._InventoryKey.CARBON_INPUT: format_float,
+    tier_2._InventoryKey.N_CONTENT: format_float,
+    tier_2._InventoryKey.LIGNIN_CONTENT: format_float,
     tier_2._InventoryKey.TILLAGE_CATEGORY: format_enum,
     tier_2._InventoryKey.IS_PADDY_RICE: format_bool,
     tier_1._InventoryKey.SHOULD_RUN: format_bool,
     tier_1._InventoryKey.LU_CATEGORY: format_enum,
     tier_1._InventoryKey.MG_CATEGORY: format_enum,
-    tier_1._InventoryKey.CI_CATEGORY: format_enum,
+    tier_1._InventoryKey.CI_CATEGORY: format_enum
 }
 """
 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/organicCarbonPerHa_utils.py

@@ -8,7 +8,7 @@ from hestia_earth.utils.stats import calc_z_critical
 from hestia_earth.utils.stats import (
     repeat_single, truncated_normal_1d
 )
-from hestia_earth.models.log import log_as_table
+from hestia_earth.models.log import format_bool, format_enum, format_float, log_as_table
 from hestia_earth.models.utils.blank_node import cumulative_nodes_term_match, node_term_match
 from hestia_earth.models.utils.term import get_cover_crop_property_terms, get_irrigated_terms
 
@@ -268,21 +268,6 @@ def sample_constant(*, iterations: int, value: float, **_) -> NDArray:
     return repeat_single(shape=(1, iterations), value=value)
 
 
-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_enum(value: Optional[Enum]) -> str:
-    """Format an enum for logging in a table."""
-    return value.value if isinstance(value, Enum) else "None"
-
-
 def format_bool_list(values: Optional[list[bool]]) -> str:
     """Format a list of bools for logging in a table."""
     return (
@@ -291,10 +276,10 @@ def format_bool_list(values: Optional[list[bool]]) -> str:
     )
 
 
-def format_number_list(values: Optional[list[float]]) -> str:
+def format_float_list(values: Optional[list[float]]) -> str:
     """Format a list of floats for logging in a table."""
     return (
-        " ".join(format_number(value) for value in values) or "None"if isinstance(values, list)
+        " ".join(format_float(value, ndigits=1) for value in values) or "None"if isinstance(values, list)
         else "None"
     )
 
@@ -303,7 +288,7 @@ def format_soil_inventory(inventory: list[SoilData]) -> str:
     return log_as_table(
         {
             "term-id": data.term_id,
-            "value": format_number(data.value),
+            "value": format_float(data.value),
             "category": format_enum(data.category)
         } for data in inventory
     ) if inventory else "None"

hestia_earth/models/ipcc2019/organicSoilCultivation_utils.py

@@ -1,6 +1,5 @@
 from enum import Enum
 from typing import Literal
-import numpy as np
 
 from hestia_earth.schema import SiteSiteType
 from hestia_earth.utils.model import find_primary_product
@@ -157,11 +156,3 @@ def valid_eco_climate_zone(
     Validate that the model should run for a specific eco-climate zone.
     """
     return isinstance(eco_climate_zone, EcoClimateZone) and eco_climate_zone not in _EXCLUDED_ECO_CLIMATE_ZONES
-
-
-def format_number(value) -> str:
-    return f"{value:.3g}" if isinstance(value, (float, int)) else "None"
-
-
-def format_nd_array(value) -> str:
-    return f"{np.mean(value):.3g} ± {np.std(value):.3g}" if isinstance(value, np.ndarray) else "None"

hestia_earth/models/log.py

@@ -1,7 +1,11 @@
+from enum import Enum
+from functools import reduce
 import os
 import sys
 import logging
-from typing import Union, List
+from typing import List, Optional, Union
+from numpy.typing import NDArray
+from numpy import ndarray
 
 LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
 _EXTENDED_LOGS = os.getenv('LOG_EXTENDED', 'true') == 'true'
@@ -108,3 +112,69 @@ def log_blank_nodes_id(blank_nodes: List[dict]):
         List of blank nodes, like Product, Input, Measurement, etc.
     """
     return ';'.join([p.get('term', {}).get('@id') for p in blank_nodes if p.get('term', {}).get('@id')]) or 'None'
+
+
+_INVALID_CHARS = {"_", ":", ",", "="}
+_REPLACEMENT_CHAR = "-"
+
+
+def format_str(value: Optional[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_bool(value: Optional[bool], default: str = "None") -> str:
+    return str(value) if isinstance(value, bool) else default
+
+
+def format_float(value: Union[int, float, None], unit: str = "", default: str = "None", ndigits: int = 3) -> str:
+    return " ".join(
+        string for string in [f"{round(value, ndigits)}", format_str(unit, "")] if string
+    ) if isinstance(value, (float, int)) else default
+
+
+def format_int(value: Union[int, float, None], unit: str = "", default: str = "None") -> str:
+    return format_float(value, unit=unit, default=default, ndigits=None)
+
+
+def _format_nd_array(value: Optional[NDArray], unit: str = "", default: str = "None", ndigits: int = 3) -> str:
+    return " ".join(
+        string for string in [
+            f"{format_float(value.mean(), ndigits=ndigits)} ± {format_float(value.std(), ndigits=ndigits)}",
+            format_str(unit, "")
+        ] if string
+    ) if isinstance(value, ndarray) else default
+
+
+TYPE_TO_FORMAT_FUNC = {
+    ndarray: _format_nd_array,
+    (float, int): format_float
+}
+
+
+def format_nd_array(value: Optional[NDArray], unit: str = "", default: str = "None", ndigits: int = 3) -> str:
+    """
+    Format a numpy array for logging in a table.
+
+    Values that are floats and ints are logged using `format_float`.
+    """
+    format_func = next(
+        (func for type_, func in TYPE_TO_FORMAT_FUNC.items() if isinstance(value, type_)),
+        None
+    )
+    return format_func(value, unit=unit, default=default, ndigits=ndigits) if format_func else default
+
+
+def format_decimal_percentage(
+    value: Optional[float], unit: str = "pct", default: str = "None", ndigits: int = 3
+) -> str:
+    """Format a decimal percentage (0-1) as a percentage (0-100%) for logging in a table."""
+    return format_float(value * 100, unit=unit, ndigits=ndigits) if isinstance(value, (float, int)) else default
+
+
+def format_enum(value: Optional[Enum], default: str = "None") -> str:
+    """Format an enum for logging in a table."""
+    return format_str(value.value) if isinstance(value, Enum) else default