hestia-earth-models 0.73.8__tar.gz → 0.74.1__tar.gz

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.73.8
+Version: 0.74.1
 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.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -38,8 +38,8 @@ RETURNS = {
 }
 LOOKUPS = {
     "@doc": "Different lookup files are used depending on the situation",
-    "awareWaterBasinId": "",
-    "region-aware-factors": ""
+    "awareWaterBasinId": ["YR_IRRI", "YR_NONIRRI", "YR_TOT"],
+    "region-aware-factors": ["Agg_CF_irri", "Agg_CF_non_irri", "Agg_CF_unspecified"]
 }
 TERM_ID = 'scarcityWeightedWaterUse'
 AWARE_KEY = 'awareWaterBasinId'
@@ -48,6 +48,8 @@ IRRIGATED_SITE_TYPES = [
     SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value,
     SiteSiteType.PERMANENT_PASTURE.value
 ]
+_REGION_LOOKUP = 'region-aware-factors.csv'
+_AWARE_LOOKUP = 'awareWaterBasinId.csv'
 
 
 def _indicator(value: float):
@@ -59,19 +61,18 @@ def _indicator(value: float):
 def _get_factor_from_basinId(site: dict, aware_id: str):
     lookup_col = 'YR_IRRI' if site.get('siteType') in IRRIGATED_SITE_TYPES else 'YR_NONIRRI'
     value = _get_single_table_value(
-        download_lookup(f"{AWARE_KEY}.csv"), column_name(AWARE_KEY), int(aware_id), column_name(lookup_col)
+        download_lookup(_AWARE_LOOKUP), column_name(AWARE_KEY), int(aware_id), column_name(lookup_col)
     )
-    debugMissingLookup(f"{AWARE_KEY}.csv", AWARE_KEY, aware_id, lookup_col, value, model=MODEL, term=TERM_ID)
+    debugMissingLookup(_AWARE_LOOKUP, AWARE_KEY, aware_id, lookup_col, value, model=MODEL, term=TERM_ID)
     return safe_parse_float(value, default=None)
 
 
 def _get_factor_from_region(impact_assessment: dict, fresh_water: dict, site: dict):
     region_id = get_region_id(impact_assessment, fresh_water)
     site_type = site.get('siteType')
-    lookup_name = 'region-aware-factors.csv'
     lookup_suffix = 'unspecified' if not site_type else ('irri' if site_type in IRRIGATED_SITE_TYPES else 'non_irri')
     column = f"Agg_CF_{lookup_suffix}"
-    value = get_region_lookup_value(lookup_name, region_id, column, model=MODEL, term=TERM_ID)
+    value = get_region_lookup_value(_REGION_LOOKUP, region_id, column, model=MODEL, term=TERM_ID)
     return safe_parse_float(value, default=None)
 
 

hestia_earth_models-0.74.1/hestia_earth/models/aware2_0/__init__.py

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

hestia_earth_models-0.74.1/hestia_earth/models/aware2_0/scarcityWeightedWaterUse.py

