hestia-earth-models 0.59.4__py3-none-any.whl → 0.59.6__py3-none-any.whl

hestia_earth/models/linkedImpactAssessment/__init__.py

@@ -8,7 +8,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name
 from hestia_earth.utils.tools import flatten, list_sum
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.input import load_impacts
 from hestia_earth.models.utils.blank_node import group_by_keys
@@ -52,71 +52,99 @@ MODEL_AGGREGATED = 'hestiaAggregatedData'
 TIER = EmissionMethodTier.BACKGROUND.value
 
 
-def _emission(cycle: dict, term_id: str, value: float, input: dict, model: str):
-    # log run on each emission so we know it did run
-    input_term_id = input.get('term', {}).get('@id')
-    operation_term_id = input.get('operation', {}).get('@id')
-    animal_term_id = input.get('animal', {}).get('@id')
-
-    logShouldRun(cycle, model, term_id, True, methodTier=TIER,
-                 input=input_term_id,
-                 operation=operation_term_id,
-                 animal=animal_term_id)
-
+def _emission(model: str, term_id: str, value: float, input: dict, operation={}, animal={}):
     emission = _new_emission(term_id, model)
     emission['value'] = [value]
     emission['methodTier'] = TIER
-    emission['inputs'] = [input.get('term')]
-    if input.get('operation'):
-        emission['operation'] = input.get('operation')
-    if input.get('animal'):
-        emission['animals'] = [input.get('animal')]
+    emission['inputs'] = [input]
+    if operation:
+        emission['operation'] = operation
+    if animal:
+        emission['animals'] = [animal]
     return emission
 
 
+def _run_emission(cycle: dict, term_id: str, data: dict):
+    def run_input(values: dict):
+        value = values.get('value', 0)
+        term = values.get('term', {})
+        operation = values.get('operation', {})
+        animal = values.get('animal', {})
+        is_aggregated = any(values.get('aggregated', []))
+        model = MODEL_AGGREGATED if is_aggregated else MODEL
+
+        details = values.get('details', {})
+        logRequirements(cycle, model=model, term=term_id,
+                        values=log_as_table([{'impact-assessment-id': key} | value for key, value in details.items()]))
+
+        logShouldRun(cycle, model, term_id, True, methodTier=TIER,
+                     input=term.get('@id'),
+                     operation=operation.get('@id'),
+                     animal=animal.get('@id'))
+
+        return _emission(model, term_id, value, input=term, operation=operation, animal=animal)
+
+    return list(map(run_input, data.values()))
+
+
 def _emission_group(term_id: str):
     lookup = download_lookup('emission.csv', True)
     return get_table_value(lookup, 'termid', term_id, column_name('inputProductionGroupId'))
 
 
 def _group_emissions(impact: dict):
-    def _group_by(prev: dict, emission: dict):
+    def _group_by(group: dict, emission: dict):
         term_id = emission.get('term', {}).get('@id')
         grouping = _emission_group(term_id)
         value = emission.get('value') or 0
         if grouping:
-            prev[grouping] = prev.get(grouping, 0) + value
-        return prev
+            group[grouping] = group.get(grouping, 0) + value
+        return group
 
     emissions = impact.get('emissionsResourceUse', [])
     return reduce(_group_by, emissions, {})
 
 
-def _run_input(cycle: dict):
-    def run(inputs: list):
-        input = inputs[0]
-        input_value = list_sum(flatten(input.get('value', []) for input in inputs))
-        term_id = input.get('term', {}).get('@id')
-        impact = input.get('impactAssessment')
-        model = MODEL_AGGREGATED if impact.get('aggregated', False) else MODEL
-        emissions = _group_emissions(impact)
-
-        logRequirements(cycle, model=model, term=term_id,
-                        impact_assessment_id=input.get('impactAssessment', {}).get('@id'),
-                        input_value=input_value)
-        logShouldRun(cycle, model, term_id, True, methodTier=TIER)
-
-        return [
-            _emission(cycle, id, input_value * value, input, model) for id, value in emissions.items()
-        ]
-    return run
-
-
 def _animal_inputs(animal: dict):
     inputs = load_impacts(animal.get('inputs', []))
     return [(input | {'animal': animal.get('term', {})}) for input in inputs]
 
 
+def _group_input_emissions(input: dict):
+    impact = input.get('impactAssessment')
+    emissions = _group_emissions(impact)
+    return input | {'emissions': emissions}
+
+
+def _group_inputs(group: dict, values: tuple):
+    # input_group_key = 'group-id'
+    # inputs = [{'term': {}, 'value':[], 'impactAssessment': {}, 'emissions': {'co2ToAirInputsProduction': 10}}]
+    input_group_key, inputs = values
+    for input in inputs:
+        input_value = list_sum(input.get('value'))
+        emissions = input.get('emissions', {})
+        for emission_term_id, emission_value in emissions.items():
+            group[emission_term_id] = group.get(emission_term_id, {})
+
+            grouped_inputs = group[emission_term_id].get(input_group_key, {
+                'term': input.get('term', {}),
+                'operation': input.get('operation', {}),
+                'animal': input.get('animal', {}),
+                'value': 0,
+                'aggregated': [],
+                'details': {}
+            })
+            grouped_inputs['aggregated'].append(input.get('impactAssessment', {}).get('agregated', False))
+            grouped_inputs['value'] = grouped_inputs['value'] + (emission_value * input_value)
+            # for logging
+            grouped_inputs['details'][input.get('impactAssessment', {}).get('@id')] = {
+                'emission-value': emission_value,
+                'input-value': input_value
+            }
+            group[emission_term_id][input_group_key] = grouped_inputs
+    return group
+
+
 def run(_, cycle: dict):
     inputs = flatten(
         load_impacts(cycle.get('inputs', [])) +
@@ -124,9 +152,16 @@ def run(_, cycle: dict):
     )
     inputs = [i for i in inputs if list_sum(i.get('value', [])) > 0]
 
+    # group inputs with same term/operation/animal to avoid adding emissions twice
+    # inputs = {'group-id': [{'term': {},'value':[10],'impactAssessment': {}}]}
+    inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
+    inputs = {key: list(map(_group_input_emissions, value)) for key, value in inputs.items()}
+
     debugValues(cycle, model=MODEL,
                 nb_inputs=len(inputs))
 
-    # group inputs with same id/operation to avoid adding emissions twice
-    inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
-    return flatten(map(_run_input(cycle), inputs.values()))
+    # finally group everything by emission so we can log inputs together
+    # emissions = {'co2ToAirInputsProduct': {'group-id':{'term':{},'value':10,'details':{}}}}
+    emissions = reduce(_group_inputs, inputs.items(), {})
+
+    return flatten([_run_emission(cycle, term_id, data) for term_id, data in emissions.items()])