hestia-earth-models 0.74.10__py3-none-any.whl → 0.74.12__py3-none-any.whl

hestia_earth/models/hestia/cationExchangeCapacityPerKgSoil.py

@@ -30,8 +30,7 @@ BIBLIO_TITLE = 'Contribution of Organic Matter and Clay to Soil Cation-Exchange
 
 
 def _measurement(site: dict, value: float, depthUpper: int = None, depthLower: int = None):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = [value]
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     if depthUpper is not None:
         data['depthUpper'] = depthUpper
     if depthLower is not None:

hestia_earth/models/hestia/cropResidueManagement.py

@@ -33,8 +33,7 @@ PRACTICE_IDS = [
 
 
 def _practice(term_id: str):
-    practice = _new_practice(term_id, MODEL)
-    practice['value'] = [0]
+    practice = _new_practice(term=term_id, model=MODEL, value=0)
     return practice
 
 

hestia_earth/models/hestia/croppingIntensity.py

@@ -23,15 +23,9 @@ LOOKUPS = {
 TERM_ID = 'croppingIntensity'
 
 
-def _practice(value: float):
-    practice = _new_practice(TERM_ID, MODEL)
-    practice['value'] = [round(value, 7)]
-    return practice
-
-
 def _run(cycle: dict):
     cycleDuration = cycle.get('cycleDuration')
-    return [_practice(cycleDuration / 365)]
+    return [_new_practice(term=TERM_ID, model=MODEL, value=cycleDuration / 365)]
 
 
 def _should_run(cycle: dict):

hestia_earth/models/hestia/default_emissions.py

@@ -1,8 +1,7 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import flatten, safe_parse_float
+from hestia_earth.utils.tools import flatten, safe_parse_float, omit
 
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
-from hestia_earth.models.utils import _omit
 from hestia_earth.models.utils.emission import _new_emission, background_emissions_in_system_boundary
 from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
 from hestia_earth.models.utils.term import get_lookup_value
@@ -38,8 +37,7 @@ TIER = EmissionMethodTier.BACKGROUND.value
 
 
 def _emission(term_id: str, value: float, input: dict):
-    emission = _new_emission(term_id, MODEL)
-    emission['value'] = [value]
+    emission = _new_emission(term=term_id, model=MODEL, value=value)
     emission['inputs'] = [input]
     emission['methodTier'] = TIER
     return emission
@@ -95,7 +93,7 @@ def _should_run(cycle: dict):
         term_id = input.get('input').get('term', {}).get('@id')
 
         logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                        **_omit(input, ['input', 'input-value']))
+                        **omit(input, ['input', 'input-value']))
         logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
 
     return should_run, valid_inputs

hestia_earth/models/hestia/default_resourceUse.py

@@ -1,8 +1,7 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.tools import flatten, safe_parse_float
+from hestia_earth.utils.tools import flatten, safe_parse_float, omit
 
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
-from hestia_earth.models.utils import _omit
 from hestia_earth.models.utils.emission import background_emissions_in_system_boundary
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
@@ -41,13 +40,6 @@ LOOKUPS = {
 MODEL_KEY = 'default_resourceUse'
 
 
-def _indicator(term_id: str, value: float, input: dict, land_cover_id: str):
-    indicator = _new_indicator(term_id, MODEL, land_cover_id)
-    indicator['value'] = value
-    indicator['inputs'] = [input]
-    return indicator
-
-
 def _default_value(input: dict):
     return safe_parse_float(get_lookup_value(input.get('term', {}), LOOKUPS['organicFertiliser']), default=None)
 
@@ -72,7 +64,8 @@ def _run_input(impact: dict, land_cover_id: str):
                         input=term_id)
 
         return [
-            _indicator(term_id, value, input_term, land_cover_id) for term_id in required_resourceUse_term_ids
+            _new_indicator(term=term_id, model=MODEL, value=value, land_cover_id=land_cover_id, inputs=[input_term])
+            for term_id in required_resourceUse_term_ids
         ]
 
     return run
@@ -106,7 +99,7 @@ def _should_run(impact: dict):
         term_id = input.get('input').get('term', {}).get('@id')
 
         logRequirements(impact, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                        **_omit(input, ['input', 'input-value']),
+                        **omit(input, ['input', 'input-value']),
                         landCover_term_id=landCover_term_id)
         logShouldRun(impact, MODEL, term_id, should_run, model_key=MODEL_KEY)
 

