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

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,73 @@ 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
+
+
+def format_conditional_message(value: bool, on_true: str = "True", on_false: str = "False") -> str:
+    return format_str(on_true if bool(value) else on_false)