hestia-earth-models 0.68.1__py3-none-any.whl → 0.69.0__py3-none-any.whl

hestia_earth/models/transformation/input/properties.py

@@ -1,9 +1,3 @@
-"""
-Input Properties
-
-This model copies the [Product properties](https://hestia.earth/schema/Product#properties) of the Cycle
-to the first transformations [inputs](https://hestia.earth/schema/Transformation#inputs).
-"""
 from hestia_earth.schema import NodeType
 from hestia_earth.utils.tools import non_empty_list
 

hestia_earth/models/transformation/input/sd.py

@@ -1,11 +1,3 @@
-"""
-Input Value
-
-This model calculates the [Input sd](https://hestia.earth/schema/Input#sd)
-by taking the sd of the same [Product](https://hestia.earth/schema/Product) of the
-previous Transformation (or Cycle if first Transformation) and applying the
-[share](https://hestia.earth/schema/Transformation/transformedShare).
-"""
 from functools import reduce
 from hestia_earth.schema import NodeType
 

hestia_earth/models/transformation/input/value.py

@@ -1,11 +1,3 @@
-"""
-Input Value
-
-This model calculates the [Input value](https://hestia.earth/schema/Input#value)
-by taking the value of the same [Product](https://hestia.earth/schema/Product) of the
-previous Transformation (or Cycle if first Transformation) and applying the
-[share](https://hestia.earth/schema/Transformation/transformedShare).
-"""
 from functools import reduce
 from hestia_earth.schema import NodeType
 

hestia_earth/models/transformation/product/excreta.py

@@ -1,10 +1,3 @@
-"""
-Product Excreta
-
-This model calculates the value of every `Product` by taking the value of the `Input` with the same `term`.
-It also adds other variants of the same `Product` in different `units` (e.g. `kg N`, `kg VS` and `kg`).
-Note: this model also substract `Emissions` for `Input` with `units` = `kg N`.
-"""
 from hestia_earth.schema import SchemaType, TermTermType
 from hestia_earth.utils.tools import list_sum, non_empty_list
 from hestia_earth.utils.model import filter_list_term_type

hestia_earth/models/utils/excretaManagement.py

@@ -1,6 +1,11 @@
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.lookup import column_name, download_lookup, get_table_value
+from hestia_earth.utils.tools import safe_parse_float, list_sum
 
+from hestia_earth.models.log import debugValues, debugMissingLookup, log_as_table
+from . import _filter_list_term_unit
+from .constant import Units
 from .term import get_lookup_value
 
 
@@ -8,3 +13,35 @@ def get_lookup_factor(practices: list, lookup_col: str):
     practices = filter_list_term_type(practices, TermTermType.EXCRETAMANAGEMENT)
     practice = practices[0].get('term', {}) if len(practices) > 0 else None
     return get_lookup_value(practice, lookup_col) if practice else None
+
+
+def _get_nh3_factor(lookup_name: str, term_id: str, input: dict, **log_args):
+    input_term_id = input.get('term', {}).get('@id')
+    value = get_table_value(download_lookup(lookup_name), 'termid', term_id, column_name(input_term_id))
+    debugMissingLookup(lookup_name, 'termid', term_id, input_term_id, value, **log_args)
+    return safe_parse_float(value, None)
+
+
+def get_excreta_inputs_with_factor(cycle: dict, lookup_name: str, excreta_convertion_func, **log_args):
+    practices = filter_list_term_type(cycle.get('practices', []), TermTermType.EXCRETAMANAGEMENT)
+    practice_id = practices[0].get('term', {}).get('@id') if len(practices) > 0 else None
+
+    # total of excreta including the factor
+    excreta_inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.EXCRETA)
+    excreta_inputs = _filter_list_term_unit(excreta_inputs, Units.KG_N)
+    excreta_values = [
+        (
+            i.get('term', {}).get('@id'),
+            excreta_convertion_func([i]),
+            _get_nh3_factor(lookup_name, practice_id, i, **log_args)
+        ) for i in excreta_inputs
+    ]
+    excreta_logs = log_as_table([
+        {'id': id, 'value': v, 'EF': ef} for id, v, ef in excreta_values
+    ])
+    has_excreta_EF_inputs = len(excreta_values) > 0
+    debugValues(cycle, **log_args,
+                practice_id=practice_id,
+                has_excreta_EF_inputs=has_excreta_EF_inputs,
+                excreta=excreta_logs)
+    return list_sum([v * f for id, v, f in excreta_values if v is not None and f is not None], 0)

