hestia-earth-models 0.70.5__py3-none-any.whl → 0.71.0__py3-none-any.whl

hestia_earth/models/cache_nodes.py

@@ -0,0 +1,157 @@
+import os
+from functools import reduce
+from hestia_earth.schema import NodeType
+from hestia_earth.utils.tools import current_time_ms, flatten
+from hestia_earth.earth_engine import init_gee
+
+from .log import logger
+from .utils import CACHE_KEY
+from .utils.site import years_from_cycles
+from .utils.source import CACHE_SOURCES_KEY, find_sources
+from .cache_sites import run as cache_sites
+
+CACHE_RELATED_KEY = 'related'
+CACHE_NESTED_KEY = 'nested'
+
+_CACHE_BATCH_SIZE = int(os.getenv('CACHE_SITES_BATCH_SIZE', '5000'))
+_ENABLE_CACHE_YEARS = os.getenv('ENABLE_CACHE_YEARS', 'true') == 'true'
+_ENABLE_CACHE_RELATED_NODES = os.getenv('ENABLE_CACHE_RELATED_NODES', 'true') == 'true'
+_CACHE_NODE_TYPES = [
+    NodeType.SITE.value,
+    NodeType.CYCLE.value,
+    NodeType.IMPACTASSESSMENT.value
+]
+
+
+def _pop_items(values: list, nb_items: int):
+    if len(values) < nb_items:
+        removed_items = values[:]  # Get a copy of the entire array
+        values.clear()  # Remove all items from the original array
+    else:
+        removed_items = values[:nb_items]  # Get the first N items
+        del values[:nb_items]  # Remove the first N items from the original array
+
+    return removed_items
+
+
+def _filter_by_type(nodes: list, type: str): return [n for n in nodes if n.get('@type', n.get('type')) == type]
+
+
+def _node_key(node: dict): return '/'.join([node.get('type', node.get('@type')), node.get('id', node.get('@id'))])
+
+
+def _years_from_cycles(nodes: dict): return years_from_cycles(_filter_by_type(nodes, NodeType.CYCLE.value))
+
+
+def _linked_node(data: dict): return {'type': data.get('type'), 'id': data.get('id')}
+
+
+def _find_nested_nodes(data) -> list[dict]:
+    if isinstance(data, dict):
+        if data.get('type') in _CACHE_NODE_TYPES and data.get('id'):
+            return [_linked_node(data)]
+        return flatten(_find_nested_nodes(list(data.values())))
+    if isinstance(data, list):
+        return flatten(map(_find_nested_nodes, data))
+    return []
+
+
+def _nested_nodes(node_keys: list[str]):
+    def exec(group: dict, node: dict):
+        nested_nodes = _find_nested_nodes(list(node.values()))
+
+        for nested_node in nested_nodes:
+            group_id = _node_key(nested_node)
+            group[group_id] = group.get(group_id, {})
+            group[group_id][CACHE_RELATED_KEY] = group.get(group_id, {}).get(CACHE_RELATED_KEY, []) + [
+                _linked_node(node)
+            ]
+
+            # cache nodes that current node refers (nesting)
+            if group_id in node_keys:
+                group_id = _node_key(node)
+                group[group_id] = group.get(group_id, {})
+                group[group_id][CACHE_NESTED_KEY] = group.get(group_id, {}).get(CACHE_NESTED_KEY, []) + [
+                    _linked_node(nested_node)
+                ]
+
+        return group
+    return exec
+
+
+def _cache_related_nodes(nodes: list):
+    # only cache nodes included in the file
+    nodes_keys = list(map(_node_key, nodes))
+    # for each node, compile list of nested nodes
+    nested_nodes_mapping = reduce(_nested_nodes(nodes_keys), nodes, {})
+
+    def cache_related_node(node: dict):
+        nodes_mapping = nested_nodes_mapping.get(_node_key(node), {})
+        related_nodes = nodes_mapping.get(CACHE_RELATED_KEY) or []
+        nested_nodes = nodes_mapping.get(CACHE_NESTED_KEY) or []
+        # save in cache
+        cached_data = node.get(CACHE_KEY, {}) | {
+            CACHE_RELATED_KEY: related_nodes,
+            CACHE_NESTED_KEY: nested_nodes
+        }
+        return node | {CACHE_KEY: cached_data}
+
+    return list(map(cache_related_node, nodes))
+
+
+def _cache_sources(nodes: list):
+    sources = find_sources()
+    return [
+        n | ({
+            CACHE_KEY: n.get(CACHE_KEY, {}) | {CACHE_SOURCES_KEY: sources}
+        } if n.get('type', n.get('@type')) in _CACHE_NODE_TYPES else {})
+        for n in nodes
+    ]
+
+
+def _safe_cache_sites(sites: list, years: list):
+    try:
+        return cache_sites(sites, years)
+    except Exception as e:
+        logger.error(f"An error occured while caching nodes on EE: {str(e)}")
+        if 'exceeded' in str(e):
+            logger.debug('Fallback to caching sites one by one')
+            # run one by one in case the batching does not work
+            return flatten([cache_sites([site], years) for site in sites])
+        else:
+            raise e
+
+
+def _cache_sites(nodes: list, batch_size: int = _CACHE_BATCH_SIZE):
+    start = current_time_ms()
+
+    # build list of nodes by key to update as sites are processed
+    nodes_mapping = {_node_key(n): n for n in nodes}
+
+    years = _years_from_cycles(nodes) if _ENABLE_CACHE_YEARS else []
+    sites = _filter_by_type(nodes, 'Site')
+
+    while len(sites) > 0:
+        batch_values = _pop_items(sites, batch_size)
+        logger.info(f"Processing {len(batch_values)} sites / {len(sites)} remaining.")
+        results = _safe_cache_sites(batch_values, years)
+        for result in results:
+            nodes_mapping[_node_key(result)] = result
+
+    logger.info(f"Done caching sites in {current_time_ms() - start} ms")
+
+    # replace original sites with new cached sites
+    return list(nodes_mapping.values())
+
+
+def run(nodes: list):
+    init_gee()
+
+    # cache sites data
+    cached_nodes = _cache_sites(nodes)
+
+    # cache related nodes
+    cached_nodes = _cache_related_nodes(cached_nodes) if _ENABLE_CACHE_RELATED_NODES else cached_nodes
+
+    # cache sources
+    return _cache_sources(cached_nodes)