hestia_earth/models/hestia/excretaKgMass.py

@@ -36,17 +36,20 @@ UNITS = [
 ]
 
 
-def _product(term_id: str, value: float = None):
-    product = _new_product(term_id, value, MODEL)
-    return product
+def _product(term_id: str, value: float = None): return _new_product(term=term_id, model=MODEL, value=value)
 
 
 def _convert_by_product(cycle: dict, product: dict, term_id: str):
     existing_product = find_term_match(cycle.get('products', []), term_id)
     existing_product_value = list_sum(existing_product.get('value', []), default=None)
 
-    conversion_to_kg_ratio = convert_product_to_unit(product, existing_product.get('term', {}).get('units')) \
-        if existing_product else None
+    conversion_to_kg_ratio = (
+        convert_product_to_unit(
+            product=product,
+            dest_unit=existing_product.get('term', {}).get('units'),
+            log_node=cycle, model=MODEL, term=term_id, model_key=MODEL_KEY
+        ) if existing_product else None
+    )
     value = existing_product_value / conversion_to_kg_ratio if all([
         existing_product_value is not None,
         conversion_to_kg_ratio
@@ -55,7 +58,7 @@ def _convert_by_product(cycle: dict, product: dict, term_id: str):
     debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 using_excreta_product=existing_product.get('term', {}).get('@id'),
                 conversion_to_kg_ratio=conversion_to_kg_ratio,
-                value=value)
+                convert_value=existing_product_value)
 
     return value
 

hestia_earth/models/hestia/excretaKgN.py

@@ -29,23 +29,24 @@ RETURNS = {
 MODEL_KEY = 'excretaKgN'
 
 
-def _product(value: float, term_id: str):
-    product = _new_product(term_id, value, MODEL)
-    return product
+def _product(term_id: str, value: float = None): return _new_product(term=term_id, model=MODEL, value=value)
 
 
 def _run_product(cycle: dict, term_id: str):
     existing_kg_product = find_term_match(cycle.get('products', []), get_kg_term_id(term_id))
-    value = convert_product_to_unit(existing_kg_product, Units.KG_N)
+    value = convert_product_to_unit(
+        product=existing_kg_product,
+        dest_unit=Units.KG_N,
+        log_node=cycle, model=MODEL, term=term_id, model_key=MODEL_KEY
+    )
 
     debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                using_excreta_product=existing_kg_product.get('term', {}).get('@id'),
-                value=value)
+                using_excreta_product=existing_kg_product.get('term', {}).get('@id'))
 
     # use existing product if exist, else create new one
     existing_product = find_term_match(cycle.get('products', []), term_id)
 
-    return (existing_product | _product(value, term_id)) if value else None
+    return (existing_product | _product(term_id, value)) if value else None
 
 
 def _should_run(cycle: dict):

hestia_earth/models/hestia/excretaKgVs.py

@@ -29,23 +29,24 @@ RETURNS = {
 MODEL_KEY = 'excretaKgVs'
 
 
-def _product(value: float, term_id: str):
-    product = _new_product(term_id, value, MODEL)
-    return product
+def _product(term_id: str, value: float = None): return _new_product(term=term_id, model=MODEL, value=value)
 
 
 def _run_product(cycle: dict, term_id: str):
     existing_kg_product = find_term_match(cycle.get('products', []), get_kg_term_id(term_id))
-    value = convert_product_to_unit(existing_kg_product, Units.KG_VS)
+    value = convert_product_to_unit(
+        product=existing_kg_product,
+        dest_unit=Units.KG_VS,
+        log_node=cycle, model=MODEL, term=term_id, model_key=MODEL_KEY
+    )
 
     debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                using_excreta_product=existing_kg_product.get('term', {}).get('@id'),
-                value=value)
+                using_excreta_product=existing_kg_product.get('term', {}).get('@id'))
 
     # use existing product if exist, else create new one
     existing_product = find_term_match(cycle.get('products', []), term_id)
 