hestia_earth/models/utils/lookup.py

@@ -1,3 +1,4 @@
+import functools
 from typing import Optional, List
 from hestia_earth.utils.lookup import (
     download_lookup,
@@ -125,6 +126,7 @@ def fallback_country(country_id: str, lookups: List[str]) -> str:
     return country_id if country_id and is_in_lookup(country_id) else fallback_id if is_in_lookup(fallback_id) else None
 
 
+@functools.cache
 def get_region_lookup_value(lookup_name: str, term_id: str, column: str, **log_args):
     # for performance, try to load the region specific lookup if exists
     lookup = (

hestia_earth/models/utils/practice.py

@@ -1,7 +1,7 @@
 from hestia_earth.schema import SchemaType
 from hestia_earth.utils.model import linked_node
 
-from .term import get_lookup_value, download_term
+from .term import download_term
 from .method import include_model
 
 
@@ -9,29 +9,3 @@ def _new_practice(term, model=None):
     node = {'@type': SchemaType.PRACTICE.value}
     node['term'] = linked_node(term if isinstance(term, dict) else download_term(term))
     return include_model(node, model)
-
-
-def is_model_enabled(model: str, term_id: str, practice: dict = None):
-    """
-    Verify if the model + term_id group is allowed for that practice.
-
-    Parameters
-    ----------
-    model : str
-        The name of the `methodModel`.
-    term_id : str
-        The name of the `term`.
-    practice : dict
-        The `Practice`.
-
-    Returns
-    -------
-    bool
-        If the model is allowed for that particular model and term_id.
-    """
-    def get_value():
-        term = practice.get('term', {})
-        value = get_lookup_value(term, term_id) or ''
-        return model in value.split(';')
-
-    return get_value() if practice else False

hestia_earth/models/utils/source.py

@@ -4,7 +4,7 @@ import re
 from hestia_earth.schema import SchemaType
 from hestia_earth.utils.api import find_node_exact, search
 from hestia_earth.utils.model import linked_node
-from hestia_earth.utils.tools import flatten
+from hestia_earth.utils.tools import flatten, non_empty_list
 
 from . import cached_value
 
@@ -17,23 +17,43 @@ def _find_source(biblio_title: str = None):
     return None if source is None else linked_node({'@type': SchemaType.SOURCE.value, **source})
 
 
-def get_source(node: dict, biblio_title: str = None):
+def get_source(node: dict, biblio_title: str = None, other_biblio_titles: list = []):
     source = cached_value(node, CACHE_SOURCES_KEY, {}).get(biblio_title) or _find_source(biblio_title)
-    return {'source': source} if source else {}
+    other_sources = non_empty_list([
+        (cached_value(node, CACHE_SOURCES_KEY, {}).get(title) or _find_source(title))
+        for title in other_biblio_titles
+    ])
+    return (
+        {'source': source} if source else {}
+    ) | (
+        {'otherSources': other_sources} if other_sources else {}
+    )
 
 
 def _extract(content: str):
-    return [str(m) for m in re.findall(r'BIBLIO_TITLE = \'.*\'', content)]
-
-
-def _clean(title: str): return title.replace("BIBLIO_TITLE = ", '').replace("'", '')
+    return [
+        str(m).replace("BIBLIO_TITLE = ", '').replace("'", '')
+        for m in re.findall(r'BIBLIO_TITLE = \'[^\']*\'', content)
+    ] + flatten([
+        str(m).replace(
+            "OTHER_BIBLIO_TITLES = [", ''
+        ).replace(
+            '  ', ''
+        ).replace(
+            "'", ''
+        ).replace(
+            "]", ''
+        ).replace(
+            '# noqa: E501', ''
+        ).split(',')
+        for m in re.findall(r'OTHER_BIBLIO_TITLES = \[[^[]*\]', content)
+    ])
 
 
 def _list_sources():
     dir = pathlib.Path(ROOT_DIR)
     files = list(dir.rglob('**/*.py'))
-    sources = list(set(flatten([_extract(open(f, 'r').read()) for f in files])))
-    return list(map(_clean, sources))
+    return list(set(flatten([_extract(open(f, 'r').read().replace('\n', '')) for f in files])))
 
 
 def find_sources():

hestia_earth/models/version.py

@@ -1 +1 @@
-VERSION = '0.68.1'
+VERSION = '0.69.0'

hestia_earth/orchestrator/strategies/run/add_blank_node_if_missing.py

@@ -1,4 +1,6 @@
+from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.lookup_utils import is_node_type_allowed
+from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.orchestrator.log import debugValues, logShouldRun
 from hestia_earth.orchestrator.utils import get_required_model_param, find_term_match
@@ -16,7 +18,7 @@ def _run_required(data: dict, model: str, term_id: str):
 
 _RUN_FROM_ARGS = {
     'runNonAddedTerm': lambda node: 'term' not in node.get('added', []),
-    'runNonMeasured': lambda node: node.get('methodTier') != 'measured'
+    'runNonMeasured': lambda node: node.get('methodTier') != EmissionMethodTier.MEASURED.value
 }
 
 
@@ -31,12 +33,14 @@ def _run_aggregated(data: dict, skip_aggregated: bool = False):
     return not data.get('aggregated', False) or not skip_aggregated
 
 
-def _is_0_emission(node: dict):
-    # emissions are set to 0 when not required to run, but we should still run for every model
+def _is_0_not_relevant_emission(node: dict):
+    # emissions are set to 0 when not relevant, but we should still run for subsequent models
     return node is not None and all([
         node.get('@type', node.get('type')) == 'Emission',
-        'value' in node.get('added', [])
-    ]) and node.get('value', [])[0] == 0
+        'value' in node.get('added', []),
+        list_sum(node.get('value') or [], -1) == 0,
+        node.get('methodTier') == EmissionMethodTier.NOT_RELEVANT.value
+    ])
 
 
 def should_run(data: dict, model: dict):
