hestia-earth-aggregation 0.21.14__tar.gz → 0.21.16__tar.gz

{hestia_earth_aggregation-0.21.14/hestia_earth_aggregation.egg-info → hestia_earth_aggregation-0.21.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hestia_earth_aggregation
-Version: 0.21.14
+Version: 0.21.16
 Summary: HESTIA's aggregation engine.
 Home-page: https://gitlab.com/hestia-earth/hestia-aggregation-engine
 Author: HESTIA Team

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16}/hestia_earth/aggregation/__init__.py

@@ -88,12 +88,14 @@ def aggregate(
         filter_by_country=filter_by_country,
         include_covariance=include_covariance,
     )
-    logger.info("time=%s, unit=ms", current_time_ms() - now)
+    logger.info("Aggregations finished. time=%s, unit=ms", current_time_ms() - now)
+    now = current_time_ms()
     aggregations = (
         [recalculate(agg, product) for agg in aggregations]
         if should_recalculate(product)
         else aggregations
     )
+    logger.info("Recalculations finished. time=%s, unit=ms", current_time_ms() - now)
     aggregations = [
         calculate_score(cycle=agg, countries=countries) for agg in aggregations
     ]

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16}/hestia_earth/aggregation/aggregate_cycles.py

@@ -157,7 +157,10 @@ def aggregate_country(
     functional_unit = cycles_aggregated[0].get("functionalUnit")
     include_matrix = aggregate_with_matrix(product)
     cycles_aggregated = non_empty_list(
-        [format_terms_results(cycle, product, country) for cycle in cycles_aggregated]
+        [
+            format_terms_results(cycle, product, country, start_year, end_year)
+            for cycle in cycles_aggregated
+        ]
     )
     cycles_aggregated = non_empty_list(
         map(

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16}/hestia_earth/aggregation/config/Cycle/processedFood.json

@@ -29,17 +29,29 @@
     },
     {
       "key": "emissions",
-      "model": "ecoinventV3AndEmberClimate",
+      "model": "worldSteel",
       "value": "cycle",
       "runStrategy": "always",
       "mergeStrategy": "list",
       "mergeArgs": {
         "replaceThreshold": ["value", 0.01]
-      }
+      },
+      "stage": 2
     },
     {
       "key": "emissions",
-      "model": "ecoinventV3",
+      "model": "bafu2025",
+      "value": "cycle",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      },
+      "stage": 2
+    },
+    {
+      "key": "emissions",
+      "model": "ecoinventV3AndEmberClimate",
       "value": "cycle",
       "runStrategy": "always",
       "mergeStrategy": "list",

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16}/hestia_earth/aggregation/utils/aggregate_country_nodes.py

@@ -61,7 +61,11 @@ from .site import (
     format_site_description,
     site_parent_region_id,
 )
-from .emission import get_method_tier, get_method_model
+from .emission import (
+    get_method_tier,
+    get_method_model,
+    has_value_without_transformation,
+)
 from .property import aggregate_properties
 from .distribution import generate_blank_node_distribution
 from .covariance import add_covariance_cycles, generate_covariance_cycles
@@ -110,6 +114,8 @@ class BlankNodeFormatted(TypedDict, total=False):
     completeness_key: Optional[str]
     start_date: Optional[str]
     end_date: str
+    inputs: List[dict]
+    transformation: List[dict]
 
 
 # --- Cycle
@@ -243,6 +249,8 @@ def _group_cycle_blank_node(cycle: dict, product: dict, product_value: float):
                 "economicValueShare": non_empty_list([_blank_node_evs(blank_nodes)]),
                 # needed for background emissions
                 "inputs": _map_values(blank_nodes, "inputs"),
+                # needed to exclude emissions with only transformation value
+                "transformation": _map_values(blank_nodes, "transformation"),
                 "properties": _map_values(blank_nodes, "properties"),
                 "methodTier": _map_values(blank_nodes, "methodTier"),
                 "methodModel": _map_values(blank_nodes, "methodModel"),
@@ -293,20 +301,16 @@ def _group_cycle_blank_nodes(
     end_year: int = None,
 ):
     def grouper(group: dict, list_key: str) -> Dict[str, Dict[str, BlankNodeFormatted]]:
-        now = current_time_ms()
         blank_nodes = _filter_blank_nodes(cycle, list_key, start_year, end_year)
         values = reduce(
             _group_cycle_blank_node(cycle, product, product_value), blank_nodes, {}
         )
         # after combining all values, need to compute the final statistical values
         group[list_key] = {
-            k: v | _compute_blank_node_stats(v) for k, v in values.items()
+            k: v | _compute_blank_node_stats(v)
+            for k, v in values.items()
+            if list_key != "emissions" or has_value_without_transformation(v)
         }
-        logger.debug(
-            "function=_group_cycle_blank_nodes, list_key=%s, time=%s",
-            list_key,
-            current_time_ms() - now,
-        )
         return group
 
     return grouper
@@ -323,6 +327,7 @@ def _format_cycle(
     Returns the list of formatted Cycles, and the list of Site ids to be downloaded.
     Note: if a Site does not have an `@id`, it means it's nested within the Cycle.
     """
+    now = current_time_ms()
     product_value = _cycle_product_value(cycle, product)
     data: CycleFormatted = (
         (
@@ -355,8 +360,9 @@ def _format_cycle(
     )
     if data:
         logger.debug(
-            "id=%s, yield=%s, organic=%s, irrigated=%s",
+            "id=%s, time=%sms, yield=%s, organic=%s, irrigated=%s",
             cycle.get("@id"),
+            current_time_ms() - now,
             product_value,
             data["organic"],
             data["irrigated"],
@@ -412,7 +418,6 @@ def _combine_cycle_blank_nodes(
     cycles: List[CycleFormatted], completeness: Dict[str, int], cycle_count: int
 ):
     def combine(group: dict, list_key: str):
-        now = current_time_ms()
         # get all possible keys first, then group each key values into a single blank node
         keys = set(flatten([list(cycle.get(list_key, {}).keys()) for cycle in cycles]))
         group[list_key] = reduce(
@@ -420,11 +425,6 @@ def _combine_cycle_blank_nodes(
             keys,
             {},
         )
-        logger.debug(
-            "function=_combine_cycle_blank_nodes, list_key=%s, time=%s",
-            list_key,
-            current_time_ms() - now,
-        )
         return group
 
     return combine
@@ -524,14 +524,8 @@ def _group_site_blank_nodes(
     site: SiteJSONLD, start_year: int = None, end_year: int = None
 ):
     def grouper(group: dict, list_key: str) -> Dict[str, BlankNodeFormatted]:
-        now = current_time_ms()
         blank_nodes = _filter_blank_nodes(site, list_key, start_year, end_year)
         group[list_key] = reduce(_group_site_blank_node(), blank_nodes, {})
-        logger.debug(
-            "function=_group_site_blank_nodes, list_key=%s, time=%s",
-            list_key,
-            current_time_ms() - now,
-        )
         return group
 
     return grouper
@@ -578,15 +572,9 @@ def _combine_site_blank_node(sites: List[SiteFormatted], list_key: str):
 
 def _combine_site_blank_nodes(sites: List[SiteFormatted]):
     def combine(group: dict, list_key: str):
-        now = current_time_ms()
         # get all possible keys first, then group each key values into a single blank node
         keys = set(flatten([list(site.get(list_key, {}).keys()) for site in sites]))
         group[list_key] = reduce(_combine_site_blank_node(sites, list_key), keys, {})
-        logger.debug(
-            "function=_combine_site_blank_nodes, list_key=%s, time=%s",
-            list_key,
-            current_time_ms() - now,
-        )
         return group
 
     return combine
@@ -672,15 +660,9 @@ def _aggregate_formatted(
     data: Union[CycleFormatted, SiteFormatted], aggregated_keys: List[str]
 ):
     def aggregate(key: str):
-        now = current_time_ms()
         values = data.get(key, {}).values()
         logger.debug(f"Aggregating {len(values)} {key}...")
         values = list(map(_aggregate_blank_node, values))
-        logger.debug(
-            "function=_aggregate_formatted, key=%s, time=%s",
-            key,
-            current_time_ms() - now,
-        )
         return values
 
     return reduce(lambda group, key: group | {key: aggregate(key)}, aggregated_keys, {})

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16}/hestia_earth/aggregation/utils/aggregate_weighted.py

@@ -6,11 +6,9 @@ from hestia_earth.utils.tools import (
     list_sum,
     list_average,
     is_boolean,
-    current_time_ms,
 )
 from hestia_earth.utils.blank_node import get_node_value
 
-from hestia_earth.aggregation.log import logger
 from . import weighted_average, _min, _max, _sd, format_evs, pick
 from .emission import get_method_tier, get_method_model
 from .property import aggregate_properties
@@ -190,7 +188,6 @@ def _aggregate_nodes(
     aggregate_keys: List[str], data: dict, weights: dict, missing_weights_node_id_func
 ):
     def aggregate_single(key: str):
-        now = current_time_ms()
         aggregates_map: dict = data.get(key)
         terms = aggregates_map.keys()
         values = non_empty_list(
@@ -199,9 +196,6 @@ def _aggregate_nodes(
                 terms,
             )
         )
-        logger.debug(
-            "function=_aggregate_nodes, key=%s, time=%s", key, current_time_ms() - now
-        )
         return values
 
     return reduce(

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16}/hestia_earth/aggregation/utils/cycle.py

@@ -41,15 +41,18 @@ from .practice import new_practice, organic_practice
 from .product import new_product
 from .weights import format_weights
 
-_MEAN_DATE_DESCRIPTION = (
-    "Additional notes: the mean endDate of all aggregated Cycles is "
-)
-
 
 def _timestamp():
     return datetime.now().strftime("%Y%m%d")
 
 
+def _mean_date_description(start: int, end: int, average: int):
+    return (
+        f"While the aggregation is for the period {start} - {end}, "
+        + f"the average end date of all aggregated Cycles is {average}."
+    )
+
+
 def _mean_date(dates: list):
     years = [int(d.split("-")[0]) for d in dates]
     return str(round(mean(years))) if years else ""
@@ -58,13 +61,17 @@ def _mean_date(dates: list):
 def _combine_mean_dates(cycles: list):
     # parse the mean date from the description of sub-country nodes
     descriptions = non_empty_list(map(lambda c: c.get("description"), cycles))
-    dates = [v.split(_MEAN_DATE_DESCRIPTION)[-1] for v in descriptions]
+    dates = [v[-5:-1] for v in descriptions]
     return _mean_date(dates)
 
 
 def _aggregated_weights(weights: dict):
-    description = format_weights(weights.values())
-    return ("Sub-aggregation weighting: " + description) if description else ""
+    description = format_weights(weights.values(), include_default_combinations=True)
+    return (
+        f"This aggregation uses the following weights on sub-systems: ({description})"
+        if description
+        else ""
+    )
 
 
 def is_organic(cycle: dict):
@@ -183,7 +190,9 @@ def _format_results(
     return {}
 
 
-def format_terms_results(data: dict, product: dict, country: dict):
+def format_terms_results(
+    data: dict, product: dict, country: dict, start_year: int, end_year: int
+):
     inputs = data.get("inputs", [])
     practices = data.get("practices", [])
     products = data.get("products", [])
@@ -193,8 +202,11 @@ def format_terms_results(data: dict, product: dict, country: dict):
         cycle = _format_results(
             cycle=_create_cycle(
                 {
-                    "description": _MEAN_DATE_DESCRIPTION
-                    + _mean_date(data.get("endDate"))
+                    "description": _mean_date_description(
+                        start=start_year,
+                        end=end_year,
+                        average=_mean_date(data.get("endDate")),
+                    )
                 }
             ),
             product=product,
@@ -259,7 +271,11 @@ def format_country_results(
                     non_empty_list(
                         [
                             _aggregated_weights(weights),
-                            _MEAN_DATE_DESCRIPTION + _combine_mean_dates(cycles),
+                            _mean_date_description(
+                                start=cycle.get("startDate"),
+                                end=cycle.get("endDate"),
+                                average=_combine_mean_dates(cycles),
+                            ),
                         ]
                     )
                 ),

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16}/hestia_earth/aggregation/utils/emission.py

@@ -69,3 +69,18 @@ def get_method_model(emissions: list):
     values = non_empty_list(flatten([e.get("methodModel", []) for e in emissions]))
     values = list({v["@id"]: v for v in values}.values())
     return values[0] if len(values) == 1 else None
+
+
+def has_value_without_transformation(blank_node: dict):
+    values = blank_node.get("value", [])
+    transformations = blank_node.get("transformation", [])
+    return (
+        not transformations
+        or len(transformations) != len(values)
+        or any(
+            [
+                value is not None and transformations[index] is None
+                for index, value in enumerate(values)
+            ]
+        )
+    )

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16}/hestia_earth/aggregation/utils/quality_score.py

@@ -175,16 +175,19 @@ def _calculate_score_emissions_system_boundary(cycle: dict, *args):
     # get all emissions in the system boundary
     all_emissions_ids = cycle_emissions_in_system_boundary(cycle)
     # ignore emissions that should be skipped in aggregation
-    all_emissions_ids = [
+    skipped_emission_ids = [
         id
         for id in all_emissions_ids
-        if should_aggregate_blank_node(
+        if not should_aggregate_blank_node(
             {
                 "@type": SchemaType.EMISSION.value,
                 "term": {"@id": id, "termType": TermTermType.EMISSION.value},
             }
         )
     ]
+    all_emissions_ids = [
+        id for id in all_emissions_ids if id not in skipped_emission_ids
+    ]
 
     # get all emissions in the Cycle that are in the system boundary
     emissions_ids = list(
@@ -207,6 +210,7 @@ def _calculate_score_emissions_system_boundary(cycle: dict, *args):
         included_emissions=len(emissions_ids),
         all_included=all_included,
         missing_emissions=";".join(missing_emissions),
+        excluded_emissions=";".join(skipped_emission_ids),
     )
 
     return all_included

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16}/hestia_earth/aggregation/utils/weights.py

@@ -16,18 +16,40 @@ from .term import (
 )
 
 
+def _weight_to_key(weights: list):
+    return "_".join(non_empty_list(weights))
+
+
 def _format_weight_key(key: str):
     return ", ".join(key.split("_")).capitalize()
 
 
-def format_weights(weights: list):
+_WEIGHTS_KEYS = [["organic", "conventional"], ["irrigated", "non-irrigated"]]
+_WEIGHTS_COMBINATIONS = [
+    _weight_to_key([organic_key, irrigated_key])
+    for organic_key in _WEIGHTS_KEYS[0]
+    for irrigated_key in _WEIGHTS_KEYS[1]
+]
+
+
+def format_weights(weights: list, include_default_combinations: bool = False):
     total = list_sum(non_empty_list([w.get("weight") for w in weights]))
-    return ";".join(
+    included_keys = non_empty_list([weight.get("key") for weight in weights])
+    return "; ".join(
         [
-            f"{_format_weight_key(weight.get('key'))}: {round(weight.get('weight') * 100 / total, 2)}"
+            f"{_format_weight_key(weight.get('key'))}: {round(weight.get('weight') * 100 / total, 2)}%"
             for weight in weights
             if weight.get("key")
         ]
+        + (
+            [
+                f"{_format_weight_key(key)}: 0%"
+                for key in _WEIGHTS_COMBINATIONS
+                if key not in included_keys
+            ]
+            if include_default_combinations and included_keys
+            else []
+        )
     )
 
 
@@ -119,13 +141,11 @@ def _country_weights(
     weight = (organic_weight if node.get("organic", False) else 1 - organic_weight) * (
         irrigated_weight if node.get("irrigated", False) else 1 - irrigated_weight
     )
-    key = "_".join(
-        non_empty_list(
-            [
-                "organic" if node.get("organic", False) else "conventional",
-                "irrigated" if node.get("irrigated", False) else "non-irrigated",
-            ]
-        )
+    key = _weight_to_key(
+        [
+            "organic" if node.get("organic", False) else "conventional",
+            "irrigated" if node.get("irrigated", False) else "non-irrigated",
+        ]
     )
     return {node_id: {"weight": weight, "completeness": completeness, "key": key}}
 

hestia_earth_aggregation-0.21.16/hestia_earth/aggregation/version.py

@@ -0,0 +1 @@
+VERSION = "0.21.16"

{hestia_earth_aggregation-0.21.14 → hestia_earth_aggregation-0.21.16/hestia_earth_aggregation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hestia_earth_aggregation
-Version: 0.21.14
+Version: 0.21.16
 Summary: HESTIA's aggregation engine.
 Home-page: https://gitlab.com/hestia-earth/hestia-aggregation-engine
 Author: HESTIA Team

hestia_earth_aggregation-0.21.14/hestia_earth/aggregation/version.py

@@ -1 +0,0 @@
-VERSION = "0.21.14"