@@ -0,0 +1,115 @@
+from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.lookup import download_lookup, _get_single_table_value, column_name
+from hestia_earth.utils.tools import safe_parse_float
+
+from hestia_earth.models.log import logRequirements, debugMissingLookup, logShouldRun
+from hestia_earth.models.utils import sum_values, multiply_values
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.impact_assessment import (
+    convert_value_from_cycle, get_product, get_site, get_region_id
+)
+from hestia_earth.models.utils.input import sum_input_impacts
+from hestia_earth.models.utils.lookup import get_region_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "site": {
+            "@type": "Site",
+            "or": {
+                "awareWaterBasinId": "",
+                "country": {"@type": "Term", "termType": "region"}
+            }
+        },
+        "optional": {
+            "emissionsResourceUse": [{
+                "@type": "Indicator",
+                "term.@id": "freshwaterWithdrawalsDuringCycle",
+                "value": ""
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Indicator": [{
+        "value": ""
+    }]
+}
+LOOKUPS = {
+    "@doc": "Different lookup files are used depending on the situation",
+    "awareWaterBasinId-2-0": ["CFs_agri", "CFs_nonagri", "CFs_unspecified"],
+    "region-aware-2-0-factors": ["CFs_agri", "CFs_nonagri", "CFs_unspecified"]
+}
+TERM_ID = 'scarcityWeightedWaterUse'
+AWARE_KEY = 'awareWaterBasinId'
+AGRI_SITE_TYPES = [
+    SiteSiteType.CROPLAND.value,
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value,
+    SiteSiteType.PERMANENT_PASTURE.value
+]
+_REGION_LOOKUP = 'region-aware-2-0-factors.csv'
+_AWARE_LOOKUP = 'awareWaterBasinId-2-0.csv'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _lookup_column(site: dict):
+    site_type = site.get('siteType')
+    return (
+        'CFs_unspecified' if not site_type else
+        'CFs_agri' if site_type in AGRI_SITE_TYPES else
+        'CFs_nonagri'
+    )
+
+
+def _get_factor_from_basinId(site: dict, aware_id: str):
+    lookup_col = _lookup_column(site)
+    lookup = download_lookup(_AWARE_LOOKUP)
+    try:
+        value = _get_single_table_value(lookup, column_name(AWARE_KEY), int(aware_id), column_name(lookup_col))
+    except Exception:
+        value = None
+    debugMissingLookup(_AWARE_LOOKUP, AWARE_KEY, aware_id, lookup_col, value, model=MODEL, term=TERM_ID)
+    return safe_parse_float(value, default=None)
+
+
+def _get_factor_from_region(impact_assessment: dict, fresh_water: dict, site: dict):
+    region_id = get_region_id(impact_assessment, fresh_water)
+    lookup_col = _lookup_column(site)
+    value = get_region_lookup_value(_REGION_LOOKUP, region_id, lookup_col, model=MODEL, term=TERM_ID)
+    return safe_parse_float(value, default=None)
+
+
+def run(impact_assessment: dict):
+    cycle = impact_assessment.get('cycle', {})
+    product = get_product(impact_assessment)
+    fresh_water = find_term_match(impact_assessment.get('emissionsResourceUse', []), 'freshwaterWithdrawalsDuringCycle')
+    site = get_site(impact_assessment)
+    aware_id = site.get(AWARE_KEY)
+    factor = (
+        _get_factor_from_basinId(site, aware_id) if aware_id else None
+    ) or _get_factor_from_region(impact_assessment, fresh_water, site)
+    inputs_value = convert_value_from_cycle(
+        impact_assessment, product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
+    )
+
+    value = sum_values([
+        multiply_values([fresh_water.get('value'), factor]),
+        inputs_value
+    ])
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    fresh_water=fresh_water.get('value'),
+                    aware_id=aware_id,
+                    factor=factor,
+                    inputs_value=inputs_value)
+
+    should_run = all([value is not None])
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+
+    return [_indicator(value)] if should_run else []

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/config/Cycle.json