-    return (existing_product | _product(value, term_id)) if value else None
+    return (existing_product | _product(term_id, value)) if value else None
 
 
 def _should_run(cycle: dict):

hestia_earth/models/hestia/feedConversionRatio/__init__.py

@@ -23,12 +23,6 @@ MODELS = [
 ]
 
 
-def _practice(term_id: str, value: float):
-    practice = _new_practice(term_id, MODEL)
-    practice['value'] = [value]
-    return practice
-
-
 def _has_no_practice(term_id: str, cycle: dict):
     return find_term_match(cycle.get('practices', []), term_id, None) is None
 
@@ -36,7 +30,11 @@ def _has_no_practice(term_id: str, cycle: dict):
 def _run_model(cycle: dict, kg_liveweight: float, feed: float):
     def exec(model: dict):
         should_run = _has_no_practice(model.TERM_ID, cycle)
-        return _practice(model.TERM_ID, model.run(cycle, feed) / kg_liveweight) if should_run else None
+        return _new_practice(
+            term=model.TERM_ID,
+            model=MODEL,
+            value=model.run(cycle, feed) / kg_liveweight
+        ) if should_run else None
     return exec
 
 

hestia_earth/models/hestia/flowingWater.py

@@ -25,8 +25,7 @@ SITE_TYPE_TO_TERM_ID = {
 
 
 def _measurement(site: dict, term_id: str):
-    data = _new_measurement(term_id, MODEL)
-    data['value'] = [True]
+    data = _new_measurement(term=term_id, model=MODEL, value=True)
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data | get_source(site, BIBLIO_TITLE)
 

hestia_earth/models/hestia/freshWater.py

@@ -22,8 +22,7 @@ TERM_ID = 'freshWater'
 
 
 def _measurement():
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = [True]
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=True)
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data
 

hestia_earth/models/hestia/histosol.py

@@ -30,8 +30,7 @@ TERM_ID = 'histosol'
 
 
 def _measurement():
-    measurement = _new_measurement(TERM_ID)
-    measurement['value'] = [0]
+    measurement = _new_measurement(term=TERM_ID, value=0)
     measurement['depthUpper'] = 0
     measurement['depthLower'] = 30
     measurement['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value

hestia_earth/models/hestia/inorganicFertiliser.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import InputStatsDefinition, TermTermType
+from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type, find_term_match
 from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_float, list_sum
 
@@ -69,18 +69,6 @@ VALUE_BY_UNIT = {
 }
 
 
-def _input(term_id: str, value: float, min: float = None, max: float = None):
-    input = _new_input(term_id, MODEL)
-    input['value'] = [value]
-    if min is not None:
-        input['min'] = [min]
-        input['statsDefinition'] = InputStatsDefinition.MODELLED.value
-    if max is not None:
-        input['max'] = [max]
-        input['statsDefinition'] = InputStatsDefinition.MODELLED.value
-    return input
-
-
 def _include_term_ids(term_id: str):
     return non_empty_list((get_term_lookup(term_id, LOOKUPS['inorganicFertiliser'][0]) or '').split(';'))
 
@@ -158,7 +146,7 @@ def _run_input(cycle: dict, input: dict):
             }
         ) if len(max_values) >= 2 else None
 
-        return _input(input_term_id, value, min, max) if value else None
+        return _new_input(term=input_term_id, model=MODEL, value=value, min=min, max=max) if value is not None else None
 
     return list(map(include_input, input_term_ids))
 

hestia_earth/models/hestia/irrigatedTypeUnspecified.py

@@ -29,12 +29,6 @@ TERM_ID = 'irrigatedTypeUnspecified'
 MIN_IRRIGATION_M3 = 250
 
 
-def _practice():
-    practice = _new_practice(TERM_ID, MODEL)
-    practice['value'] = [100]
-    return practice
-
-
 def _should_run(cycle: dict):
     functional_unit = cycle.get('functionalUnit')
     irrigation_value_m3 = get_total_irrigation_m3(cycle)
@@ -60,4 +54,4 @@ def _should_run(cycle: dict):
 
 def run(cycle: dict):
     should_run = _should_run(cycle)
-    return [_practice()] if should_run else []
+    return [_new_practice(term=TERM_ID, model=MODEL, value=100)] if should_run else []