hestia_earth/models/cache_sites.py

@@ -81,7 +81,7 @@ def _run_values(
         site_cache = merge(
             site.get(CACHE_KEY, {}),
             {CACHE_GEOSPATIAL_KEY: cached_data},
-            ({CACHE_YEARS_KEY: list(set(cached_value(site, CACHE_YEARS_KEY, []) + years))} if years else {})
+            ({CACHE_YEARS_KEY: sorted(list(set(cached_value(site, CACHE_YEARS_KEY, []) + years)))} if years else {})
         )
         return merge(site, {CACHE_KEY: site_cache})
 

hestia_earth/models/config/Cycle.json

@@ -2054,36 +2054,6 @@
         },
         "stage": 2
       },
-      {
-        "key": "emissions",
-        "model": "ipcc2006",
-        "value": "n2OToAirOrganicSoilCultivationDirect",
-        "runStrategy": "add_blank_node_if_missing",
-        "runArgs": {
-          "runNonMeasured": true,
-          "runNonAddedTerm": true
-        },
-        "mergeStrategy": "list",
-        "mergeArgs": {
-          "replaceThreshold": ["value", 0.01]
-        },
-        "stage": 2
-      },
-      {
-        "key": "emissions",
-        "model": "ipcc2006",
-        "value": "co2ToAirOrganicSoilCultivation",
-        "runStrategy": "add_blank_node_if_missing",
-        "runArgs": {
-          "runNonMeasured": true,
-          "runNonAddedTerm": true
-        },
-        "mergeStrategy": "list",
-        "mergeArgs": {
-          "replaceThreshold": ["value", 0.01]
-        },
-        "stage": 2
-      },
       {
         "key": "emissions",
         "model": "ipcc2006",

hestia_earth/models/data/ecoinventV3/__init__.py

@@ -5,17 +5,19 @@ 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__))
-_FILEPATH = os.getenv('ECOINVENT_V3_FILEPATH', f"{os.path.join(CURRENT_DIR, 'ecoinventV3_excerpt')}.csv")
+_CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+_ENV_NAME = 'ECOINVENT_V3_FILEPATH'
 
 
 @lru_cache()
 def _get_file():
