hestia-earth-models 0.67.0__py3-none-any.whl → 0.68.0__py3-none-any.whl

hestia_earth/models/site/management.py

@@ -185,7 +185,7 @@ def _gap_filled_start_date(land_cover_id: str, end_date: str, cycle: dict) -> di
     cycle_duration = _get_cycle_duration(cycle, land_cover_id)
     return {
         "startDate": max(
-            _gap_filled_date_obj(end_date) - timedelta(days=cycle_duration)
+            _gap_filled_date_obj(end_date) - timedelta(days=cycle_duration - 1)
             if cycle_duration else datetime.fromtimestamp(0),
             _gap_filled_date_obj(cycle.get("startDate"), mode=DatestrGapfillMode.START)
             if cycle.get("startDate") else datetime.fromtimestamp(0)

hestia_earth/models/site/post_checks/__init__.py

@@ -2,13 +2,14 @@ from os.path import dirname, abspath
 import sys
 
 from hestia_earth.models.utils import _run_in_serie
-from . import cache
+from . import cache, country
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
 
 MODELS = [
-    cache.run
+    cache.run,
+    country.run
 ]
 
 

hestia_earth/models/site/post_checks/country.py

@@ -0,0 +1,9 @@
+"""
+Post Checks Country
+
+Stores a simpler version of the country as originally set on the Site.
+"""
+from hestia_earth.utils.model import linked_node
+
+
+def run(site: dict): return site | {'country': linked_node(site.get('country'))}

hestia_earth/models/site/pre_checks/__init__.py

@@ -2,7 +2,7 @@ from os.path import dirname, abspath
 import sys
 
 from hestia_earth.models.utils import _run_in_serie
-from . import cache_years, cache_geospatialDatabase, cache_sources
+from . import cache_years, cache_geospatialDatabase, cache_sources, country
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
@@ -10,7 +10,8 @@ sys.path.append(CURRENT_DIR)
 MODELS = [
     cache_years.run,
     cache_geospatialDatabase.run,
-    cache_sources.run
+    cache_sources.run,
+    country.run
 ]
 
 

hestia_earth/models/site/pre_checks/country.py

@@ -0,0 +1,9 @@
+"""
+Pre Checks Country
+
+Load the complete country data from HESTIA to be able to use `subClassOf` for example.
+"""
+from hestia_earth.utils.api import download_hestia
+
+
+def run(site: dict): return site | {'country': download_hestia(site.get('country', {}).get('@id'))}

hestia_earth/models/utils/__init__.py

@@ -8,10 +8,9 @@ import datetime
 from functools import reduce
 import operator
 from pydash.objects import get
-from typing import Any, Callable, Union
+from typing import Any, Callable
 from hestia_earth.schema import SchemaType
 from hestia_earth.utils.api import download_hestia
-from hestia_earth.utils.model import linked_node
 from hestia_earth.utils.tools import flatten, non_empty_list
 from hestia_earth.utils.date import is_in_days, is_in_months
 
@@ -44,20 +43,6 @@ def _omit(values: dict, keys: list) -> dict: return {k: v for k, v in values.ite
 def _include(value: dict, keys: list) -> dict: return {k: v for k, v in value.items() if k in keys}
 
 
-def _include_model(node: dict, term_id: str):
-    term = download_hestia(term_id) or {}
-    return {**node, **({} if term.get('@id') is None else {'model': linked_node(term)})}
-
-
-def _include_method(node: dict, term_id: Union[None, str, dict], key='method'):
-    term = (download_hestia(term_id) or {}) if isinstance(term_id, str) else term_id
-    return node | ({} if term is None or term.get('@id') is None else {key: linked_node(term)})
-
-
-def _include_methodModel(node: dict, term_id: str):
-    return _include_method(node, term_id=term_id, key='methodModel')
-
-
 def _run_in_serie(data: dict, models: list): return reduce(lambda prev, model: model(prev), models, data)
 
 

hestia_earth/models/utils/blank_node.py

@@ -12,38 +12,48 @@ from typing import (
     Optional,
     Union
 )
-
 from dateutil import parser
 from dateutil.relativedelta import relativedelta
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.blank_node import ArrayTreatment, get_node_value
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import (
     flatten,
     list_sum,
+    list_average,
     safe_parse_date,
     safe_parse_float,
     non_empty_list
 )
-
-from . import is_from_model, _filter_list_term_unit, is_iterable, full_date_str
-from .constant import Units, get_atomic_conversion
-from .lookup import (
+from hestia_earth.utils.lookup_utils import (
     is_model_siteType_allowed,
     is_siteType_allowed,
-    is_product_id_allowed, is_product_termType_allowed,
-    is_input_id_allowed, is_input_termType_allowed, _node_value
+    is_product_id_allowed,
+    is_product_termType_allowed,
+    is_input_id_allowed,
+    is_input_termType_allowed
 )
+
+from hestia_earth.models.log import debugValues, log_as_table
+from . import is_from_model, _filter_list_term_unit, is_iterable, full_date_str
+from .constant import Units, get_atomic_conversion
+from .lookup import _node_value
 from .property import get_node_property, get_node_property_value
-from .term import get_lookup_value
-from ..log import debugValues, log_as_table
+from .term import get_lookup_value, download_term
 
 # TODO: verify those values
 MAX_DEPTH = 1000
 OLDEST_DATE = '1800'
 
 
+def group_by_term(values: list):
+    def group_by(groups: dict, value: dict):
+        key = value.get('term', {}).get('@id')
+        groups[key] = groups.get(key, []) + [value]
+        return groups
+    return reduce(group_by, values, {})
+
+
 def merge_blank_nodes(source: list, new_values: list):
     """
     Merge a list of blank nodes into an existing list of blank nodes.
@@ -114,29 +124,29 @@ def _module_term_id(term_id: str, module):
     return getattr(module, 'TERM_ID', term_id_str).split(',')[0]
 
 
-def _run_model_required(model: str, term: dict, data: dict):
-    siteType_allowed = is_model_siteType_allowed(model, term, data)
+def _run_model_required(model: str, term_id: str, data: dict):
+    siteType_allowed = is_model_siteType_allowed(model, term_id, data)
 
     run_required = all([siteType_allowed])
-    debugValues(data, model=model, term=term.get('@id'),
+    debugValues(data, model=model, term=term_id,
                 run_required=run_required,
                 siteType_allowed=siteType_allowed)
     return run_required
 
 
-def _run_required(model: str, term: dict, data: dict):
-    siteType_allowed = is_siteType_allowed(data, term)
-    product_id_allowed = is_product_id_allowed(data, term)
-    product_termType_allowed = is_product_termType_allowed(data, term)
-    input_id_allowed = is_input_id_allowed(data, term)
-    input_termType_allowed = is_input_termType_allowed(data, term)
+def _run_required(model: str, term_id: str, data: dict):
+    siteType_allowed = is_siteType_allowed(data, term_id)
+    product_id_allowed = is_product_id_allowed(data, term_id)
+    product_termType_allowed = is_product_termType_allowed(data, term_id)
+    input_id_allowed = is_input_id_allowed(data, term_id)
+    input_termType_allowed = is_input_termType_allowed(data, term_id)
 
     run_required = all([
         siteType_allowed, product_id_allowed, product_termType_allowed, input_id_allowed, input_termType_allowed
     ])
     # model is only used for logs here, skip logs if model not provided
     if model:
-        debugValues(data, model=model, term=term.get('@id'),
+        debugValues(data, model=model, term=term_id,
                     siteType_allowed=siteType_allowed,
                     product_id_allowed=product_id_allowed,
                     product_termType_allowed=product_termType_allowed,
@@ -144,7 +154,7 @@ def _run_required(model: str, term: dict, data: dict):
                     input_termType_allowed=input_termType_allowed)
         # logging this for the model would cause issues parsing statuses
         if model != 'emissionNotRelevant':
-            debugValues(data, model=model, term=term.get('@id'), run_required=run_required)
+            debugValues(data, model=model, term=term_id, run_required=run_required)
     return run_required
 
 
@@ -166,10 +176,9 @@ def is_run_required(model: str, term_id: str, node: dict):
     bool
         True if the model is required to run.
     """
-    term = download_hestia(term_id)
     return (
-        (_run_model_required(model, term, node) if model else True) and _run_required(model, term, node)
-    ) if term else True
+        (_run_model_required(model, term_id, node) if model else True) and _run_required(model, term_id, node)
+    ) if term_id else True
 
 
 def run_if_required(model: str, term_id: str, data: dict, module):
@@ -1271,7 +1280,7 @@ def get_inputs_from_properties(input: dict, term_types: Union[TermTermType, List
     properties = (
         input.get('properties') or
         input.get('term', {}).get('defaultProperties') or
-        download_hestia(input.get('term', {}).get('@id')).get('defaultProperties')
+        download_term(input.get('term', {})).get('defaultProperties')
     )
     inputs = non_empty_list([
         {
@@ -1335,11 +1344,14 @@ def _node_from_group(nodes: list):
     # `nodes` contain list with consecutive dates
     return nodes[0] if len(nodes) == 1 else (
         # if all nodes have the same dates, sum up the values
-        nodes[0] | {'value': _sum_nodes_value(nodes)} if _same_dates(nodes)
-        else nodes[0] | {
-            'startDate': min(n.get('startDate') for n in nodes),
-            'endDate': max(n.get('endDate') for n in nodes)
-        }
+        nodes[0] | (
+            {
+                'value': _sum_nodes_value(nodes)
+            } if _same_dates(nodes) else {
+                'startDate': min(n.get('startDate') for n in nodes),
+                'endDate': max(n.get('endDate') for n in nodes)
+            }
+        )
     )
 
 
@@ -1349,7 +1361,7 @@ def _condense_nodes(nodes: list):
     return flatten(map(_node_from_group, grouped_nodes))
 
 
-def _group_nodes_to_condense(nodes: list) -> dict:
+def _group_nodes_by_value_and_properties(nodes: list) -> dict:
     def _group_node(group: dict, node: dict):
         value = node.get('value', [])
         value = '-'.join(map(str, value if isinstance(value, list) else [value]))
@@ -1359,7 +1371,6 @@ def _group_nodes_to_condense(nodes: list) -> dict:
                 f"{p.get('value')}"
             ])) for p in node.get('properties', [])
         ]))
-        # group by term, value, and properties
         group_key = '-'.join(non_empty_list([
             node.get('term', {}).get('@id', ''),
             value,
@@ -1371,8 +1382,51 @@ def _group_nodes_to_condense(nodes: list) -> dict:
     return reduce(_group_node, nodes, {})
 
 
+def _group_nodes_by_dates(nodes: list) -> dict:
+    def _group_node(group: dict, node: dict):
+        group_key = '-'.join(non_empty_list([
+            node.get('term', {}).get('@id', ''),
+            node.get('startDate'),
+            node.get('endDate'),
+        ]))
+        group[group_key] = group.get(group_key, []) + [node]
+        return group
+
+    return reduce(_group_node, nodes, {})
+
+
+def _average_properties(properties: list):
+    # group properties by term
+    grouped_properties = group_by_term(properties)
+    return [
+        props[0] | {
+            'value': list_average(non_empty_list([p.get('value') for p in props]), default=props[0].get('value'))
+        }
+        for props in grouped_properties.values()
+    ]
+
+
+def _merge_same_dates(nodes: list):
+    # group by term, startDate and endDate
+    grouped_nodes = _group_nodes_by_dates(nodes)
+
+    def merge_nodes(nodes: list):
+        properties = flatten([n.get('properties', []) for n in nodes])
+        return nodes[0] | (
+            {
+                'value': _sum_nodes_value(nodes)
+            } | ({
+                'properties': _average_properties(properties)
+            } if properties else {})
+        ) if len(nodes) > 1 else nodes[0]
+
+    return list(map(merge_nodes, grouped_nodes.values()))
+
+
 def condense_nodes(nodes: list) -> list:
-    grouped_nodes = _group_nodes_to_condense(nodes)
+    # merge nodes with the same term and dates as they need to be unique
+    values = _merge_same_dates(nodes)
+    grouped_nodes = _group_nodes_by_value_and_properties(values)
     return flatten(map(_condense_nodes, grouped_nodes.values()))
 
 
@@ -1446,13 +1500,13 @@ def most_relevant_blank_node_by_id(nodes: list, term_id: str, date: str):
 PROPERTY_UNITS_CONVERSIONS = {
     Units.KG.value: {
         Units.MJ.value: [
-            'energyContentHigherHeatingValue',  # "kg" to "mj"
+            'energyContentLowerHeatingValue',  # "kg" to "mj"
         ]
     },
     Units.M3.value: {
         Units.MJ.value: [
             'density',  # "m3" to "kg"
-            'energyContentHigherHeatingValue',  # "kg" to "mj"
+            'energyContentLowerHeatingValue',  # "kg" to "mj"
         ]
     }
 }
@@ -1506,7 +1560,6 @@ def convert_unit_properties(node_value: Union[int, float], node: dict, dest_unit
     Convert a number `node_value` belonging to a term `node`, to unit `to_units` by chaining multiple unit conversions
     together.
     Uses terms properties for the conversion.
-    Uses cached calls to download_hestia() internally for speedup
     Returns None if no conversion possible.
     """
     src_unit = node.get("units") or node.get('term', {}).get('units', "")

hestia_earth/models/utils/completeness.py

@@ -1,6 +1,7 @@
 from typing import Union
 from hestia_earth.schema import Completeness, TermTermType
-from hestia_earth.utils.api import download_hestia
+
+from .term import download_term
 
 completeness_fields = Completeness().required
 
@@ -12,7 +13,7 @@ def _completeness_term_type(cycle: dict, term: Union[str, dict, TermTermType]):
 
 
 def _get_term_type_completeness(cycle: dict, term: Union[str, dict]):
-    term = download_hestia(term) if isinstance(term, str) else term
+    term = download_term(term) if isinstance(term, str) else term
     term_type = term.get('termType') if term else None
     return cycle.get('completeness', {}).get(term_type, False)
 

hestia_earth/models/utils/cycle.py

@@ -1,9 +1,10 @@
 from hestia_earth.schema import CycleFunctionalUnit, SiteSiteType, TermTermType, AnimalReferencePeriod
 from hestia_earth.utils.model import filter_list_term_type, find_term_match, find_primary_product
 from hestia_earth.utils.tools import list_sum, safe_parse_float, safe_parse_date, non_empty_list
+from hestia_earth.utils.lookup_utils import is_siteType_allowed
 
 from ..log import logRequirements, debugValues
-from .lookup import all_factor_value, is_siteType_allowed
+from .lookup import all_factor_value
 from .term import get_lookup_value
 from .property import get_node_property
 from .completeness import _is_term_type_complete
@@ -344,7 +345,7 @@ def is_organic(cycle: dict):
         `True` if the `Cycle` is organic, `False` otherwise.
     """
     practices = filter_list_term_type(cycle.get('practices', []), TermTermType.STANDARDSLABELS)
-    return any([get_lookup_value(p.get('term', {}), 'isOrganic') == 'organic' for p in practices])
+    return next((get_lookup_value(p.get('term', {}), 'isOrganic') == 'organic' for p in practices), False)
 
 
 def is_irrigated(cycle: dict, **log_ars):
@@ -463,9 +464,9 @@ def get_animals_by_period(cycle: dict, period: AnimalReferencePeriod = AnimalRef
     ]
 
 
-def get_allowed_sites(model: str, term_id: str, termType: TermTermType, cycle: dict):
+def get_allowed_sites(model: str, term_id: str, cycle: dict):
     sites = non_empty_list([cycle.get('site', None)]) + cycle.get('otherSites', [])
-    allowed_sites = [s for s in sites if is_siteType_allowed(s, {'@id': term_id, 'termType': termType.value})]
+    allowed_sites = [s for s in sites if is_siteType_allowed(s, term_id)]
     allowed_site_ids = non_empty_list([s.get('@id', s.get('id')) for s in allowed_sites])
     debugValues(cycle, model=model, term=term_id, site_ids=';'.join(allowed_site_ids))
     return allowed_sites

hestia_earth/models/utils/ecoClimateZone.py

@@ -36,8 +36,8 @@ def get_eco_climate_zone_value(node: dict, as_enum: bool = False) -> Union[int,
     Parameters
     ----------
     node : dict
-        A HESTIA [Site](https://www-staging.hestia.earth/schema/Site) or
-        [Cycle](https://www-staging.hestia.earth/schema/Cycle).
+        A HESTIA [Site](https://hestia.earth/schema/Site) or
+        [Cycle](https://hestia.earth/schema/Cycle).
 
     Returns
     -------

hestia_earth/models/utils/emission.py

@@ -1,22 +1,22 @@
 from collections.abc import Iterable
 from typing import Optional, Union
 from hestia_earth.schema import EmissionMethodTier, SchemaType, TermTermType
-from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import linked_node
 
 
-from . import _term_id, _include_methodModel, flatten_args
+from . import flatten_args
+from .term import download_term
 from .blank_node import find_terms_value
+from .method import include_methodModel
 from .constant import Units, get_atomic_conversion
 
-
 EMISSION_METHOD_TIERS = [e.value for e in EmissionMethodTier]
 
 
 def _new_emission(term, model=None):
     node = {'@type': SchemaType.EMISSION.value}
-    node['term'] = linked_node(term if isinstance(term, dict) else download_hestia(_term_id(term)))
-    return _include_methodModel(node, model)
+    node['term'] = linked_node(term if isinstance(term, dict) else download_term(term, TermTermType.EMISSION))
+    return include_methodModel(node, model)
 
 
 def get_nh3_no3_nox_to_n(cycle: dict, nh3_term_id: str, no3_term_id: str, nox_term_id: str, allow_none: bool = False):

hestia_earth/models/utils/feedipedia.py

@@ -1,5 +1,5 @@
 from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name
+from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, lookup_term_ids
 from hestia_earth.utils.tools import non_empty_list, safe_parse_float
 
 from hestia_earth.models.log import logShouldRun
@@ -11,9 +11,9 @@ DRY_MATTER_TERM_ID = 'dryMatter'
 
 def get_feedipedia_properties():
     lookup = download_lookup('property.csv')
-    term_ids = list(lookup.termid)
     term_ids = [
-        term_id for term_id in term_ids if get_table_value(lookup, 'termid', term_id, column_name('feedipediaName'))
+        term_id for term_id in lookup_term_ids(lookup)
+        if get_table_value(lookup, 'termid', term_id, column_name('feedipediaName'))
     ]
     return term_ids
 
@@ -25,7 +25,6 @@ def _should_rescale_by_dm(property_id: str):
 
 
 def _dm_property(term_id: str, property_values: dict, dm_property_values: dict, dry_matter_property: dict):
-    blank_node = _new_property(term_id)
     blank_node_data = {}
     for property_key in property_values.keys():
         new_dm_value = safe_parse_float(dry_matter_property.get(property_key))
@@ -37,7 +36,7 @@ def _dm_property(term_id: str, property_values: dict, dm_property_values: dict,
                 2
             ) if _should_rescale_by_dm(term_id) else old_property_value
             blank_node_data[property_key] = new_value
-    return (blank_node | blank_node_data) if blank_node_data else None
+    return (_new_property(term_id) | blank_node_data) if blank_node_data else None
 
 
 def _map_properties(lookup, term_id: str, column_prefix: str):
@@ -74,7 +73,8 @@ def rescale_properties_from_dryMatter(model: str, node: dict, blank_nodes: list)
         new_properties = non_empty_list([
             exec_property(blank_node, p, dry_matter_property) for p in properties if all([
                 not find_term_match(all_properties, p),
-                p != DRY_MATTER_TERM_ID
+                p != DRY_MATTER_TERM_ID,
+                dry_matter_property
             ])
         ])
         for prop in new_properties:

hestia_earth/models/utils/impact_assessment.py

@@ -1,6 +1,5 @@
 from typing import Optional
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.lookup import download_lookup
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import list_sum, safe_parse_date
 
@@ -131,6 +130,7 @@ def impact_country_value(
     lookup: str,
     group_key: str = None,
     country_fallback: bool = False,
+    default_no_values=None
 ) -> float:
     """
     Calculate the value of the impact based on lookup factors and `site.country.@id`.
@@ -160,19 +160,19 @@ def impact_country_value(
     nodes = filter_list_term_type(impact.get('emissionsResourceUse', []), term_type)
 
     country_id = get_country_id(impact)
-    country_id = fallback_country(country_id, [download_lookup(lookup)]) if country_fallback else country_id
+    country_id = fallback_country(country_id, [lookup]) if country_fallback else country_id
 
     values = list(map(_term_factor_value(model, term_id, lookup, country_id, group_key), nodes))
     debugValues(impact, model=model, term=term_id,
                 values_used=log_as_table(values))
 
-    all_with_factors = all([v.get('coefficient') is not None for v in values if v.get('value') is not None])
+    has_values = len(values) > 0
+    missing_values = set([v.get('id') for v in values if v.get('value') and v.get('coefficient') is None])
+    all_with_factors = not missing_values
     values = [float((v.get('value') or 0) * (v.get('coefficient') or 0)) for v in values]
 
     # fail if some factors are missing
-    return None if not all_with_factors else (
-        list_sum(values) if len(values) > 0 else None
-    )
+    return None if not all_with_factors else (list_sum(values) if has_values else default_no_values)
 
 
 def impact_aware_value(model: str, term_id: str, impact: dict, lookup: str, group_key: str = None) -> float:

hestia_earth/models/utils/indicator.py

@@ -1,15 +1,17 @@
-from hestia_earth.schema import SchemaType
-from hestia_earth.utils.api import download_hestia
+from hestia_earth.schema import SchemaType, TermTermType
 from hestia_earth.utils.model import linked_node
 
-from . import _term_id, _include_methodModel
+from .method import include_methodModel
+from .term import download_term
 
 
 def _new_indicator(term, model=None, land_cover_id: str = None, previous_land_cover_id: str = None):
     node = {'@type': SchemaType.INDICATOR.value}
-    node['term'] = linked_node(term if isinstance(term, dict) else download_hestia(_term_id(term)))
+    node['term'] = linked_node(term if isinstance(term, dict) else download_term(
+        term, TermTermType.CHARACTERISEDINDICATOR)
+    )
     if land_cover_id:
-        node['landCover'] = linked_node(download_hestia(land_cover_id))
+        node['landCover'] = linked_node(download_term(land_cover_id, TermTermType.LANDCOVER))
     if previous_land_cover_id:
-        node['previousLandCover'] = linked_node(download_hestia(previous_land_cover_id))
-    return _include_methodModel(node, model)
+        node['previousLandCover'] = linked_node(download_term(previous_land_cover_id, TermTermType.LANDCOVER))
+    return include_methodModel(node, model)

hestia_earth/models/utils/inorganicFertiliser.py

@@ -1,18 +1,18 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.lookup import column_name, download_lookup, get_table_value, extract_grouped_data
+from hestia_earth.utils.lookup import download_lookup, extract_grouped_data, lookup_term_ids
 from hestia_earth.utils.tools import safe_parse_float
 from hestia_earth.utils.model import filter_list_term_type
 
-from ..log import debugMissingLookup
 from .term import get_lookup_value
 from .fertiliser import get_fertilisers_from_inputs
+from .lookup import get_region_lookup_value
 
 BREAKDOWN_LOOKUP = 'region-inorganicFertiliser-fertGroupingNitrogen-breakdown.csv'
 
 
 def get_terms():
     lookup = download_lookup('inorganicFertiliser.csv', True)
-    return list(lookup.termid)
+    return lookup_term_ids(lookup)
 
 
 def get_term_lookup(term_id: str, col_name: str):
@@ -35,9 +35,7 @@ def get_NH3_emission_factor(term_id: str, soilPh: float, temperature: float):
 
 
 def get_country_breakdown(model: str, term_id: str, country_id: str, col_name: str):
-    lookup = download_lookup(BREAKDOWN_LOOKUP)
-    value = get_table_value(lookup, 'termid', country_id, column_name(col_name))
-    debugMissingLookup(BREAKDOWN_LOOKUP, 'termid', country_id, col_name, value, model=model, term=term_id)
+    value = get_region_lookup_value(BREAKDOWN_LOOKUP, country_id, col_name, model=model, term=term_id)
     return safe_parse_float(value, None)
 
 

hestia_earth/models/utils/input.py

@@ -1,19 +1,20 @@
 from hestia_earth.schema import SchemaType, TermTermType
-from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import find_term_match, linked_node, filter_list_term_type
 from hestia_earth.utils.tools import list_sum, non_empty_list, list_average, flatten
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name
 
-from ..log import logger
-from . import _term_id, _include_model, _filter_list_term_unit, _load_calculated_node
+from hestia_earth.models.log import logger
+from . import _filter_list_term_unit, _load_calculated_node
 from .constant import Units
 from .blank_node import get_total_value, get_total_value_converted, get_lookup_value
+from .term import download_term
+from .method import include_model
 
 
 def _new_input(term, model=None):
     node = {'@type': SchemaType.INPUT.value}
-    node['term'] = linked_node(term if isinstance(term, dict) else download_hestia(_term_id(term)))
-    return _include_model(node, model)
+    node['term'] = linked_node(term if isinstance(term, dict) else download_term(term))
+    return include_model(node, model)
 
 
 def load_impacts(inputs: list):