@@ -47,20 +51,20 @@ def should_run(data: dict, model: dict):
 
     # run if: value is empty or force run from args
     is_empty = _is_empty(node, args.get('skipEmptyValue', False))
-    is_0_emission = _is_0_emission(node)
+    is_0_not_relevant_emission = _is_0_not_relevant_emission(node)
     run_is_aggregated = _run_aggregated(data, args.get('skipAggregated', False))
     run_args = {
         key: func(node) for key, func in _RUN_FROM_ARGS.items() if node and args.get(key, False) is True
     }
     run = any([
         is_empty,
-        is_0_emission,
+        is_0_not_relevant_emission,
         (len(run_args.keys()) > 0 and all([v for _k, v in run_args.items()]))
     ]) and _run_required(data, model.get('model'), term_id) and run_is_aggregated
 
     logShouldRun(data, model.get('model'), term_id, run, key=key, value=term_id,
                  is_empty=is_empty,
-                 is_0_emission=is_0_emission,
+                 is_0_not_relevant_emission=is_0_not_relevant_emission,
                  run_is_aggregated=run_is_aggregated,
                  **run_args)
 

{hestia_earth_models-0.68.1.dist-info → hestia_earth_models-0.69.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.68.1
+Version: 0.69.0
 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
@@ -11,7 +11,7 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: hestia-earth-schema==30.*
+Requires-Dist: hestia-earth-schema==31.*
 Requires-Dist: hestia-earth-utils>=0.14.0
 Requires-Dist: python-dateutil>=2.8.1
 Requires-Dist: CurrencyConverter==0.16.8