-    if not os.path.exists(_FILEPATH):
-        logger.warning('Ecoinvent file not found. Please make sure to set env variable "ECOINVENT_V3_FILEPATH".')
+    filepath = os.getenv(_ENV_NAME, f"{os.path.join(_CURRENT_DIR, 'ecoinventV3_excerpt')}.csv")
+
+    if not os.path.exists(filepath):
+        logger.warning('Ecoinvent file not found. Please make sure to set env variable "%s".', _ENV_NAME)
         return None
 
-    return load_lookup(filepath=_FILEPATH, keep_in_memory=True)
+    return load_lookup(filepath=filepath, keep_in_memory=True)
 
 
 def ecoinventV3_emissions(ecoinventName: str):

hestia_earth/models/ecoinventV3/__init__.py

@@ -5,7 +5,11 @@ 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.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.background_emissions import (
+    get_background_inputs,
+    no_gap_filled_background_emissions,
+    log_missing_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
@@ -47,6 +51,7 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
+    "emission": "inputProductionGroupId",
     "electricity": "ecoinventMapping",
     "fuel": "ecoinventMapping",
     "inorganicFertiliser": "ecoinventMapping",
@@ -97,6 +102,7 @@ def _add_emission(cycle: dict, input: dict):
 
 def _run_input(cycle: dict):
     no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
+    log_missing_emissions_func = log_missing_emissions(cycle, model=MODEL, methodTier=TIER)
 
     def run(inputs: list):
         input = inputs[0]
@@ -118,6 +124,7 @@ def _run_input(cycle: dict):
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
 
         grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
+        log_missing_emissions_func(input_term_id, list(grouped_emissions.keys()))
         return [
             _emission(term_id, value * input_value, input)
             for term_id, value in grouped_emissions.items()

hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -118,6 +118,7 @@ def _run_input(cycle: dict):
                         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,
+                        termType_electricityFuel_complete=electricity_complete,
                         input_value=input_value)
 
         should_run = all([electricity_complete, has_mappings, has_no_gap_filled_background_emissions, input_value])

hestia_earth/models/emepEea2019/co2ToAirFuelCombustion.py

@@ -1,8 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from .utils import get_fuel_values, _emission
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
 from . import MODEL
 
 REQUIREMENTS = {
@@ -20,6 +20,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Emission": [{
         "value": "",
+        "inputs": "",
+        "operation": "",
         "methodTier": "tier 1"
     }]
 }
@@ -31,23 +33,26 @@ TERM_ID = 'co2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _run(fuel_values: list):
-    value = list_sum(fuel_values)
-    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
-
-
 def _should_run(cycle: dict):
-    fuel_values = get_fuel_values(TERM_ID, cycle, LOOKUPS['fuel'])
-    has_fuel = len(fuel_values) > 0
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_fuel=has_fuel)
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
 
