hestia-earth-aggregation 0.21.15__py3-none-any.whl → 0.21.17__py3-none-any.whl

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/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/config/Cycle/crop.json

@@ -0,0 +1,63 @@
+{
+  "models": [
+    {
+      "key": "inputs",
+      "model": "cycle",
+      "value": "input.hestiaAggregatedData",
+      "runStrategy": "always",
+      "mergeStrategy": "list"
+    },
+    {
+      "key": "emissions",
+      "model": "linkedImpactAssessment",
+      "value": "emissions",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      }
+    },
+    {
+      "key": "emissions",
+      "model": "ecoalimV9",
+      "value": "cycle",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      }
+    },
+    {
+      "key": "emissions",
+      "model": "worldSteel",
+      "value": "cycle",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      },
+      "stage": 2
+    },
+    {
+      "key": "emissions",
+      "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",
+      "mergeArgs": {
+        "replaceThreshold": ["value", 0.01]
+      }
+    }
+  ]
+}

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/recalculate_cycles.py

@@ -4,10 +4,11 @@ from hestia_earth.orchestrator import run
 
 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
 CONFIG_PATH = os.path.join(CURRENT_DIR, "config", "Cycle")
+_TERM_TYPES = os.listdir(CONFIG_PATH)
 
 
 def should_recalculate(product: dict):
-    return f"{product.get('termType')}.json" in os.listdir(CONFIG_PATH)
+    return f"{product.get('termType')}.json" in _TERM_TYPES
 
 
 def recalculate(cycle: dict, product: dict):

hestia_earth/aggregation/utils/aggregate_country_nodes.py

@@ -65,6 +65,7 @@ from .emission import (
     get_method_tier,
     get_method_model,
     has_value_without_transformation,
+    include_emission,
 )
 from .property import aggregate_properties
 from .distribution import generate_blank_node_distribution
@@ -205,6 +206,10 @@ def _group_cycle_blank_node(cycle: dict, product: dict, product_value: float):
         term_id = term.get("@id")
         group_key = blank_node_group_key(blank_node)
 
+        # skip background emissions when recalculated
+        if node_type == "Emission" and not include_emission(blank_node, product):
+            return group
+
         is_aggregated_product = node_type == "Product" and term_id == product.get("@id")
 
         site_type = cycle.get("site", {}).get("siteType")
@@ -223,9 +228,9 @@ def _group_cycle_blank_node(cycle: dict, product: dict, product_value: float):
             is_aggregated_product=is_aggregated_product,
         )
 
