hestia-earth-models 0.69.1__py3-none-any.whl → 0.70.1__py3-none-any.whl

hestia_earth/models/cycle/animal/input/properties.py

@@ -15,7 +15,7 @@ REQUIREMENTS = {
             "inputs": [{
                 "@type": "Input",
                 "or": {
-                    "impactAssessment": "",
+                    "impactAssessment": {"@type": "ImpactAssessment"},
                     "properties": [{"@type": "Property", "@id": "dryMatter"}]
                 }
             }]

hestia_earth/models/cycle/cycleDuration.py

@@ -11,11 +11,11 @@ REQUIREMENTS = {
         "endDate": "",
         "optional": {
             "startDate": "",
-            "products": {
+            "products": [{
                 "@type": "Product",
                 "primary": "True",
                 "term.termType": "crop"
-            },
+            }],
             "practices": [{"@type": "Practice", "value": "", "term.@id": "croppingIntensity"}]
         }
     }

hestia_earth/models/cycle/input/hestiaAggregatedData.py

@@ -1,12 +1,11 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import find_primary_product, linked_node, filter_list_term_type
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils.crop import valid_site_type
 from hestia_earth.models.utils.blank_node import get_lookup_value
-from hestia_earth.models.utils.term import get_generic_crop
+from hestia_earth.models.utils.term import get_generic_crop, download_term
 from hestia_earth.models.utils.aggregated import (
     should_link_input_to_impact, link_inputs_to_impact, find_closest_impact, aggregated_end_date
 )
@@ -17,7 +16,7 @@ REQUIREMENTS = {
             "@type": "Input",
             "value": "",
             "none": {
-                "impactAssessment": "",
+                "impactAssessment": {"@type": "ImpactAssessment"},
                 "fromCycle": "True",
                 "producedInCycle": "True"
             },
@@ -37,7 +36,7 @@ REQUIREMENTS = {
                 "term.@id": "seed",
                 "value": "",
                 "none": {
-                    "impactAssessment": ""
+                    "impactAssessment": {"@type": "ImpactAssessment"}
                 }
             }],
             "products": [{"@type": "Product", "value": "", "primary": "True"}]
@@ -58,8 +57,7 @@ MODEL_KEY = 'impactAssessment'
 
 
 def _run_seed(cycle: dict, primary_product: dict, seed_input: dict, product_term_id: str):
-    product = download_hestia(product_term_id)
-    region = seed_input.get('region')
+    product = download_term(product_term_id, TermTermType.SEED)
     country = seed_input.get('country')
     # to avoid double counting seed => aggregated impact => seed, we need to get the impact of the previous decade
     # if the data does not exist, use the aggregated impact of generic crop instead
@@ -68,16 +66,16 @@ def _run_seed(cycle: dict, primary_product: dict, seed_input: dict, product_term
     default_product = get_generic_crop()
 
     impact = (
-        find_closest_impact(cycle, date, product, region, country, match_end_date) or
-        find_closest_impact(cycle, date, primary_product.get('term', {}), region, country, match_end_date) or
-        find_closest_impact(cycle, date, default_product, region, country)
+        find_closest_impact(cycle, date, product, country, must_queries=match_end_date) or
+        find_closest_impact(cycle, date, primary_product.get('term', {}), country, must_queries=match_end_date) or
+        find_closest_impact(cycle, date, default_product, country)
     )
 
     search_by_product_term_id = (product or primary_product or default_product).get('@id')
-    search_by_region_id = (region or country or {}).get('@id') or 'region-world'
+    search_by_country_id = (country or {}).get('@id') or 'region-world'
     debugValues(cycle, model=MODEL_ID, term=seed_input.get('term', {}).get('@id'), key=MODEL_KEY,
                 search_by_product_term_id=search_by_product_term_id,
-                search_by_region_id=search_by_region_id,
+                search_by_country_id=search_by_country_id,
                 search_by_end_date=str(date),
                 impact_assessment_id_found=(impact or {}).get('@id'))
 
@@ -95,7 +93,7 @@ def _should_run_seed(cycle: dict):
     seed_inputs = [
         {
             'input': seed_input,
-            'product': get_lookup_value(seed_input.get('term', {}), LOOKUPS['seed'], key=MODEL_KEY)
+            'product-id': get_lookup_value(seed_input.get('term', {}), LOOKUPS['seed'], key=MODEL_KEY)
         }
         for seed_input in seed_inputs
     ]
@@ -104,7 +102,7 @@ def _should_run_seed(cycle: dict):
 
     for seed_input in seed_inputs:
         term_id = seed_input.get('input').get('term', {}).get('@id')
-        linked_product_id = seed_input.get('product')
+        linked_product_id = seed_input.get('product-id')
 
         logRequirements(cycle, model=MODEL_ID, term=term_id, key=MODEL_KEY,
                         site_type_valid=site_type_valid,
@@ -140,7 +138,7 @@ def run(cycle: dict):
         link_inputs_to_impact(MODEL_ID, cycle, inputs) if should_run else []
     ) + (
         non_empty_list([
-            _run_seed(cycle, primary_product, seed_input.get('input'), seed_input.get('product'))
+            _run_seed(cycle, primary_product, seed_input.get('input'), seed_input.get('product-id'))
             for seed_input in seed_inputs
         ]) if should_run_seed else []
     )

hestia_earth/models/cycle/input/properties.py

@@ -12,7 +12,7 @@ REQUIREMENTS = {
         "inputs": [{
             "@type": "Input",
             "or": {
-                "impactAssessment": "",
+                "impactAssessment": {"@type": "ImpactAssessment"},
                 "properties": [{"@type": "Property", "@id": "dryMatter"}]
             }
         }]

hestia_earth/models/cycle/siteDuration.py

@@ -9,14 +9,14 @@ REQUIREMENTS = {
     "Cycle": {
         "cycleDuration": "> 0",
         "none": {
-            "otherSites": ""
+            "otherSites": [{"@type": "Site"}]
         },
         "optional": {
-            "products": {
+            "products": [{
                 "@type": "Product",
                 "primary": "True",
                 "term.termType": "crop"
-            },
+            }],
             "startDateDefinition": ""
         }
     }

hestia_earth/models/cycle/transformation.py

@@ -25,7 +25,7 @@ def _run_emission(cycle: dict, transformation: dict):
     def exec(emission: dict):
         term_id = emission.get('term', {}).get('@id')
         logShouldRun(cycle, MODEL_LOG, term_id, True, key=MODEL_KEY)
-        return {**emission, MODEL_KEY: transformation.get('term', {})}
+        return emission | {MODEL_KEY: transformation.get('term', {})}
     return exec
 
 

hestia_earth/models/cycle/utils.py

@@ -1,15 +1,9 @@
 from hestia_earth.utils.tools import list_average
 
 from hestia_earth.models.log import logShouldRun
-from hestia_earth.models.utils.term import get_lookup_value
 from . import MODEL
 
 
-def get_liveAnimal_term_id(product: dict, **log_ars):
-    term_id = get_lookup_value(product.get('term', {}), 'liveAnimalTermId', model=MODEL, **log_ars)
-    return term_id.split(';')[0] if term_id else None
-
-
 def _should_run_property_by_min_max(property: dict):
     return all([
         property.get('min') is not None,

hestia_earth/models/data/ecoinventV3/__init__.py

@@ -1,32 +1,34 @@
 import os
-from hestia_earth.utils.lookup import column_name, get_table_value, load_lookup
+from functools import lru_cache
+from hestia_earth.utils.lookup import column_name, get_table_value, load_lookup, lookup_columns
 from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import logger
 
 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
-ECOINVENT_FILEPATH = os.getenv('ECOINVENT_V3_FILEPATH', f"{os.path.join(CURRENT_DIR, 'ecoinventV3_excerpt')}.csv")
+_FILEPATH = os.getenv('ECOINVENT_V3_FILEPATH', f"{os.path.join(CURRENT_DIR, 'ecoinventV3_excerpt')}.csv")
 
 
+@lru_cache()
 def _get_file():
-    if not os.path.exists(ECOINVENT_FILEPATH):
-        logger.warn('Ecoinvent file not found. Please make sure to set env variable "ECOINVENT_V3_FILEPATH".')
+    if not os.path.exists(_FILEPATH):
+        logger.warning('Ecoinvent file not found. Please make sure to set env variable "ECOINVENT_V3_FILEPATH".')
         return None
 
-    return load_lookup(filepath=ECOINVENT_FILEPATH, keep_in_memory=True)
+    return load_lookup(filepath=_FILEPATH, keep_in_memory=True)
 
 
 def ecoinventV3_emissions(ecoinventName: str):
     lookup = _get_file()
     col_name = column_name('ecoinventName')
 
-    def emission(index: int):
-        id = get_table_value(
-            lookup, col_name, ecoinventName, column_name(f"emissionsResourceUse.{index}.term.id")
-        )
-        value = get_table_value(
-            lookup, col_name, ecoinventName, column_name(f"emissionsResourceUse.{index}.value")
-        )
+    def emission(column: str):
+        id = get_table_value(lookup, col_name, ecoinventName, column_name(column))
+        value = get_table_value(lookup, col_name, ecoinventName, column_name(column.replace('termid', 'value')))
         return (id, value) if id else None
 
-    return non_empty_list(map(emission, range(0, 12)))
+    columns = [
+        col for col in lookup_columns(lookup)
+        if col.endswith(column_name('termid'))
+    ]
+    return non_empty_list(map(emission, columns))

hestia_earth/models/ecoalimV9/__init__.py

@@ -0,0 +1,13 @@
+from os.path import dirname, abspath
+import sys
+from importlib import import_module
+
+from hestia_earth.models.utils.blank_node import run_if_required
+
+CURRENT_DIR = dirname(abspath(__file__)) + '/'
+sys.path.append(CURRENT_DIR)
+MODEL = 'ecoalimV9'
+PKG = '.'.join(['hestia_earth', 'models', MODEL])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/ecoalimV9/cycle.py

@@ -0,0 +1,128 @@
+from functools import reduce
+from statistics import mean
+from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.utils.tools import flatten, list_sum
+
+from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.background_emissions import get_background_inputs, no_gap_filled_background_emissions
+from hestia_earth.models.utils.blank_node import group_by_keys
+from .utils import get_input_mappings, ecoalim_values
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "inputs": [{
+            "@type": "Input",
+            "value": "> 0",
+            "none": {
+                "fromCycle": "True",
+                "producedInCycle": "True"
+            }
+        }],
+        "optional": {
+            "animals": [{
+                "@type": "Animal",
+                "inputs": [{
+                    "@type": "Input",
+                    "value": "> 0",
+                    "none": {
+                        "fromCycle": "True",
+                        "producedInCycle": "True"
+                    }
+                }]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "term": "",
+        "value": "",
+        "methodTier": "background",
+        "inputs": "",
+        "operation": "",
+        "animals": ""
+    }]
+}
+LOOKUPS = {
+    "ecoalim-emissionsResourceUse": "emission-",
+    "crop": "ecoalimMapping",
+    "processedFood": "ecoalimMapping",
+    "animalProduct": "ecoalimMapping",
+    "forage": "ecoalimMapping",
+    "feedFoodAdditive": "ecoalimMapping"
+}
+MODEL_KEY = 'cycle'
+TIER = EmissionMethodTier.BACKGROUND.value
+
+
+def _emission(term_id: str, value: float, input: dict):
+    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')]
+    return emission
+
+
+def _add_emission(cycle: dict, input: dict):
+    input_term_id = input.get('term', {}).get('@id')
+    operation_term_id = input.get('operation', {}).get('@id')
+    animal_term_id = input.get('animal', {}).get('@id')
+
+    def add(prev: dict, mapping: tuple):
+        gadm_id, ecoalim_key = mapping
+        # all countries have the same coefficient
+        coefficient = 1
+        emissions = ecoalim_values(ecoalim_key, 'emission')
+        for emission_term_id, value in emissions:
+            # log run on each emission so we know it did run
+            debugValues(cycle, model=MODEL, term=emission_term_id, model_key=MODEL_KEY,
+                        value=value,
+                        coefficient=coefficient,
+                        input=input_term_id,
+                        operation=operation_term_id,
+                        animal=animal_term_id)
+            prev[emission_term_id] = prev.get(emission_term_id, []) + [value * coefficient]
+        return prev
+    return add
+
+
+def _run_input(cycle: dict):
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
+
+    def run(inputs: list):
+        input = inputs[0]
+        input_term_id = input.get('term', {}).get('@id')
+        input_value = list_sum(flatten(input.get('value', []) for input in inputs))
+        mappings = get_input_mappings(MODEL, input)
+        has_mappings = len(mappings) > 0
+
+        # skip input that has background emissions we have already gap-filled (model run before)
+        has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
+
+        logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
+                        has_ecoalim_mappings=has_mappings,
+                        ecoalim_mappings=';'.join([v[1] for v in mappings]),
+                        has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
+                        input_value=input_value)
+
+        should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
+        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
+
+        grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
+        return [
+            _emission(term_id, mean(value) * input_value, input)
+            for term_id, value in grouped_emissions.items()
+        ]
+    return run
+
+
+def run(cycle: dict):
+    inputs = get_background_inputs(cycle)
+    grouped_inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
+    return flatten(map(_run_input(cycle), grouped_inputs.values()))

hestia_earth/models/ecoalimV9/impact_assessment.py

@@ -0,0 +1,125 @@
+from functools import reduce
+from statistics import mean
+from hestia_earth.schema import IndicatorMethodTier
+from hestia_earth.utils.tools import flatten, list_sum
+
+from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.background_emissions import get_background_inputs
+from hestia_earth.models.utils.blank_node import group_by_keys
+from .utils import get_input_mappings, ecoalim_values
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "cycle": {
+            "@type": "Cycle",
+            "inputs": [{
+                "@type": "Input",
+                "value": "> 0",
+                "none": {
+                    "fromCycle": "True",
+                    "producedInCycle": "True"
+                }
+            }],
+            "optional": {
+                "animals": [{
+                    "@type": "Animal",
+                    "inputs": [{
+                        "@type": "Input",
+                        "value": "> 0",
+                        "none": {
+                            "fromCycle": "True",
+                            "producedInCycle": "True"
+                        }
+                    }]
+                }]
+            }
+        }
+    }
+}
+RETURNS = {
+    "Indicator": [{
+        "term": "",
+        "value": "",
+        "methodTier": "background",
+        "inputs": "",
+        "operation": ""
+    }]
+}
+LOOKUPS = {
+    "ecoalim-emissionsResourceUse": "resourceUse-",
+    "crop": "ecoalimMapping",
+    "processedFood": "ecoalimMapping",
+    "animalProduct": "ecoalimMapping",
+    "forage": "ecoalimMapping",
+    "feedFoodAdditive": "ecoalimMapping"
+}
+MODEL_KEY = 'impact_assessment'
+TIER = IndicatorMethodTier.BACKGROUND.value
+
+
+def _indicator(term_id: str, value: float, input: dict):
+    indicator = _new_indicator(term_id, MODEL)
+    indicator['value'] = value
+    indicator['methodTier'] = TIER
+    indicator['inputs'] = [input.get('term')]
+    if input.get('operation'):
+        indicator['operation'] = input.get('operation')
+    return indicator
+
+
+def _add_indicator(cycle: dict, input: dict):
+    input_term_id = input.get('term', {}).get('@id')
+    operation_term_id = input.get('operation', {}).get('@id')
+    animal_term_id = input.get('animal', {}).get('@id')
+
+    def add(prev: dict, mapping: tuple):
+        gadm_id, ecoalim_key = mapping
+        # all countries have the same coefficient
+        coefficient = 1
+        indicators = ecoalim_values(ecoalim_key, 'resourceUse')
+        for indicator_term_id, value in indicators:
+            # log run on each indicator so we know it did run
+            debugValues(cycle, model=MODEL, term=indicator_term_id, model_key=MODEL_KEY,
+                        value=value,
+                        coefficient=coefficient,
+                        input=input_term_id,
+                        operation=operation_term_id,
+                        animal=animal_term_id)
+            if value is not None:
+                prev[indicator_term_id] = prev.get(indicator_term_id, []) + [value * coefficient]
+        return prev
+    return add
+
+
+def _run_input(impact_assessment: dict):
+    def run(inputs: list):
+        input = inputs[0]
+        input_term_id = input.get('term', {}).get('@id')
+        input_value = list_sum(flatten(input.get('value', []) for input in inputs))
+        mappings = get_input_mappings(MODEL, input)
+        has_mappings = len(mappings) > 0
+
+        logRequirements(impact_assessment, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
+                        has_ecoalim_mappings=has_mappings,
+                        ecoalim_mappings=';'.join([v[1] for v in mappings]),
+                        input_value=input_value)
+
+        should_run = all([has_mappings, input_value])
+        logShouldRun(
+            impact_assessment, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY
+        )
+
+        grouped_indicators = reduce(_add_indicator(impact_assessment, input), mappings, {}) if should_run else {}
+        return [
+            _indicator(term_id, mean(value) * input_value, input)
+            for term_id, value in grouped_indicators.items()
+        ]
+    return run
+
+
+def run(impact_assessment: dict):
+    inputs = get_background_inputs(impact_assessment.get('cycle', {}))
+    grouped_inputs = reduce(group_by_keys(['term', 'operation']), inputs, {})
+    return flatten(map(_run_input(impact_assessment), grouped_inputs.values()))

hestia_earth/models/ecoalimV9/utils.py

@@ -0,0 +1,31 @@
+from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, lookup_columns
+from hestia_earth.utils.tools import non_empty_list
+
+from hestia_earth.models.utils.term import get_lookup_value
+
+
+_LOOKUP = "ecoalim-emissionsResourceUse.csv"
+
+
+def get_input_mappings(model: str, input: dict):
+    term = input.get('term', {})
+    term_id = term.get('@id')
+    value = get_lookup_value(term, 'ecoalimMapping', model=model, term=term_id)
+    mappings = non_empty_list(value.split(';')) if value else []
+    return [(m.split(':')[0], m.split(':')[1]) for m in mappings]
+
+
+def ecoalim_values(mapping: str, column_prefix: str):
+    lookup = download_lookup(_LOOKUP)
+    col_name = column_name('ecoalimMappingName')
+
+    def emission(column: str):
+        id = get_table_value(lookup, col_name, mapping, column)
+        value = get_table_value(lookup, col_name, mapping, column.replace('term', 'value'))
+        return (id, value) if id else None
+
+    columns = [
+        col for col in lookup_columns(lookup)
+        if col.startswith(column_name(column_prefix)) and col.endswith(column_name('term'))
+    ]
+    return non_empty_list(map(emission, columns))

hestia_earth/models/ecoinventV3/__init__.py

@@ -4,12 +4,12 @@ from hestia_earth.utils.tools import flatten, list_sum
 
 from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
 from hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
-from hestia_earth.models.utils import is_from_model
 from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.background_emissions import get_background_inputs, no_gap_filled_background_emissions
 from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.pesticideAI import get_pesticides_from_inputs
 from hestia_earth.models.utils.fertiliser import get_fertilisers_from_inputs
-from .utils import get_background_inputs, get_input_mappings
+from .utils import get_input_mappings
 
 REQUIREMENTS = {
     "Cycle": {
@@ -96,26 +96,17 @@ def _add_emission(cycle: dict, input: dict):
 
 
 def _run_input(cycle: dict):
-    emissions = cycle.get('emissions', [])
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
 
     def run(inputs: list):
         input = inputs[0]
         input_term_id = input.get('term', {}).get('@id')
-        operation_term_id = input.get('operation', {}).get('@id')
-        animal_term_id = input.get('animal', {}).get('@id')
         input_value = list_sum(flatten(input.get('value', []) for input in inputs))
         mappings = get_input_mappings(MODEL, cycle, input)
         has_mappings = len(mappings) > 0
+
         # skip input that has background emissions we have already gap-filled (model run before)
-        has_no_gap_filled_background_emissions = not any([
-            is_from_model(e)
-            for e in emissions
-            if all([
-                any([i.get('@id') == input_term_id for i in e.get('inputs', [])]),
-                e.get('operation', {}).get('@id') == operation_term_id,
-                e.get('animal', {}).get('@id') == animal_term_id
-            ])
-        ])
+        has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
 
         logRequirements(cycle, model=MODEL, term=input_term_id,
                         has_ecoinvent_mappings=has_mappings,
@@ -125,6 +116,7 @@ def _run_input(cycle: dict):
 
         should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
+
         grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
         return [
             _emission(term_id, value * input_value, input)

hestia_earth/models/ecoinventV3/utils.py

@@ -1,36 +1,8 @@
-from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import flatten, non_empty_list
+from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.utils.term import get_lookup_value
 
 
-def _animal_inputs(animal: dict):
-    inputs = animal.get('inputs', [])
-    return [(input | {'animal': animal.get('term', {})}) for input in inputs]
-
-
-def _should_run_input(products: list):
-    def should_run(input: dict):
-        return all([
-            # make sure Input is not a Product as well or we might double-count emissions
-            find_term_match(products, input.get('term', {}).get('@id'), None) is None,
-            # ignore inputs which are flagged as Product of the Cycle
-            not input.get('fromCycle', False),
-            not input.get('producedInCycle', False)
-        ])
-    return should_run
-
-
-def get_background_inputs(cycle: dict, extra_inputs: list = []):
-    # add all the properties of some Term that inlcude others with the mapping
-    inputs = flatten(
-        cycle.get('inputs', []) +
-        list(map(_animal_inputs, cycle.get('animals', []))) +
-        extra_inputs
-    )
-    return list(filter(_should_run_input(cycle.get('products', [])), inputs))
-
-
 def get_input_mappings(model: str, cycle: dict, input: dict):
     term = input.get('term', {})
     term_id = term.get('@id')

hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -4,12 +4,13 @@ from hestia_earth.schema import EmissionMethodTier
 
 from hestia_earth.models.log import logShouldRun, logRequirements, debugValues
 from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.background_emissions import get_background_inputs, no_gap_filled_background_emissions
 from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.term import get_electricity_grid_mix_terms
 from hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
 from .utils import get_input_coefficient
-from ..ecoinventV3.utils import get_background_inputs, get_input_mappings
+from ..ecoinventV3.utils import get_input_mappings
 
 REQUIREMENTS = {
     "Cycle": {
@@ -101,6 +102,7 @@ def _add_emission(cycle: dict, input: dict):
 
 def _run_input(cycle: dict):
     electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
 
     def run(inputs: list):
         input = inputs[0]
@@ -109,12 +111,16 @@ def _run_input(cycle: dict):
         mappings = get_input_mappings(MODEL, cycle, input)
         has_mappings = len(mappings) > 0
 
+        # skip input that has background emissions we have already gap-filled (model run before)
+        has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
+
         logRequirements(cycle, model=MODEL, term=input_term_id,
                         has_ecoinvent_mappings=has_mappings,
                         ecoinvent_mappings=';'.join([v[0] for v in mappings]),
+                        has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
                         input_value=input_value)
 
-        should_run = all([electricity_complete, has_mappings, input_value])
+        should_run = all([electricity_complete, has_mappings, has_no_gap_filled_background_emissions, input_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
 
         grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}