@@ -955,7 +955,7 @@
     {
       "key": "emissions",
       "model": "ecoinventV3AndEmberClimate",
-      "value": "all",
+      "value": "cycle",
       "runStrategy": "always",
       "mergeStrategy": "list",
       "mergeArgs": {
@@ -966,7 +966,7 @@
     {
       "key": "emissions",
       "model": "ecoinventV3",
-      "value": "all",
+      "value": "cycle",
       "runStrategy": "always",
       "mergeStrategy": "list",
       "mergeArgs": {
@@ -1469,7 +1469,9 @@
           "replaceThreshold": ["value", 0.01]
         },
         "stage": 2
-      },
+      }
+    ],
+    [
       {
         "key": "emissions",
         "model": "dammgen2009",

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/config/ImpactAssessment.json

@@ -806,7 +806,7 @@
       },
       {
         "key": "impacts",
-        "model": "aware",
+        "model": "aware2-0",
         "value": "scarcityWeightedWaterUse",
         "runStrategy": "always",
         "mergeStrategy": "list",

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/config/__init__.py

@@ -1,10 +1,16 @@
 import os
 import json
+from enum import Enum
 from hestia_earth.utils.tools import flatten
 
 CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
 
 
+class AWARE_VERSION(Enum):
+    V1 = '1.2'
+    V2 = '2.0'
+
+
 def _is_aggregated_model(model: dict):
     return isinstance(model, dict) and 'aggregated' in model.get('value', '').lower()
 
@@ -17,12 +23,26 @@ def _remove_aggregated(models: list):
     return list(filter(lambda v: v is not None, values))
 
 
+def _use_aware_1(models: list):
+    return [
+        _use_aware_1(m) if isinstance(m, list) else
+        m | {'model': 'aware'} if m.get('model') == 'aware2-0' else
+        m | {'value': 'awareWaterBasinId_v1'} if m.get('value') == 'awareWaterBasinId' else
+        m
+        for m in models
+    ]
+
+
 def _load_config(filename: str) -> dict:
     with open(os.path.join(CURRENT_DIR, f"{filename}.json"), 'r') as f:
         return json.load(f)
 
 
-def load_config(node_type: str, skip_aggregated_models: bool = False) -> dict:
+def load_config(
+    node_type: str,
+    skip_aggregated_models: bool = False,
+    use_aware_version: AWARE_VERSION = AWARE_VERSION.V2
+) -> dict:
     """
     Load the configuration associated with the Node Type.
 
@@ -32,11 +52,15 @@ def load_config(node_type: str, skip_aggregated_models: bool = False) -> dict:
         The Node Type to load configuration. Can be: `Cycle`, `Site`, `ImpactAssessment`.
     skip_aggregated_models : bool
         Include models using aggregated data. Included by default.
+    use_aware_version : AWARE_VERSION
+        Choose which AWARE version to use. Defaults to using version `2.0`.
     """
     try:
         config = _load_config(node_type)
         models = config.get('models')
-        return config | {'models': _remove_aggregated(models) if skip_aggregated_models else models}
+        models = _remove_aggregated(models) if skip_aggregated_models else models
+        models = _use_aware_1(models) if use_aware_version == AWARE_VERSION.V1 else models
+        return config | {'models': models}
     except FileNotFoundError:
         raise Exception(f"Invalid type {node_type}.")
 

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/cycle/animal/input/hestiaAggregatedData.py

@@ -56,12 +56,12 @@ def _should_run_animal(cycle: dict, animal: dict):
     inputs = list(filter(should_link_input_to_impact(cycle), inputs))
     nb_inputs = len(inputs)
 
-    logRequirements(cycle, model=MODEL_ID, term=term_id, key=MODEL_KEY,
+    logRequirements(cycle, model=MODEL_ID, term=term_id, key=MODEL_KEY, animalId=animal.get('animalId'),
                     end_date=end_date,
                     nb_inputs=nb_inputs)
 
     should_run = all([end_date, nb_inputs > 0])
-    logShouldRun(cycle, MODEL_ID, term_id, should_run, key=MODEL_KEY)
+    logShouldRun(cycle, MODEL_ID, term_id, should_run, key=MODEL_KEY, animalId=animal.get('animalId'))
     return should_run, inputs
 
 

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/cycle/animal/input/properties.py

@@ -50,7 +50,7 @@ def _find_related_product(input: dict):
     return find_term_match(products, input.get('term', {}).get('@id'))
 
 
-def _run_input_by_impactAssessment(cycle: dict):
+def _run_input_by_impactAssessment(cycle: dict, **log_args):
     def exec(input: dict):
         term_id = input.get('term', {}).get('@id')
         product = _find_related_product(input)
@@ -58,7 +58,7 @@ def _run_input_by_impactAssessment(cycle: dict):
         all_properties = input.get('properties', [])
         new_properties = [p for p in properties if not find_term_match(all_properties, p.get('term', {}).get('@id'))]
         for prop in new_properties:
-            logShouldRun(cycle, MODEL, term_id, True, property=prop.get('term', {}).get('@id'))
+            logShouldRun(cycle, MODEL, term_id, True, property=prop.get('term', {}).get('@id'), **log_args)
         return {**input, 'properties': merge_blank_nodes(all_properties, new_properties)} if new_properties else input
     return exec
 
@@ -80,9 +80,10 @@ def _run_animal(cycle: dict, animal: dict):
             should_run_properties_value(i)
         ])
     ]
