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

hestia_earth/models/ipcc2019/ch4ToAirOrganicSoilCultivation.py

@@ -2,7 +2,7 @@ import numpy as np
 import numpy.typing as npt
 from typing import Callable, Union
 from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import format_nd_array, format_float, logRequirements, logShouldRun
 from hestia_earth.utils.stats import (
     discrete_uniform_1d, gen_seed, normal_1d, repeat_single, triangular_1d
 )
@@ -15,8 +15,8 @@ from hestia_earth.models.utils.measurement import most_relevant_measurement_valu
 from hestia_earth.models.utils.site import valid_site_type
 
 from .organicSoilCultivation_utils import (
-    assign_ditch_category, assign_organic_soil_category, calc_emission, DitchCategory, format_nd_array, format_number,
-    get_ditch_frac, get_emission_factor, OrganicSoilCategory, remap_categories, valid_eco_climate_zone
+    assign_ditch_category, assign_organic_soil_category, calc_emission, DitchCategory, get_ditch_frac,
+    get_emission_factor, OrganicSoilCategory, remap_categories, valid_eco_climate_zone
 )
 from . import MODEL
 
@@ -226,8 +226,8 @@ def _should_run(cycle: dict):
         emission_factor=format_nd_array(emission_factor),
         ditch_factor=format_nd_array(ditch_factor),
         ditch_frac=format_nd_array(ditch_frac),
-        land_occupation=format_number(land_occupation),
-        histosol=format_number(histosol)
+        land_occupation=format_float(land_occupation),
+        histosol=format_float(histosol)
     )
 
     should_run = all([

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -18,7 +18,7 @@ from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_date
 from hestia_earth.utils.stats import correlated_normal_2d, gen_seed
 from hestia_earth.utils.descriptive_stats import calc_descriptive_stats
 
-from hestia_earth.models.log import log_as_table
+from hestia_earth.models.log import format_bool, format_float, format_int, format_nd_array, log_as_table
 from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.blank_node import (
     _gapfill_datestr, _get_datestr_format, cumulative_nodes_term_match, DatestrGapfillMode, DatestrFormat,
@@ -1386,7 +1386,7 @@ def _format_cycle_inventory(cycle_inventory: dict) -> str:
         {
             "year": year,
             **{
-                id: _format_number(group.get(KEY, {}).get(id, 0)) for id in unique_cycles
+                id: format_float(group.get(KEY, {}).get(id, 0)) for id in unique_cycles
             }
         } for year, group in cycle_inventory.items()
     ) if should_run else "None"
@@ -1450,21 +1450,6 @@ def _format_land_use_inventory(land_use_inventory: dict) -> str:
     ) if should_run else "None"
 
 
-def _format_bool(value: Optional[bool]) -> str:
-    """Format a bool for logging in a table."""
-    return str(value) if isinstance(value, bool) else "None"
-
-
-def _format_int(value: Optional[float]) -> str:
-    """Format an int for logging in a table. If the value is invalid, return `"None"` as a string."""
-    return f"{value:.0f}" if isinstance(value, (float, int)) else "None"
-
-
-def _format_number(value: Optional[float]) -> str:
-    """Format a float for logging in a table. If the value is invalid, return `"None"` as a string."""
-    return f"{value:.1f}" if isinstance(value, (float, int)) else "None"
-
-
 def _format_column_header(method: MeasurementMethodClassification, inventory_key: _InventoryKey) -> str:
     """
     Format a measurement method classification and inventory key for logging in a table as a column header. Replace any
@@ -1483,16 +1468,16 @@ def _format_named_tuple(value: Optional[Union[CarbonStock, CarbonStockChange, Ca
     Extract and format just the value and discard the other data. If the value is invalid, return `"None"` as a string.
     """
     return (
-        _format_number(mean(value.value))
+        format_nd_array(mean(value.value))
         if isinstance(value, (CarbonStock, CarbonStockChange, CarbonStockChangeEmission))
         else "None"
     )
 
 
 _LAND_USE_INVENTORY_KEY_TO_FORMAT_FUNC = {
-    _InventoryKey.LAND_USE_CHANGE_EVENT: _format_bool,
-    _InventoryKey.YEARS_SINCE_LUC_EVENT: _format_int,
-    _InventoryKey.YEARS_SINCE_INVENTORY_START: _format_int
+    _InventoryKey.LAND_USE_CHANGE_EVENT: format_bool,
+    _InventoryKey.YEARS_SINCE_LUC_EVENT: format_int,
+    _InventoryKey.YEARS_SINCE_INVENTORY_START: format_int
 }
 """
 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/co2ToAirOrganicSoilCultivation.py

@@ -5,7 +5,7 @@ from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition
 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 logRequirements, logShouldRun
+from hestia_earth.models.log import format_float, format_nd_array, logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import land_occupation_per_ha
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
 from hestia_earth.models.utils.emission import _new_emission
@@ -13,8 +13,7 @@ from hestia_earth.models.utils.measurement import most_relevant_measurement_valu
 from hestia_earth.models.utils.site import valid_site_type
 
 from .organicSoilCultivation_utils import (
-    assign_organic_soil_category, calc_emission, format_nd_array, format_number, get_emission_factor,
-    OrganicSoilCategory, valid_eco_climate_zone
+    assign_organic_soil_category, calc_emission, get_emission_factor, OrganicSoilCategory, valid_eco_climate_zone
 )
 from . import MODEL
 
@@ -183,8 +182,8 @@ def _should_run(cycle: dict):
         eco_climate_zone=eco_climate_zone,
         organic_soil_category=organic_soil_category,
         emission_factor=format_nd_array(emission_factor),
-        land_occupation=format_number(land_occupation),
-        histosol=format_number(histosol)
+        land_occupation=format_float(land_occupation),
+        histosol=format_float(histosol)
     )
 
     should_run = all([

hestia_earth/models/ipcc2019/n2OToAirOrganicSoilCultivationDirect.py

@@ -1,6 +1,6 @@
 from hestia_earth.schema import EmissionMethodTier
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import format_float, logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import land_occupation_per_ha
 from hestia_earth.models.utils.ecoClimateZone import EcoClimateZone, get_eco_climate_zone_value
 from hestia_earth.models.utils.emission import _new_emission
@@ -8,7 +8,7 @@ from hestia_earth.models.utils.measurement import most_relevant_measurement_valu
 from hestia_earth.models.utils.site import valid_site_type
 
 from .organicSoilCultivation_utils import (
-    assign_organic_soil_category, calc_emission, format_number, get_emission_factor, OrganicSoilCategory,
+    assign_organic_soil_category, calc_emission, get_emission_factor, OrganicSoilCategory,
     remap_categories, valid_eco_climate_zone
 )
 from . import MODEL
@@ -122,9 +122,9 @@ def _should_run(cycle: dict):
         cycle, model=MODEL, term=TERM_ID,
         eco_climate_zone=eco_climate_zone,
         organic_soil_category=organic_soil_category,
-        emission_factor=f"{format_number(emission_factor_mean)} ± {format_number(emission_factor_sd)}",
-        land_occupation=format_number(land_occupation),
-        histosol=format_number(histosol)
+        emission_factor=f"{format_float(emission_factor_mean)} ± {format_float(emission_factor_sd)}",
+        land_occupation=format_float(land_occupation),
+        histosol=format_float(histosol)
     )
 
     should_run = all([

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