hestia-earth-models 0.72.1__py3-none-any.whl → 0.73.0__py3-none-any.whl

hestia_earth/models/linkedImpactAssessment/emissions.py

@@ -77,6 +77,7 @@ def _run_emission(cycle: dict, emission_term_id: str, data: dict):
 
         # log run on each emission so we know it did run
         details = values.get('details', {})
+        logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id)
         debugValues(cycle, model=model, term=emission_term_id,
                     value=value,
                     coefficient=1,

hestia_earth/models/linkedImpactAssessment/utils.py

@@ -8,14 +8,14 @@ from hestia_earth.models.utils.input import load_impacts
 from . import MODEL
 
 
-def _indicator(term_id: str, value: float, input: dict):
-    indicator = _new_indicator(term_id, MODEL)
+def _indicator(model: str, term_id: str, value: float, input: dict):
+    indicator = _new_indicator(term_id, model)
     indicator['value'] = value
     indicator['inputs'] = [input]
     return indicator
 
 
-def _run_indicators(impact_assessment: dict, product: dict, term_id: str):
+def _run_indicators(impact_assessment: dict, product: dict, term_id: str, model: str):
     def run(values: list):
         input = values[0].get('input').get('term', {})
         indicator = values[0].get('indicator')
@@ -24,22 +24,22 @@ def _run_indicators(impact_assessment: dict, product: dict, term_id: str):
             for value in values
         ])
         value = convert_value_from_cycle(
-            impact_assessment, product, sum_values(values_from_cycle), model=MODEL, term_id=term_id
+            impact_assessment, product, sum_values(values_from_cycle), model=model, term_id=term_id
         )
 
         # show values per input in the logs
-        debugValues(impact_assessment, model=MODEL, term=term_id,
+        debugValues(impact_assessment, model=model, term=term_id,
                     value=value,
                     coefficient=1,
                     input=input.get('@id'))
 
         return (
-            _indicator(term_id, value, input) | _include(indicator, ['landCover', 'previousLandCover'])
+            _indicator(model, term_id, value, input) | _include(indicator, ['landCover', 'previousLandCover'])
         ) if value is not None else None
     return run
 
 
-def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str):
+def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str, model: str):
     cycle = impact_assessment.get('cycle', {})
 
     # group all indicators per `landCover` and `previousLandCover`
@@ -71,7 +71,7 @@ def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str)
     ])
     has_indicators = bool(valid_indicators)
 
-    logRequirements(impact_assessment, model=MODEL, term=term_id,
+    logRequirements(impact_assessment, model=model, term=term_id,
                     indicators=log_as_table([
                         {
                             'indicator-id': value.get('indicator').get('term', {}).get('@id'),
@@ -83,30 +83,30 @@ def _run_inputs_production(impact_assessment: dict, product: dict, term_id: str)
                     ]))
 
     should_run = all([has_indicators])
-    logShouldRun(impact_assessment, MODEL, term_id, should_run)
+    logShouldRun(impact_assessment, model, term_id, should_run)
 
     return non_empty_list(flatten(
-        map(_run_indicators(impact_assessment, product, term_id), grouped_indicators.values())
+        map(_run_indicators(impact_assessment, product, term_id, model), grouped_indicators.values())
     ))
 
 
-def _should_run_inputs_production(impact_assessment: dict, term_id: str):
+def _should_run_inputs_production(impact_assessment: dict, term_id: str, model: str):
     product = get_product(impact_assessment) or {}
     product_id = product.get('term', {}).get('@id')
 
     product_value = list_sum(product.get('value', []), default=None)
     economic_value = product.get('economicValueShare')
 
-    logRequirements(impact_assessment, model=MODEL, term=term_id,
+    logRequirements(impact_assessment, model=model, term=term_id,
                     product_id=product_id,
                     product_value=product_value,
                     product_economicValueShare=economic_value)
 
     should_run = all([product, product_value, economic_value])
-    logShouldRun(impact_assessment, MODEL, term_id, should_run)
+    logShouldRun(impact_assessment, model, term_id, should_run)
     return should_run, product
 
 
-def run_inputs_production(impact_assessment: dict, term_id: str):
-    should_run, product = _should_run_inputs_production(impact_assessment, term_id)
-    return _run_inputs_production(impact_assessment, product, term_id) if should_run else []
+def run_inputs_production(impact_assessment: dict, term_id: str, model: str = MODEL):
+    should_run, product = _should_run_inputs_production(impact_assessment, term_id, model)
+    return _run_inputs_production(impact_assessment, product, term_id, model) if should_run else []