-        # only primary data can be incomplete, otherwise skip the blank node
         if all(
             [
+                # only primary data can be incomplete, otherwise skip the blank node
                 complete is False,
                 not blank_node_data.get("primary"),
                 blank_node_data.get("primaryPercent", 0) <= 0,
@@ -301,7 +306,6 @@ 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, {}
@@ -312,11 +316,6 @@ def _group_cycle_blank_nodes(
             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
@@ -333,6 +332,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 = (
         (
@@ -365,8 +365,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"],
@@ -422,7 +423,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(
@@ -430,11 +430,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
@@ -534,14 +529,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
@@ -588,15 +577,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
@@ -682,15 +665,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/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/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):
@@ -170,9 +177,7 @@ def _format_results(
         "products": non_empty_list(map(_format_aggregate(new_product), products)),
     }
     # aggregate emissions after as it needs inputs and products
-    cycle["emissions"] = non_empty_list(
-        map(_format_aggregate(new_emission(product)), emissions)
-    )
+    cycle["emissions"] = non_empty_list(map(_format_aggregate(new_emission), emissions))
 
     # set the primary product
     primary_product = find_term_match(cycle.get("products", []), product.get("@id"))
@@ -183,7 +188,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 +200,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 +269,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/utils/emission.py

@@ -2,62 +2,58 @@ from hestia_earth.schema import (
     EmissionMethodTier,
     SchemaType,
     EmissionStatsDefinition,
-    TermTermType,
 )
 from hestia_earth.utils.model import linked_node
 from hestia_earth.utils.lookup_utils import is_in_system_boundary
 from hestia_earth.utils.tools import flatten, non_empty_list
 
+from hestia_earth.aggregation.recalculate_cycles import should_recalculate
 from . import _unique_nodes, _set_dict_single
 from .term import METHOD_MODEL
 
 _DEFAULT_TIER = EmissionMethodTier.TIER_1.value
-_SKIP_BACKGROUND_EMISSIONS = [TermTermType.PROCESSEDFOOD.value]
 
 
-def _include_emission(emission: dict, product: dict):
+def include_emission(emission: dict, product: dict):
     return any(
         [
             emission.get("methodTier") != EmissionMethodTier.BACKGROUND.value,
-            product.get("termType") not in _SKIP_BACKGROUND_EMISSIONS,
+            not should_recalculate(product),
         ]
     )
 
 
-def new_emission(product: dict):
-    def emission(data: dict):
-        term = data.get("term", {})
-        # only add emissions included in the System Boundary
-        if is_in_system_boundary(term.get("@id")):
-            node = {"@type": SchemaType.EMISSION.value}
-            node["term"] = linked_node(term)
-            value = data.get("value")
-            if value is not None:
-                node["value"] = [value]
-                node["statsDefinition"] = EmissionStatsDefinition.CYCLES.value
-
-            node["methodTier"] = data.get("methodTier") or _DEFAULT_TIER
-            node["methodModel"] = data.get("methodModel") or METHOD_MODEL
-
-            inputs = data.get("inputs", [])
-            # compute list of unique inputs, required for `background` emissions
-            if inputs:
-                _set_dict_single(
-                    node,
-                    "inputs",
-                    list(map(linked_node, _unique_nodes(inputs))),
-                    strict=True,
-                )
-
-            if node.get("methodTier") != EmissionMethodTier.NOT_RELEVANT.value:
-                _set_dict_single(
-                    node, "distribution", data.get("distribution"), strict=True
-                )
-
-            _set_dict_single(node, "description", data.get("description"), strict=True)
-            return node if _include_emission(node, product) else None
-
-    return emission
+def new_emission(data: dict):
+    term = data.get("term", {})
+    # only add emissions included in the System Boundary
+    if is_in_system_boundary(term.get("@id")):
+        node = {"@type": SchemaType.EMISSION.value}
+        node["term"] = linked_node(term)
+        value = data.get("value")
+        if value is not None:
+            node["value"] = [value]
+            node["statsDefinition"] = EmissionStatsDefinition.CYCLES.value
+
+        node["methodTier"] = data.get("methodTier") or _DEFAULT_TIER
+        node["methodModel"] = data.get("methodModel") or METHOD_MODEL
+
+        inputs = data.get("inputs", [])
+        # compute list of unique inputs, required for `background` emissions
+        if inputs:
+            _set_dict_single(
+                node,
+                "inputs",
+                list(map(linked_node, _unique_nodes(inputs))),
+                strict=True,
+            )
+
+        if node.get("methodTier") != EmissionMethodTier.NOT_RELEVANT.value:
+            _set_dict_single(
+                node, "distribution", data.get("distribution"), strict=True
+            )
+
+        _set_dict_single(node, "description", data.get("description"), strict=True)
+        return node
 
 
 def get_method_tier(emissions: list):

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/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/version.py

@@ -1 +1 @@
-VERSION = "0.21.15"
+VERSION = "0.21.17"

{hestia_earth_aggregation-0.21.15.dist-info → hestia_earth_aggregation-0.21.17.dist-info}/METADATA

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

{hestia_earth_aggregation-0.21.15.dist-info → hestia_earth_aggregation-0.21.17.dist-info}/RECORD

@@ -1,19 +1,20 @@
-hestia_earth/aggregation/__init__.py,sha256=5r0icTYP5F4DFIX-Xm1Ms3inpAUfpXQwOmO2y_DV3zs,3202
-hestia_earth/aggregation/aggregate_cycles.py,sha256=9BRX41d0uLhKLUPBlALxAoRMfPriDj3Dhy0sTgmTS5Y,7812
+hestia_earth/aggregation/__init__.py,sha256=kSK6RYcK0YnRGx6TknaukhuhbnxRHofLI_8PA0-k8Yg,3339
+hestia_earth/aggregation/aggregate_cycles.py,sha256=MR-SseQRMGFUOKiBJcLVysjdjw5J-QfJ258VxGhasFw,7868
 hestia_earth/aggregation/log.py,sha256=0CibXDtKqFfE-R86qziM2uH7ATUZ6I9p_bVpRSn_e_o,2351
-hestia_earth/aggregation/recalculate_cycles.py,sha256=xCO_tj5BAC407vZ36EVuxeOBmX2y82EXRrTx5W6g4CY,484
-hestia_earth/aggregation/version.py,sha256=Z3Ng7JCS2UZEW-r2srjuHslYzJkIywa_nSkx0uI3j84,20
-hestia_earth/aggregation/config/Cycle/processedFood.json,sha256=JWelgL-ZLnurS9R8Y-HOXjiWZ5k3kAuUQHDoMcukEq8,1127
+hestia_earth/aggregation/recalculate_cycles.py,sha256=igMxKd7_K0MFlAt3Q_OynvHxDo3ldTixWbXjaC4M71c,510
+hestia_earth/aggregation/version.py,sha256=hcVLcttb0pemu91UT65kphAN_tKjRCwH4PaeO6euVl8,20
+hestia_earth/aggregation/config/Cycle/crop.json,sha256=OBYXxleifxg9EJfZsqR1dgCxlEe2lIrCBqMe_Jo5XE4,1387
+hestia_earth/aggregation/config/Cycle/processedFood.json,sha256=OBYXxleifxg9EJfZsqR1dgCxlEe2lIrCBqMe_Jo5XE4,1387
 hestia_earth/aggregation/utils/__init__.py,sha256=nVVLgVFZ4415CgQAqgv4jDamA7gDmzOWk5SY4vshAQs,6583
-hestia_earth/aggregation/utils/aggregate_country_nodes.py,sha256=U39M2clD9_6FE0yFYvamP7EI8FrCQ350pzD0y_9Rw_Y,28806
-hestia_earth/aggregation/utils/aggregate_weighted.py,sha256=CUTqR8z3_MRnGhzAOiFswy68Twe1GaNCyrSd5x7qf_Q,7037
+hestia_earth/aggregation/utils/aggregate_country_nodes.py,sha256=RIJYaWNNdnlCif6EgF-mG_HsfwuchSOHEgvE8eYl-NU,28116
+hestia_earth/aggregation/utils/aggregate_weighted.py,sha256=OzrYhbL7g-X_1x7BLEwkxqLlDOLQ7CdFV8UuQTzQEz4,6817
 hestia_earth/aggregation/utils/blank_node.py,sha256=f8JBcd5_SLqW8juzFAfbZysAESaZXj8JX6C7rDkLEoc,16812
 hestia_earth/aggregation/utils/combine.py,sha256=EmXUZksdkrtQ6o1gMOG5WMivUhL28NKSM9D4cPohJiE,4904
 hestia_earth/aggregation/utils/completeness.py,sha256=eZ759PAdOSshhys-YKKPEpAYxR3sTrEjI--WJTEwmus,4633
 hestia_earth/aggregation/utils/covariance.py,sha256=2VaNGPvyD4ub3rR-OBn8VIEIeAz4JOefl6ZlAtXKj4U,5884
-hestia_earth/aggregation/utils/cycle.py,sha256=gzU2KofOVGBZvOPTymJGpsbbouABjSzUM35OJ42sFl8,15954
+hestia_earth/aggregation/utils/cycle.py,sha256=ohFc2rtzi7cJZatBll8JFoAFK0PB7CzVtccnyvzkfsU,16471
 hestia_earth/aggregation/utils/distribution.py,sha256=2XQKXVu-1XUy1zEHgThERupaj4RizXKO5F-VY-QQlMo,6935
-hestia_earth/aggregation/utils/emission.py,sha256=2roXjGmDuS7a3muPJoEOqg7E-TZyQsnoavhU6b3B-Z8,2983
+hestia_earth/aggregation/utils/emission.py,sha256=fmzi2GHhG1E5Ioi00D1vVIPZwqaDB7P4-NxGwX64KyI,2745
 hestia_earth/aggregation/utils/group.py,sha256=qU9sAuJu0RG80yLs90nsyoOcU57Pb6M1WKwT1TlJEkM,4765
 hestia_earth/aggregation/utils/input.py,sha256=pZ1bcdHR3y4S-3b0JZllbEUWdEyVZbltxv-07j7SucI,1092
 hestia_earth/aggregation/utils/lookup.py,sha256=osJiXTRns5KeBMz3mRsanmFQTATrwcMVBzB07xrb71M,2046
@@ -22,14 +23,14 @@ hestia_earth/aggregation/utils/measurement.py,sha256=tdQwjo1hPb3iAaboBQiua832q27
 hestia_earth/aggregation/utils/practice.py,sha256=MXZsQoeSXxe2vmdjvyS58HZN9jejPZNbVnczTc3HxxU,2252
 hestia_earth/aggregation/utils/product.py,sha256=dEUCy0eakyKyD2vu1RRnF4bdAI-jpS-qePNF8ZGhHFE,886
 hestia_earth/aggregation/utils/property.py,sha256=n_aHZ4qASv_wcDJ_HrA1T2kFX8R2zUEo91LCPL5xWkw,917
-hestia_earth/aggregation/utils/quality_score.py,sha256=Jfxbdj9_UgZUB0w9RbiMCX0soVqqe7okrHw1f2vwLUw,8743
+hestia_earth/aggregation/utils/quality_score.py,sha256=PPNRW1wEkVqP7QExyu5dcr8R_Z_DWkmT3zmQG9u470Y,8914
 hestia_earth/aggregation/utils/queries.py,sha256=kzob6CHL1a60CRJdGICiWS98LKJRyq3uaToyuQyl9RI,17564
 hestia_earth/aggregation/utils/site.py,sha256=nc1N4IRiTki69IbCX4G6lagQ5U7IpsOsqiPuHwbl1HM,5455
 hestia_earth/aggregation/utils/source.py,sha256=SOiE-jB5WNtbRxreUWQ8c04ywzrwICy1aGyRL3-L0RY,686
 hestia_earth/aggregation/utils/term.py,sha256=uVAfBYnxNkcTNfzuwwHur6JGBahNrPwR2pN-__sj9zk,2758
-hestia_earth/aggregation/utils/weights.py,sha256=3WO2_26bj1RB2h524Gknu0btvTFJucqMtn-tag339aY,6843
-hestia_earth_aggregation-0.21.15.dist-info/licenses/LICENSE,sha256=TD25LoiRJsA5CPUNrcyt1PXlGcbUGFMAeZoBcfCrCNE,1154
-hestia_earth_aggregation-0.21.15.dist-info/METADATA,sha256=XgOXgQA87fTsZYpB8xXvgcz1Mp5LP7Kkec3Ik5wlLZo,2481
-hestia_earth_aggregation-0.21.15.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-hestia_earth_aggregation-0.21.15.dist-info/top_level.txt,sha256=q0QxKEYx9uLpAD5ZtC7Ypq29smEPfOzEAn7Xv8XHGOQ,13
-hestia_earth_aggregation-0.21.15.dist-info/RECORD,,
+hestia_earth/aggregation/utils/weights.py,sha256=Qk5hCr_K24DzkeE4Sa241pGb6m00iaWHIXFQAJ-cDGc,7518
+hestia_earth_aggregation-0.21.17.dist-info/licenses/LICENSE,sha256=TD25LoiRJsA5CPUNrcyt1PXlGcbUGFMAeZoBcfCrCNE,1154
+hestia_earth_aggregation-0.21.17.dist-info/METADATA,sha256=fgZq8hdf22iumAqR_xOGtVJcOoKfSKnaexEakj6H7YA,2481
+hestia_earth_aggregation-0.21.17.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+hestia_earth_aggregation-0.21.17.dist-info/top_level.txt,sha256=q0QxKEYx9uLpAD5ZtC7Ypq29smEPfOzEAn7Xv8XHGOQ,13
+hestia_earth_aggregation-0.21.17.dist-info/RECORD,,