-    inputs = list(map(_run_input_by_impactAssessment(cycle), inputs))
-    inputs = rescale_properties_from_dryMatter(MODEL, cycle, inputs)
-    inputs = average_blank_node_properties_value(cycle, inputs)
+    log_args = {'animalId': animal.get('animalId')}
+    inputs = list(map(_run_input_by_impactAssessment(cycle, **log_args), inputs))
+    inputs = rescale_properties_from_dryMatter(MODEL, cycle, inputs, **log_args)
+    inputs = average_blank_node_properties_value(cycle, inputs, **log_args)
     return animal | {'inputs': inputs}
 
 

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/cycle/animal/milkYield.py

@@ -42,12 +42,17 @@ def _run(cycle: dict, animal: dict):
     practices = non_empty_list(
         [p for p in cycle.get('practices', []) if p.get('term', {}).get('@id') in practice_ids]
     )
+    log_args = {
+        'model_key': MODEL_KEY,
+        'animalId': animal.get('animalId')
+    }
 
-    logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                    practice_ids=log_blank_nodes_id(practices))
+    logRequirements(cycle, model=MODEL, term=term_id,
+                    practice_ids=log_blank_nodes_id(practices),
+                    **log_args)
 
     for practice in practices:
-        logShouldRun(cycle, MODEL, practice.get('term', {}).get('@id'), True, model_key=MODEL_KEY)
+        logShouldRun(cycle, MODEL, practice.get('term', {}).get('@id'), True, **log_args)
 
     return {
         **animal,

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/cycle/utils.py

@@ -11,21 +11,21 @@ def _should_run_property_by_min_max(property: dict):
     ])
 
 
-def _run_property(cycle: dict, property: dict):
+def _run_property(cycle: dict, property: dict, **log_args):
     term_id = property.get('term', {}).get('@id')
 
     should_run = _should_run_property_by_min_max(property)
-    logShouldRun(cycle, MODEL, term_id, should_run, key='value')
+    logShouldRun(cycle, MODEL, term_id, should_run, key='value', **log_args)
 
     return property | ({
         'value': list_average([property.get('min'), property.get('max')])
     } if should_run else {})
 
 
-def _run_properties(cycle: dict, blank_node: dict):
+def _run_properties(cycle: dict, blank_node: dict, **log_args):
     properties = blank_node.get('properties', [])
     return blank_node | ({
-        'properties': [_run_property(cycle, p) for p in properties]
+        'properties': [_run_property(cycle, p, **log_args) for p in properties]
     } if properties else {})
 
 
@@ -33,5 +33,5 @@ def should_run_properties_value(blank_node: dict):
     return any(map(_should_run_property_by_min_max, blank_node.get('properties', [])))
 
 
-def average_blank_node_properties_value(cycle: dict, blank_nodes: list):
-    return [_run_properties(cycle, v) for v in blank_nodes]
+def average_blank_node_properties_value(cycle: dict, blank_nodes: list, **log_args):
+    return [_run_properties(cycle, v, **log_args) for v in blank_nodes]

hestia_earth_models-0.74.1/hestia_earth/models/data/ecoinventV3/__init__.py