-    should_run = any([has_fuel])
+    should_run = any([bool(valid_inputs), electricity_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, fuel_values
+    return should_run, group_fuel_inputs(valid_inputs)
 
 
 def run(cycle: dict):
-    should_run, fuel_values = _should_run(cycle)
-    return _run(fuel_values) if should_run else []
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth/models/emepEea2019/n2OToAirFuelCombustionDirect.py

@@ -1,8 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from .utils import get_fuel_values, _emission
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
 from . import MODEL
 
 REQUIREMENTS = {
@@ -10,7 +10,7 @@ REQUIREMENTS = {
         "or": {
             "inputs": [
                 {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
-                     "operation": ""
+                    "operation": ""
                 }}
             ],
             "completeness.electricityFuel": "True"
@@ -20,6 +20,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Emission": [{
         "value": "",
+        "inputs": "",
+        "operation": "",
         "methodTier": "tier 1"
     }]
 }
@@ -31,23 +33,26 @@ TERM_ID = 'n2OToAirFuelCombustionDirect'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _run(fuel_values: list):
-    value = list_sum(fuel_values)
-    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
-
-
 def _should_run(cycle: dict):
-    fuel_values = get_fuel_values(TERM_ID, cycle, LOOKUPS['fuel'])
-    has_fuel = len(fuel_values) > 0
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_fuel=has_fuel)
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
 
-    should_run = any([has_fuel])
+    should_run = any([bool(valid_inputs), electricity_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, fuel_values
+    return should_run, group_fuel_inputs(valid_inputs)
 
 
 def run(cycle: dict):
-    should_run, fuel_values = _should_run(cycle)
-    return _run(fuel_values) if should_run else []
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth/models/emepEea2019/noxToAirFuelCombustion.py

@@ -1,8 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from .utils import get_fuel_values, _emission
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
 from . import MODEL
 
 REQUIREMENTS = {
@@ -20,6 +20,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Emission": [{
         "value": "",
+        "inputs": "",
+        "operation": "",
         "methodTier": "tier 1"
     }]
 }
@@ -31,23 +33,26 @@ TERM_ID = 'noxToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _run(fuel_values: list):
-    value = list_sum(fuel_values)
-    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
-
-
 def _should_run(cycle: dict):
-    fuel_values = get_fuel_values(TERM_ID, cycle, LOOKUPS['fuel'])
-    has_fuel = len(fuel_values) > 0
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_fuel=has_fuel)
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
 
-    should_run = any([has_fuel])
+    should_run = any([bool(valid_inputs), electricity_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, fuel_values
+    return should_run, group_fuel_inputs(valid_inputs)
 
 
 def run(cycle: dict):
-    should_run, fuel_values = _should_run(cycle)
-    return _run(fuel_values) if should_run else []
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth/models/emepEea2019/so2ToAirFuelCombustion.py

@@ -1,8 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from .utils import get_fuel_values, _emission
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
 from . import MODEL
 
 REQUIREMENTS = {
@@ -20,6 +20,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Emission": [{
         "value": "",
+        "inputs": "",
+        "operation": "",
         "methodTier": "tier 1"
     }]
 }
@@ -31,23 +33,26 @@ TERM_ID = 'so2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _run(fuel_values: list):
-    value = list_sum(fuel_values)
-    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
-
-
 def _should_run(cycle: dict):
-    fuel_values = get_fuel_values(TERM_ID, cycle, LOOKUPS['fuel'])
-    has_fuel = len(fuel_values) > 0
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_fuel=has_fuel)
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
 
