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

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/utils/product.py

@@ -166,6 +166,12 @@ PRODUCT_UNITS_CONVERSIONS = {
         ],
         Units.KG_VS.value: [
             ('volatileSolidsContent', True)
+        ],
+        Units.KG_P.value: [
+            ('phosphorusContentAsP', True)
+        ],
+        Units.KG_P2O5.value: [
+            ('phosphateContentAsP2O5', True)
         ]
     },
     Units.KG_N.value: {
@@ -175,6 +181,14 @@ PRODUCT_UNITS_CONVERSIONS = {
         Units.KG_VS.value: [
             ('nitrogenContent', False),
             ('volatileSolidsContent', True)
+        ],
+        Units.KG_P.value: [
+            ('nitrogenContent', False),
+            ('phosphorusContentAsP', True)
+        ],
+        Units.KG_P2O5.value: [
+            ('nitrogenContent', False),
+            ('phosphateContentAsP2O5', True)
         ]
     },
     Units.KG_VS.value: {
@@ -215,6 +229,12 @@ PRODUCT_UNITS_CONVERSIONS = {
                 ],
                 True
             )
+        ],
+        Units.KG_P.value: [
+            ('phosphorusContentAsP', True)
+        ],
+        Units.KG_P2O5.value: [
+            ('phosphateContentAsP2O5', True)
         ]
     },
     Units.KG_COLD_CARCASS_WEIGHT.value: {
@@ -225,6 +245,12 @@ PRODUCT_UNITS_CONVERSIONS = {
         Units.KG_COLD_CARCASS_WEIGHT.value: [],
         Units.KG_READY_TO_COOK_WEIGHT.value: [
             ('processingConversionColdCarcassWeightToReadyToCookWeight', True)
+        ],
+        Units.KG_P.value: [
+            ('phosphorusContentAsP', True)
+        ],
+        Units.KG_P2O5.value: [
+            ('phosphateContentAsP2O5', True)
         ]
     },
     Units.KG_COLD_DRESSED_CARCASS_WEIGHT.value: {
@@ -237,6 +263,12 @@ PRODUCT_UNITS_CONVERSIONS = {
         Units.KG_COLD_CARCASS_WEIGHT.value: [],
         Units.KG_READY_TO_COOK_WEIGHT.value: [
             ('processingConversionColdDressedCarcassWeightToReadyToCookWeight', True)
+        ],
+        Units.KG_P.value: [
+            ('phosphorusContentAsP', True)
+        ],
+        Units.KG_P2O5.value: [
+            ('phosphateContentAsP2O5', True)
         ]
     },
     Units.KG_READY_TO_COOK_WEIGHT.value: {
@@ -262,7 +294,13 @@ PRODUCT_UNITS_CONVERSIONS = {
         Units.KG_COLD_DRESSED_CARCASS_WEIGHT.value: [
             ('processingConversionColdDressedCarcassWeightToReadyToCookWeight', False)
         ],
-        Units.KG_READY_TO_COOK_WEIGHT.value: []
+        Units.KG_READY_TO_COOK_WEIGHT.value: [],
+        Units.KG_P.value: [
+            ('phosphorusContentAsP', True)
+        ],
+        Units.KG_P2O5.value: [
+            ('phosphateContentAsP2O5', True)
+        ]
     },
     Units.HEAD.value: {
         Units.KG_LIVEWEIGHT.value: [

hestia_earth/models/utils/property.py

@@ -50,7 +50,12 @@ def find_term_property(term, property: str, default=None) -> dict:
     return find_term_match(props, property, default)
 
 
-def get_node_property(node: dict, property: str, find_default_property: bool = True) -> dict:
+def get_node_property(
+    node: dict,
+    property: str,
+    find_default_property: bool = True,
+    download_from_hestia: bool = False
+) -> dict:
     """
     Get the property by `@id` linked to the Blank Node in the glossary.
 
@@ -66,6 +71,8 @@ def get_node_property(node: dict, property: str, find_default_property: bool = T
         The `term.@id` of the property. Example: `nitrogenContent`.
     find_default_property : bool
         Default to fetching the property from the `defaultProperties` of the `Term`.
+    download_from_hestia : bool
+        Default to downloading the Term from HESTIA.
 
     Returns
     -------
@@ -76,7 +83,9 @@ def get_node_property(node: dict, property: str, find_default_property: bool = T
     return find_term_property(node.get('term', {}), property, {}) if all([
         find_default_property,
         prop is None
-    ]) else (prop or {})
+    ]) else (
+        prop or ({'term': download_term(property, TermTermType.PROPERTY)} if download_from_hestia else {})
+    )
 
 
 def node_has_no_property(term_id: str):
@@ -91,9 +100,8 @@ def node_property_lookup_value(model: str, node_term: dict, prop_id: str, defaul
     # as the lookup table might not exist, we are making sure we return `0` in thise case
     try:
         lookup_name = f"{node_term.get('termType')}-property.csv"
-        lookup = download_lookup(lookup_name)
         term_id = node_term.get('@id')
-        lookup_value = get_table_value(lookup, 'termid', term_id, column_name(prop_id))
+        lookup_value = get_table_value(download_lookup(lookup_name), 'termid', term_id, column_name(prop_id))
         value = extract_grouped_data(lookup_value, 'Avg') if (
             isinstance(lookup_value, str) and 'Avg' in lookup_value
         ) else lookup_value
@@ -104,8 +112,8 @@ def node_property_lookup_value(model: str, node_term: dict, prop_id: str, defaul
 
 
 def get_node_property_value(model: str, node: dict, prop_id: str, default=None, handle_percents=True, **log_args):
-    prop = get_node_property(node, prop_id)
-    term = (prop or {}).get('term') or download_term(prop_id, TermTermType.PROPERTY)
+    prop = get_node_property(node, prop_id, download_from_hestia=True)
+    term = (prop or {}).get('term')
     units = (term or {}).get('units')
     value = prop.get('value') if prop else node_property_lookup_value(model, node.get('term', {}), prop_id, **log_args)
     return default if value is None else (value / 100 if units == '%' and handle_percents else value)

hestia_earth/models/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.70.0
+Version: 0.70.2
 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