@@ -0,0 +1,18 @@
+import os
+
+from hestia_earth.models.log import logger
+
+_CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+_ENV_FOLDER = 'ECOINVENT_V3_FOLDER'
+_ECOINVENT_FOLDER = os.getenv(_ENV_FOLDER) or _CURRENT_DIR
+_ECOINVENT_VERSION = os.getenv('ECOINVENT_VERSION', '3.9')
+
+
+def get_filepath(term_type: str):
+    filename = f"ecoinventV{_ECOINVENT_VERSION.replace('.', '_')}-{term_type}.csv"
+    filepath = os.path.join(_ECOINVENT_FOLDER, filename)
+    if not os.path.exists(filepath):
+        logger.warning('Ecoinvent file not found. Please make sure to set env variable "%s".', _ENV_FOLDER)
+        return None
+
+    return filepath

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/ecoalimV9/cycle.py

@@ -1,17 +1,18 @@
-from functools import reduce
 from statistics import mean
 from hestia_earth.schema import EmissionMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, list_sum
+from hestia_earth.utils.blank_node import group_by_keys
 
 from hestia_earth.models.log import 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,
-    log_missing_emissions
+    log_missing_emissions,
+    parse_term_id,
+    process_input_mappings
 )
-from hestia_earth.models.utils.blank_node import group_by_keys
-from .utils import get_input_mappings, process_input, parse_term_id
+from .utils import get_input_mappings, extract_input_mapping
 from . import MODEL
 
 REQUIREMENTS = {
@@ -51,6 +52,7 @@ RETURNS = {
 }
 LOOKUPS = {
     "ecoalim-emission": "emission-",
+    "emission": "inputProductionGroupId",
     "animalProduct": "ecoalimMapping",
     "crop": "ecoalimMapping",
     "feedFoodAdditive": "ecoalimMapping",
@@ -84,6 +86,13 @@ def _run_input(cycle: dict):
         mappings = get_input_mappings(MODEL, input)
         has_mappings = len(mappings) > 0
 
+        # grouping the inputs together in the logs
+        input_parent_term_id = (input.get('parent', {})).get('@id') or input.get('animalId', {})
+        extra_logs = {
+            **({'input_group_id': input_parent_term_id} if input_parent_term_id else {}),
+            **({'animalId': input.get('animalId')} if input.get('animalId') else {})
+        }
+
         # 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)
 
@@ -91,15 +100,22 @@ def _run_input(cycle: dict):
                         has_mappings=has_mappings,
                         mappings=';'.join([v[1] for v in mappings]),
                         has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
-                        input_value=input_value)
+                        input_value=input_value,
+                        **extra_logs)
 
         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)
+        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY, **extra_logs)
 