-    should_run = any([has_fuel])
+    should_run = any([bool(valid_inputs), electricity_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, fuel_values
+    return should_run, group_fuel_inputs(valid_inputs)
 
 
 def run(cycle: dict):
-    should_run, fuel_values = _should_run(cycle)
-    return _run(fuel_values) if should_run else []
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth/models/emepEea2019/utils.py

@@ -1,48 +1,96 @@
+from functools import reduce
 from hestia_earth.schema import TermTermType, SiteSiteType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.lookup import extract_grouped_data
-from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
+from hestia_earth.utils.tools import list_sum, safe_parse_float
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.completeness import _is_term_type_complete
+from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.cycle import get_animals_by_period
 from hestia_earth.models.utils.emission import _new_emission
 from . import MODEL
 
 
-def _emission(value: float, tier: str, term_id: str):
+def _emission(value: float, tier: str, term_id: str, input: dict = None, operation: dict = None):
     emission = _new_emission(term_id, MODEL)
     emission['value'] = [value]
     emission['methodTier'] = tier
+    if input:
+        emission['inputs'] = [input]
+    if operation:
+        emission['operation'] = operation
     return emission
 
 
-def _get_fuel_input_value(term_id: str, lookup_col: str):
-    def get_value(input: dict):
-        input_term = input.get('term', {})
-        input_term_id = input_term.get('@id')
-        operation_term = input.get('operation', {})
-        input_value = list_sum(input.get('value', []))
-
-        operation_factor = extract_grouped_data(
-            get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id), input_term_id
-        ) if operation_term else None
-        input_factor = operation_factor or get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id)
-        factor = safe_parse_float(input_factor, None)
-
-        return input_value * factor if factor is not None else None
-    return get_value
-
+def _run_inputs(inputs: list, tier: str, term_id: str):
+    total_value = list_sum([
+        (i.get('input-value') or 0) * (i.get('operation-factor') or i.get('input-default-factor') or 0)
+        for i in inputs
+    ])
+    input_term = {
+        '@type': 'Term',
+        '@id': inputs[0].get('input-id'),
+        'termType': inputs[0].get('input-termType'),
+        'units': inputs[0].get('input-units'),
+    }
+    operation_term = {
+        '@type': 'Term',
+        '@id': inputs[0].get('operation-id'),
+        'termType': inputs[0].get('operation-termType'),
+        'units': inputs[0].get('operation-units'),
+    } if inputs[0].get('operation-id') else None
+    return _emission(
+        value=total_value,
+        tier=tier,
+        term_id=term_id,
+        input=input_term,
+        operation=operation_term
+    )
 
-def get_fuel_values(term_id: str, cycle: dict, lookup_col: str):
-    inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
-    values = non_empty_list(map(_get_fuel_input_value(term_id, lookup_col), inputs))
 
-    return [0] if all([
-        len(values) == 0,
-        _is_term_type_complete(cycle, 'electricityFuel')
-    ]) else values
+def _fuel_input_data(term_id: str, lookup_col: str, input: dict):
+    input_term = input.get('term', {})
+    input_term_id = input_term.get('@id')
+    operation_term = input.get('operation', {})
+    input_value = list_sum(input.get('value', []), None)
+
+    operation_factor = extract_grouped_data(
+        data=get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id),
+        key=input_term_id
+    ) if operation_term else None
+    input_factor = get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id)
+
+    return {
+        'input-id': input_term_id,
+        'input-termType': input_term.get('termType'),
+        'input-units': input_term.get('units'),
+        'input-value': input_value,
+        'input-default-factor': safe_parse_float(input_factor, default=None),
+        'operation-id': operation_term.get('@id'),
+        'operation-termType': operation_term.get('termType'),
+        'operation-units': operation_term.get('units'),
+        'operation-factor': safe_parse_float(operation_factor, default=None)
+    }
+
+
+def get_fuel_inputs(term_id: str, cycle: dict, lookup_col: str):
+    inputs = [
+        _fuel_input_data(term_id, lookup_col, i)
+        for i in filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
+    ]
+    valid_inputs = [
+        i for i in inputs if all([
+            i.get('input-value') is not None,
+            (i.get('operation-factor') or i.get('input-default-factor')) is not None
+        ])
+    ]
+    return inputs, valid_inputs
+
+
+def group_fuel_inputs(inputs: list):
+    return reduce(group_by_keys(['input-id', 'operation-id']), inputs, {}) if len(inputs) > 0 else None
 
 
 def _get_emissions_factor(animal: dict, lookup_col: str) -> float:

hestia_earth/models/hestia/aboveGroundCropResidue.py

@@ -105,9 +105,9 @@ def _run(cycle: dict, total_values: list):
         term_id = model.get('product')
         value = _run_model(model, cycle, total_value)
         debugValues(cycle, model=MODEL, term=term_id,
-                    total_value=total_value,
-                    remaining_value=remaining_value,
-                    value=value)
+                    total_above_ground_crop_residue=total_value,
+                    remaining_crop_residue_value=remaining_value,
+                    allocated_value=value)
 
         if value == 0:
             values.extend([_product(term_id, value)])