hestia-earth-models 0.72.1__tar.gz → 0.72.2__tar.gz

{hestia_earth_models-0.72.1 → hestia_earth_models-0.72.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.72.1
+Version: 0.72.2
 Summary: HESTIA's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: HESTIA Team

{hestia_earth_models-0.72.1 → hestia_earth_models-0.72.2}/hestia_earth/models/cml2001Baseline/resourceUseEnergyDepletionInputsProduction.py

@@ -1,4 +1,5 @@
 from hestia_earth.models.linkedImpactAssessment.utils import run_inputs_production
+from . import MODEL
 
 REQUIREMENTS = {
     "ImpactAssessment": {
@@ -37,4 +38,4 @@ RETURNS = {
 TERM_ID = 'resourceUseEnergyDepletionInputsProduction'
 
 
-def run(impact_assessment: dict): return run_inputs_production(impact_assessment, TERM_ID)
+def run(impact_assessment: dict): return run_inputs_production(impact_assessment, TERM_ID, MODEL)

{hestia_earth_models-0.72.1 → hestia_earth_models-0.72.2}/hestia_earth/models/cml2001Baseline/resourceUseMineralsAndMetalsInputsProduction.py

@@ -1,4 +1,5 @@
 from hestia_earth.models.linkedImpactAssessment.utils import run_inputs_production
+from . import MODEL
 
 REQUIREMENTS = {
     "ImpactAssessment": {
@@ -37,4 +38,4 @@ RETURNS = {
 TERM_ID = 'resourceUseMineralsAndMetalsInputsProduction'
 
 
-def run(impact_assessment: dict): return run_inputs_production(impact_assessment, TERM_ID)
+def run(impact_assessment: dict): return run_inputs_production(impact_assessment, TERM_ID, MODEL)

{hestia_earth_models-0.72.1 → hestia_earth_models-0.72.2}/hestia_earth/models/ecoalimV9/cycle.py

@@ -81,6 +81,7 @@ def _add_emission(cycle: dict, input: dict):
         emissions = ecoalim_values(ecoalim_key, 'emission')
         for emission_term_id, value in emissions:
             # log run on each emission so we know it did run
+            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id)
             debugValues(cycle, model=MODEL, term=emission_term_id, model_key=MODEL_KEY,
                         value=value,
                         coefficient=coefficient,

{hestia_earth_models-0.72.1 → hestia_earth_models-0.72.2}/hestia_earth/models/ecoalimV9/impact_assessment.py

@@ -81,6 +81,7 @@ def _add_indicator(cycle: dict, input: dict):
         indicators = ecoalim_values(ecoalim_key, 'resourceUse')
         for indicator_term_id, value in indicators:
             # log run on each indicator so we know it did run
+            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=indicator_term_id)
             debugValues(cycle, model=MODEL, term=indicator_term_id, model_key=MODEL_KEY,
                         value=value,
                         coefficient=coefficient,

{hestia_earth_models-0.72.1 → hestia_earth_models-0.72.2}/hestia_earth/models/ecoinventV3/__init__.py

@@ -89,6 +89,7 @@ def _add_emission(cycle: dict, input: dict):
         emissions = ecoinventV3_emissions(ecoinventName)
         for emission_term_id, value in emissions:
             # log run on each emission so we know it did run
+            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=coefficient,

{hestia_earth_models-0.72.1 → hestia_earth_models-0.72.2}/hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -89,6 +89,7 @@ def _add_emission(cycle: dict, input: dict):
         emissions = ecoinventV3_emissions(ecoinventName)
         for emission_term_id, value in emissions:
             # log run on each emission so we know it did run
+            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=coefficient,

{hestia_earth_models-0.72.1 → hestia_earth_models-0.72.2}/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-0.72.1 → hestia_earth_models-0.72.2}/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 []