-        results = process_input(
-            cycle, input, mappings, TermTermType.EMISSION, model_key=MODEL_KEY
+        results = process_input_mappings(
+            cycle, input, mappings, TermTermType.EMISSION,
+            extract_mapping=extract_input_mapping,
+            **(
+                extra_logs | {'model': MODEL, 'model_key': MODEL_KEY}
+            )
         ) if should_run else {}
-        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())))
+        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())), **(
+            extra_logs | {'has_mappings': has_mappings}
+        ))
         return [
             _emission(
                 term_id=parse_term_id(term_id),
@@ -115,5 +131,5 @@ def _run_input(cycle: dict):
 
 def run(cycle: dict):
     inputs = get_background_inputs(cycle)
-    grouped_inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
+    grouped_inputs = group_by_keys(inputs, ['term', 'operation', 'animal'])
     return flatten(map(_run_input(cycle), grouped_inputs.values()))

{hestia_earth_models-0.73.8 → hestia_earth_models-0.74.1}/hestia_earth/models/ecoalimV9/impact_assessment.py

@@ -1,13 +1,17 @@
-from functools import reduce
 from statistics import mean
 from hestia_earth.schema import IndicatorMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, list_sum
+from hestia_earth.utils.blank_node import group_by_keys
 
 from hestia_earth.models.log import logShouldRun, logRequirements
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.background_emissions import get_background_inputs, log_missing_emissions
-from hestia_earth.models.utils.blank_node import group_by_keys
-from .utils import get_input_mappings, process_input, parse_term_id
+from hestia_earth.models.utils.background_emissions import (
+    get_background_inputs,
+    log_missing_emissions,
+    parse_term_id,
+    process_input_mappings
+)
+from .utils import get_input_mappings, extract_input_mapping
 from . import MODEL
 
 REQUIREMENTS = {
@@ -74,6 +78,8 @@ def _indicator(
     indicator['inputs'] = [input.get('term')]
     if input.get('operation'):
         indicator['operation'] = input.get('operation')
+    if input.get('animal'):
+        indicator['animals'] = [input.get('animal')]
     return indicator
 
 
@@ -89,20 +95,34 @@ def _run_input(impact_assessment: dict):
         mappings = get_input_mappings(MODEL, input)
         has_mappings = len(mappings) > 0
 
+        # grouping the inputs together in the logs
+        input_parent_term_id = (input.get('parent', {})).get('@id') or input.get('animalId', {})
+        extra_logs = {
+            **({'input_group_id': input_parent_term_id} if input_parent_term_id else {}),
+            **({'animalId': input.get('animalId')} if input.get('animalId') else {})
+        }
+
         logRequirements(impact_assessment, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
                         has_mappings=has_mappings,
                         mappings=';'.join([v[1] for v in mappings]),
-                        input_value=input_value)
+                        input_value=input_value,
+                        **extra_logs)
 
         should_run = all([has_mappings, input_value])
         logShouldRun(
-            impact_assessment, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY
+            impact_assessment, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY, **extra_logs
         )
 
-        results = process_input(
-            impact_assessment, input, mappings, TermTermType.RESOURCEUSE, model_key=MODEL_KEY
+        results = process_input_mappings(
+            impact_assessment, input, mappings, TermTermType.RESOURCEUSE,
+            extract_mapping=extract_input_mapping,
+            **(
+                extra_logs | {'model': MODEL, 'model_key': MODEL_KEY}
+            )
         ) if should_run else {}
-        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())))
+        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())), **(
+            extra_logs | {'has_mappings': has_mappings}
+        ))
         return [
             _indicator(
                 term_id=parse_term_id(term_id),
@@ -120,5 +140,5 @@ def _run_input(impact_assessment: dict):
 
 def run(impact_assessment: dict):
     inputs = get_background_inputs(impact_assessment.get('cycle', {}))
-    grouped_inputs = reduce(group_by_keys(['term', 'operation']), inputs, {})
+    grouped_inputs = group_by_keys(inputs, ['term', 'operation', 'animal'])
     return flatten(map(_run_input(impact_assessment), grouped_inputs.values()))

hestia_earth_models-0.74.1/hestia_earth/models/ecoalimV9/utils.py

@@ -0,0 +1,37 @@
+from functools import lru_cache
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import download_lookup, column_name
+from hestia_earth.utils.tools import non_empty_list
+
+from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.background_emissions import convert_background_lookup
+
+_LOOKUP_INDEX_KEY = column_name('ecoalimMappingName')
+
+
+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 extract_input_mapping(mapping: tuple, term_type: TermTermType):
+    gadm_id, mapping_name = mapping
+    # # all countries have the same coefficient
+    coefficient = 1
+    values = ecoalim_values(mapping_name, term_type)
+    return values, coefficient
+
+
+@lru_cache()
+def _build_lookup(term_type: str):
+    lookup = download_lookup(f"ecoalim-{term_type}.csv", keep_in_memory=False)
+    return convert_background_lookup(lookup=lookup, index_column=_LOOKUP_INDEX_KEY)
+
+
+@lru_cache()
+def ecoalim_values(mapping: str, term_type: TermTermType):
+    data = _build_lookup(term_type.value)
+    return list(data[mapping].items())

hestia_earth_models-0.74.1/hestia_earth/models/ecoinventV3/__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 = 'ecoinventV3'
+PKG = '.'.join(['hestia_earth', 'models', MODEL])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))