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

hestia_earth/models/pooreNemecek2018/utils.py

@@ -31,12 +31,18 @@ def run_products_average(cycle: dict, term_id: str, get_value_func):
     return list_average(values) if should_run else None
 
 
+def _excreta_product_id(data: str, term_id):
+    value = extract_grouped_data(data, term_id) or ''
+    return value.split('|')[0] if '|' in value else value
+
+
 def get_excreta_product_with_ratio(cycle: dict, lookup: str, **log_args):
     product = find_primary_product(cycle) or {}
 
     data = get_lookup_value(product.get('term'), lookup, model=MODEL, **log_args)
 
-    default_product_id = extract_grouped_data(data, 'default')
+    # TODO: handle multiple products delimited by `|`
+    default_product_id = _excreta_product_id(data, 'default')
 
     # find matching practices and assign a ratio for each
     # if no matches, use default id with 100% ratio
@@ -44,7 +50,7 @@ def get_excreta_product_with_ratio(cycle: dict, lookup: str, **log_args):
     practices = [
         {
             'id': practice.get('term', {}).get('@id'),
-            'product-id': extract_grouped_data(data, practice.get('term', {}).get('@id')) or default_product_id,
+            'product-id': _excreta_product_id(data, practice.get('term', {}).get('@id')) or default_product_id,
             'value': list_sum(practice.get('value'))
         }
         for practice in practices

hestia_earth/models/schmidt2007/ch4ToAirWasteTreatment.py

@@ -8,10 +8,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "or": {
-            "products": [{"@type": "Product", "value": "", "term.termType": "waste"}],
-            "completeness.waste": ""
-        }
+        "products": [{"@type": "Product", "value": ""}]
     }
 }
 RETURNS = {

hestia_earth/models/schmidt2007/h2SToAirWasteTreatment.py

@@ -8,10 +8,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "or": {
-            "products": [{"@type": "Product", "value": "", "term.termType": "waste"}],
-            "completeness.waste": ""
-        }
+        "products": [{"@type": "Product", "value": ""}]
     }
 }
 RETURNS = {

hestia_earth/models/schmidt2007/n2OToAirWasteTreatmentDirect.py

@@ -8,10 +8,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "or": {
-            "products": [{"@type": "Product", "value": "", "term.termType": "waste"}],
-            "completeness.waste": ""
-        }
+        "products": [{"@type": "Product", "value": ""}]
     }
 }
 RETURNS = {

hestia_earth/models/schmidt2007/nh3ToAirWasteTreatment.py

@@ -8,10 +8,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "or": {
-            "products": [{"@type": "Product", "value": "", "term.termType": "waste"}],
-            "completeness.waste": ""
-        }
+        "products": [{"@type": "Product", "value": ""}]
     }
 }
 RETURNS = {

hestia_earth/models/utils/background_emissions.py

@@ -0,0 +1,52 @@
+from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import flatten
+
+from . import is_from_model
+
+
+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 no_gap_filled_background_emissions(cycle: dict):
+    emissions = cycle.get('emissions', [])
+
+    def check_input(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')
+
+        return not any([
+            is_from_model(emission)
+            for emission in emissions
+            if all([
+                any([i.get('@id') == input_term_id for i in emission.get('inputs', [])]),
+                emission.get('operation', {}).get('@id') == operation_term_id,
+                emission.get('animal', {}).get('@id') == animal_term_id
+            ])
+        ])
+
+    return check_input

hestia_earth/models/utils/blank_node.py

@@ -27,6 +27,7 @@ from hestia_earth.utils.tools import (
 )
 from hestia_earth.utils.lookup_utils import (
     is_model_siteType_allowed,
+    is_model_product_id_allowed,
     is_siteType_allowed,
     is_product_id_allowed,
     is_product_termType_allowed,
@@ -124,13 +125,16 @@ 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_id: str, data: dict):
+def _run_model_required(model: str, term_id: str, data: dict, skip_logs: bool = False):
     siteType_allowed = is_model_siteType_allowed(model, term_id, data)
+    product_id_allowed = is_model_product_id_allowed(model, term_id, data)
 
-    run_required = all([siteType_allowed])
-    debugValues(data, model=model, term=term_id,
-                run_required=run_required,
-                siteType_allowed=siteType_allowed)
+    run_required = all([siteType_allowed, product_id_allowed])
+    if not skip_logs:
+        debugValues(data, model=model, term=term_id,
+                    run_required=run_required,
+                    siteType_allowed=siteType_allowed,
+                    product_id_allowed=product_id_allowed)
     return run_required
 
 

hestia_earth/models/utils/impact_assessment.py

@@ -3,7 +3,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import list_sum, safe_parse_date
 
-from hestia_earth.models.log import debugValues, log_as_table
+from hestia_earth.models.log import debugValues
 from .lookup import all_factor_value, _term_factor_value, _aware_factor_value, fallback_country
 from .product import find_by_product
 from .site import region_level_1_id
@@ -157,22 +157,22 @@ def impact_country_value(
         The impact total value.
     """
     term_type = TermTermType.RESOURCEUSE.value if 'resourceUse' in lookup else TermTermType.EMISSION.value
-    nodes = filter_list_term_type(impact.get('emissionsResourceUse', []), term_type)
+    blank_nodes = filter_list_term_type(impact.get('emissionsResourceUse', []), term_type)
 
     country_id = get_country_id(impact)
     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))
-
-    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 has_values else default_no_values)
+    return all_factor_value(
+        model=model,
+        term_id=term_id,
+        node=impact,
+        lookup_name=lookup,
+        lookup_col=country_id,
+        blank_nodes=blank_nodes,
+        grouped_key=group_key,
+        default_no_values=None,
+        factor_value_func=_term_factor_value
+    )
 
 
 def impact_aware_value(model: str, term_id: str, impact: dict, lookup: str, group_key: str = None) -> float:
@@ -197,14 +197,23 @@ def impact_aware_value(model: str, term_id: str, impact: dict, lookup: str, grou
     int
         The impact total value.
     """
-    nodes = impact.get('emissionsResourceUse', [])
+    blank_nodes = impact.get('emissionsResourceUse', [])
     site = get_site(impact)
     aware_id = site.get('awareWaterBasinId')
     if aware_id is None:
         return None
-    factors = list(map(_aware_factor_value(model, term_id, lookup, aware_id, group_key), nodes))
-    values = [value for value in factors if value is not None]
-    return list_sum(values) if len(values) > 0 else None
+
+    return all_factor_value(
+        model=model,
+        term_id=term_id,
+        node=impact,
+        lookup_name=lookup,
+        lookup_col=aware_id,
+        blank_nodes=blank_nodes,
+        grouped_key=group_key,
+        default_no_values=None,
+        factor_value_func=_aware_factor_value
+    )
 
 
 def impact_endpoint_value(model: str, term_id: str, impact: dict, lookup_col: str) -> float:

hestia_earth/models/utils/lookup.py

@@ -26,7 +26,8 @@ def _factor_value(model: str, term_id: str, lookup_name: str, lookup_col: str, g
         coefficient = get_region_lookup_value(lookup_name, node_term_id, lookup_col, model=model, term=term_id)
         # value is either a number or matching between a model and a value (restrict value to specific model only)
         coefficient = safe_parse_float(
-            extract_grouped_data(coefficient, grouped_data_key), None
+            extract_grouped_data(coefficient, grouped_data_key),
+            default=None
         ) if ':' in str(coefficient) else safe_parse_float(coefficient, None)
         if value is not None and coefficient is not None:
             if model:
@@ -39,43 +40,15 @@ def _factor_value(model: str, term_id: str, lookup_name: str, lookup_col: str, g
     return get_value
 
 
-def all_factor_value(
-    model: str,
-    term_id: str,
-    node: dict,
-    lookup_name: str,
-    lookup_col: str,
-    blank_nodes: List[dict],
-    grouped_key: Optional[str] = None,
-    default_no_values=0
-):
-    values = list(map(_factor_value(model, term_id, lookup_name, lookup_col, grouped_key), blank_nodes))
-
-    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
-
-    for missing_value in missing_values:
-        debugMissingLookup(lookup_name, 'termid', missing_value, lookup_col, None, model=model, term=term_id)
-
-    debugValues(node, model=model, term=term_id,
-                all_with_factors=all_with_factors,
-                missing_lookup_factor=';'.join(missing_values),
-                has_values=has_values,
-                values_used=log_as_table(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 has_values else default_no_values)
-
-
 def _term_factor_value(model: str, term_id: str, lookup_name: str, lookup_term_id: str, group_key: str = None):
     def get_value(data: dict):
         node_term_id = data.get('term', {}).get('@id')
         value = _node_value(data)
         coefficient = get_region_lookup_value(lookup_name, lookup_term_id, node_term_id, model=model, term=term_id)
-        coefficient = safe_parse_float(extract_grouped_data(coefficient, group_key) if group_key else coefficient)
+        coefficient = safe_parse_float(
+            extract_grouped_data(coefficient, group_key) if group_key else coefficient,
+            default=None
+        )
         if value is not None and coefficient is not None:
             debugValues(data, model=model, term=term_id,
                         node=node_term_id,
@@ -90,23 +63,59 @@ def _aware_factor_value(model: str, term_id: str, lookup_name: str, aware_id: st
     lookup_col = column_name('awareWaterBasinId')
 
     def get_value(data: dict):
+        node_term_id = data.get('term', {}).get('@id')
+        value = _node_value(data)
+
         try:
-            node_term_id = data.get('term', {}).get('@id')
-            value = _node_value(data)
             coefficient = _get_single_table_value(lookup, lookup_col, int(aware_id), column_name(node_term_id))
-            coefficient = safe_parse_float(extract_grouped_data(coefficient, group_key)) if group_key else coefficient
+            coefficient = safe_parse_float(
+                extract_grouped_data(coefficient, group_key),
+                default=None
+            ) if group_key else coefficient
             if value is not None and coefficient is not None:
                 debugValues(data, model=model, term=term_id,
                             node=node_term_id,
                             value=value,
                             coefficient=coefficient)
-                return value * coefficient
-            return None
         except ValueError:  # factor does not exist
-            return None
+            coefficient = None
+
+        return {'id': node_term_id, 'value': value, 'coefficient': coefficient}
     return get_value
 
 
+def all_factor_value(
+    model: str,
+    term_id: str,
+    node: dict,
+    lookup_name: str,
+    lookup_col: str,
+    blank_nodes: List[dict],
+    grouped_key: Optional[str] = None,
+    default_no_values=0,
+    factor_value_func=_factor_value
+):
+    values = list(map(factor_value_func(model, term_id, lookup_name, lookup_col, grouped_key), blank_nodes))
+
+    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
+
+    for missing_value in missing_values:
+        debugMissingLookup(lookup_name, 'termid', missing_value, lookup_col, None, model=model, term=term_id)
+
+    debugValues(node, model=model, term=term_id,
+                all_with_factors=all_with_factors,
+                missing_lookup_factor=';'.join(missing_values),
+                has_values=has_values,
+                values_used=log_as_table(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 has_values else default_no_values)
+
+
 def _country_in_lookup(country_id: str):
     def in_lookup(lookup_name: str):
         return (

hestia_earth/models/utils/measurement.py

@@ -10,7 +10,7 @@ from hestia_earth.utils.date import diff_in_days
 
 from . import flatten_args
 from .blank_node import most_relevant_blank_node_by_id
-from .method import include_methodModel
+from .method import include_method
 from .term import download_term, get_lookup_value
 
 
@@ -26,10 +26,10 @@ MEASUREMENT_REDUCE = {
 MEASUREMENT_METHOD_CLASSIFICATIONS = [e.value for e in MeasurementMethodClassification]
 
 
-def _new_measurement(term, model=None):
+def _new_measurement(term, method=None):
     node = {'@type': SchemaType.MEASUREMENT.value}
     node['term'] = linked_node(term if isinstance(term, dict) else download_term(term))
-    return include_methodModel(node, term_id=model)
+    return include_method(node, term_id=method)
 
 
 def measurement_value(measurement: dict, is_larger_unit: bool = False) -> float:

hestia_earth/models/version.py

@@ -1 +1 @@
-VERSION = '0.70.0'
+VERSION = '0.70.1'

{hestia_earth_models-0.70.0.dist-info → hestia_earth_models-0.70.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.70.0
+Version: 0.70.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
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: hestia-earth-schema==31.*
-Requires-Dist: hestia-earth-utils>=0.14.0
+Requires-Dist: hestia-earth-utils>=0.14.1
 Requires-Dist: python-dateutil>=2.8.1
 Requires-Dist: CurrencyConverter==0.16.8
 Requires-Dist: haversine>=2.7.0