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

hestia_earth/models/hestia/landOccupationDuringCycle.py

@@ -66,9 +66,8 @@ class SiteData(NamedTuple):
 
 def _indicator(term_id: str, value: float, land_cover_id: str, country_id: str):
     indicator = _new_indicator(
-        term_id, model=MODEL, land_cover_id=land_cover_id, country_id=country_id
+        term=term_id, model=MODEL, value=value, land_cover_id=land_cover_id, country_id=country_id
     )
-    indicator['value'] = round(value, 6)
     return indicator
 
 

hestia_earth/models/hestia/liveAnimal.py

@@ -45,9 +45,7 @@ MODEL_KEY = 'liveAnimal'
 VALID_SITE_TYPES = [SiteSiteType.ANIMAL_HOUSING.value, SiteSiteType.PERMANENT_PASTURE.value]
 
 
-def _product(term: str, value: float):
-    product = _new_product(term, value, MODEL)
-    return product
+def _product(term_id: str, value: float = None): return _new_product(term=term_id, model=MODEL, value=value)
 
 
 def _run(term_id: str, product_value: dict, propertyPerHead: float):

hestia_earth/models/hestia/longFallowRatio.py

@@ -21,15 +21,9 @@ RETURNS = {
 TERM_ID = 'longFallowRatio'
 
 
-def _practice(value: float):
-    practice = _new_practice(TERM_ID, MODEL)
-    practice['value'] = [round(value, 7)]
-    return practice
-
-
 def _run(longFallowDuration: float, rotationDuration: float):
     value = rotationDuration / (rotationDuration - longFallowDuration)
-    return [_practice(value)]
+    return [_new_practice(term=TERM_ID, model=MODEL, value=value)]
 
 
 def _should_run(cycle: dict):

hestia_earth/models/hestia/management.py

@@ -3,11 +3,11 @@ from datetime import timedelta, datetime
 from hestia_earth.schema import SchemaType, TermTermType, COMPLETENESS_MAPPING
 from hestia_earth.utils.lookup import column_name, get_table_value, download_lookup
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import safe_parse_float, flatten, is_number, is_boolean
+from hestia_earth.utils.tools import safe_parse_float, flatten, is_number, is_boolean, pick
 from hestia_earth.utils.blank_node import get_node_value
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
-from hestia_earth.models.utils import _include, group_by
+from hestia_earth.models.utils import group_by
 from hestia_earth.models.utils.management import _new_management
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.blank_node import condense_nodes, DatestrFormat, _gapfill_datestr, DatestrGapfillMode
@@ -93,11 +93,17 @@ _PRACTICES_COMPLETENESS_MAPPING = COMPLETENESS_MAPPING.get(SchemaType.PRACTICE.v
 
 
 def management(data: dict):
-    node = _new_management(data.get('id'))
-    node['value'] = data['value']
-    node['endDate'] = _gap_filled_date_only_str(data['endDate'])
-    if data.get('startDate'):
-        node['startDate'] = _gap_filled_date_only_str(date_str=data['startDate'], mode=DatestrGapfillMode.START)
+    start_date = (
+        _gap_filled_date_only_str(date_str=data['startDate'], mode=DatestrGapfillMode.START) if data.get('startDate')
+        else None
+    )
+    node = _new_management(
+        term=data.get('id'),
+        model=MODEL,
+        value=data['value'],
+        end_date=_gap_filled_date_only_str(data['endDate']),
+        start_date=start_date
+    )
     if data.get('properties'):
         node['properties'] = data['properties']
     return node
@@ -186,7 +192,7 @@ def _get_relevant_items(cycle: dict, item_name: str, term_types: List[TermTermTy
     blank_nodes = filter_list_term_type(cycle.get(item_name, []), complete_term_types)
     return [
         _include_with_date_gap_fill(cycle, ["startDate", "endDate"]) |
-        _include(
+        pick(
             _gap_filled_start_date(
                 cycle=cycle,
                 end_date=item.get("endDate") if "endDate" in item else cycle.get("endDate", ""),

hestia_earth/models/hestia/materialAndSubstrate.py

@@ -53,8 +53,7 @@ _SIGNIFICANT_DIGITS = 5
 
 
 def _input(term_id: str, value: float, stats: dict) -> dict:
-    node = _new_input(term_id + _ID_SUFFIX, MODEL)
-    node['value'] = [value]
+    node = _new_input(term=term_id + _ID_SUFFIX, model=MODEL, value=value)
     return node | stats
 
 

hestia_earth/models/hestia/milkYield.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import TermTermType, SiteSiteType, PracticeStatsDefinition
+from hestia_earth.schema import TermTermType, SiteSiteType
 from hestia_earth.utils.model import filter_list_term_type, find_term_match
 from hestia_earth.utils.tools import list_sum
 
@@ -51,19 +51,9 @@ VALID_SITE_TYPES = [
 
 
 def practice(term_id: str, value: float, properties: list, sd: float = None, min: float = None, max: float = None):
-    data = _new_practice(term_id, MODEL)
-    data['value'] = [round(value, 2)]
+    data = _new_practice(term=term_id, model=MODEL, value=value, sd=sd, min=min, max=max)
     if properties:
         data['properties'] = properties
-    if sd is not None:
-        data['sd'] = [round(sd, 2)]
-        data['statsDefinition'] = PracticeStatsDefinition.MODELLED.value
-    if min is not None:
-        data['min'] = [round(min, 2)]
-        data['statsDefinition'] = PracticeStatsDefinition.MODELLED.value
-    if max is not None:
-        data['max'] = [round(max, 2)]
-        data['statsDefinition'] = PracticeStatsDefinition.MODELLED.value
     return data
 
 

hestia_earth/models/hestia/netPrimaryProduction.py

@@ -24,8 +24,7 @@ NPP_Aqua = {TemperatureLevel.LOW: 2, TemperatureLevel.MEDIUM: 4, TemperatureLeve
 
 
 def _measurement(site: dict, value: float):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = [value]
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data | get_source(site, BIBLIO_TITLE)
 

hestia_earth/models/hestia/organicCarbonPerHa.py

@@ -64,8 +64,7 @@ VALID_MEASUREMENT_METHOD_CLASSIFICATIONS = {
 def _measurement(
     site: dict, value: float, depthUpper: Union[int, float], depthLower: Union[int, float], date: Optional[str] = None
 ) -> dict:
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = [value]
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['depthUpper'] = int(depthUpper)
     data['depthLower'] = int(depthLower)
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value

hestia_earth/models/hestia/pToSurfaceWaterAquacultureSystems.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import list_sum, non_empty_list
 
@@ -70,9 +70,7 @@ TIER = EmissionMethodTier.TIER_1.value
 
 
 def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    emission = _new_emission(term=TERM_ID, model=MODEL, value=value)
     emission['methodTier'] = TIER
     return emission
 

hestia_earth/models/hestia/pastureGrass.py

@@ -25,10 +25,9 @@ KEY_TERM_ID = 'genericGrassPlant'
 
 
 def _practice():
-    node = _new_practice(TERM_ID, MODEL)
-    node['value'] = [100]
-    node['key'] = linked_node(download_term(KEY_TERM_ID, TermTermType.LANDCOVER))
-    return node
+    practice = _new_practice(term=TERM_ID, model=MODEL, value=100)
+    practice['key'] = linked_node(download_term(KEY_TERM_ID, TermTermType.LANDCOVER))
+    return practice
 
 
 def _should_run(cycle: dict):

hestia_earth/models/hestia/pastureSystem.py

@@ -32,12 +32,6 @@ MODEL_KEY = 'pastureSystem'
 VALID_SITE_TYPES = [SiteSiteType.PERMANENT_PASTURE.value]
 
 
-def _practice(term_id: str):
-    practice = _new_practice(term_id, MODEL)
-    practice['value'] = [100]
-    return practice
-
-
 def _run(cycle: dict):
     end_date = cycle.get('endDate')
     measurements = cycle.get('site', {}).get('measurements', [])
@@ -48,7 +42,7 @@ def _run(cycle: dict):
                 slope=slope)
     logShouldRun(cycle, MODEL, term_id, True)
 
-    return [_practice(term_id)]
+    return [_new_practice(term=term_id, model=MODEL, value=100)]
 
 
 def _should_run(cycle: dict):

hestia_earth/models/hestia/potentialEvapotranspirationAnnual.py

@@ -26,8 +26,7 @@ MEASUREMENT_ID = 'potentialEvapotranspirationMonthly'
 
 
 def _measurement(value: float, start_date: str, end_date: str):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = [value]
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['startDate'] = start_date
     data['endDate'] = end_date
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value

hestia_earth/models/hestia/potentialEvapotranspirationMonthly.py

@@ -25,8 +25,7 @@ MEASUREMENT_ID = 'potentialEvapotranspirationDaily'
 
 
 def _measurement(value: list, dates: list):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = value
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['dates'] = dates
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data

hestia_earth/models/hestia/precipitationAnnual.py

@@ -26,8 +26,7 @@ MEASUREMENT_ID = 'precipitationMonthly'
 
 
 def _measurement(value: float, start_date: str, end_date: str):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = [value]
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['startDate'] = start_date
     data['endDate'] = end_date
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value

hestia_earth/models/hestia/precipitationMonthly.py

@@ -25,8 +25,7 @@ MEASUREMENT_ID = 'precipitationDaily'
 
 
 def _measurement(value: list, dates: list):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = value
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['dates'] = dates
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data

hestia_earth/models/hestia/rainfallAnnual.py

@@ -26,8 +26,7 @@ MEASUREMENT_ID = 'rainfallMonthly'
 
 
 def _measurement(value: float, start_date: str, end_date: str):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = [value]
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['startDate'] = start_date
     data['endDate'] = end_date
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value

hestia_earth/models/hestia/rainfallMonthly.py

@@ -25,8 +25,7 @@ MEASUREMENT_ID = 'rainfallDaily'
 
 
 def _measurement(value: list, dates: list):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = value
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['dates'] = dates
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data

hestia_earth/models/hestia/residueBurnt.py

@@ -24,12 +24,6 @@ RETURNS = {
 TERM_ID = 'residueBurnt'
 
 
-def _practice(value: float):
-    practice = _new_practice(TERM_ID, MODEL)
-    practice['value'] = [value]
-    return practice
-
-
 def _should_run(cycle: dict):
     crop_residue_incomplete = _is_term_type_incomplete(cycle, TermTermType.CROPRESIDUE)
     products = cycle.get('products', [])
@@ -50,4 +44,4 @@ def _should_run(cycle: dict):
 
 def run(cycle: dict):
     should_run, total, value = _should_run(cycle)
-    return [_practice(value / total * 100)] if should_run else []
+    return [_new_practice(term=TERM_ID, model=MODEL, value=value / total * 100)] if should_run else []

hestia_earth/models/hestia/residueIncorporated.py

@@ -34,12 +34,6 @@ RETURNS = {
 TERM_ID = 'residueIncorporated'
 
 
-def _practice(value: float):
-    practice = _new_practice(TERM_ID, MODEL)
-    practice['value'] = [value]
-    return practice
-
-
 def _should_run(cycle: dict):
     crop_residue_incomplete = _is_term_type_incomplete(cycle, TermTermType.CROPRESIDUE)
     products = cycle.get('products', [])
@@ -63,4 +57,4 @@ def run(cycle: dict):
     # do not try to run if any of the `residueIncorporated` terms ar added
     has_practice = has_residue_incorporated_practice(cycle)
     should_run, total, value = _should_run(cycle) if not has_practice else (False, None, None)
-    return [_practice(value / total * 100)] if should_run else []
+    return [_new_practice(term=TERM_ID, model=MODEL, value=value / total * 100)] if should_run else []

hestia_earth/models/hestia/residueLeftOnField.py

@@ -24,12 +24,6 @@ RETURNS = {
 TERM_ID = 'residueLeftOnField'
 
 
-def _practice(value: float):
-    practice = _new_practice(TERM_ID, MODEL)
-    practice['value'] = [value]
-    return practice
-
-
 def _should_run(cycle: dict):
     crop_residue_incomplete = _is_term_type_incomplete(cycle, TermTermType.CROPRESIDUE)
     products = cycle.get('products', [])
@@ -51,4 +45,4 @@ def _should_run(cycle: dict):
 
 def run(cycle: dict):
     should_run, total, value = _should_run(cycle)
-    return [_practice(value / total * 100)] if should_run else []
+    return [_new_practice(term=TERM_ID, model=MODEL, value=value / total * 100)] if should_run else []

hestia_earth/models/hestia/residueRemoved.py

@@ -45,17 +45,12 @@ RETURNS = {
 TERM_ID = 'residueRemoved'
 
 
-def _practice(value: float):
-    practice = _new_practice(TERM_ID, MODEL)
-    practice['value'] = [value]
-    return practice
-
-
 def _run_by_products(cycle: dict):
     products = cycle.get('products', [])
     aboveGroundCropResidueTotal = list_sum(find_term_match(products, 'aboveGroundCropResidueTotal').get('value'))
     aboveGroundCropResidueRemoved = list_sum(find_term_match(products, 'aboveGroundCropResidueRemoved').get('value'))
-    return [_practice(aboveGroundCropResidueRemoved / aboveGroundCropResidueTotal * 100)]
+    value = aboveGroundCropResidueRemoved / aboveGroundCropResidueTotal * 100
+    return [_new_practice(term=TERM_ID, model=MODEL, value=value)]
 
 
 def _should_run_by_products(cycle: dict):
@@ -91,7 +86,7 @@ def _run_by_practices(cycle: dict):
         for p in cycle.get('practices', [])
         if _is_incorporated_practice(p)
     ])
-    return [_practice(100 - (incorporated_value or 0))]
+    return [_new_practice(term=TERM_ID, model=MODEL, value=100 - (incorporated_value or 0))]
 
 
 def _should_run_by_practices(cycle: dict):

hestia_earth/models/hestia/resourceUse_utils.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.tools import to_precision, list_sum
+from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.blank_node import _gapfill_datestr, DatestrGapfillMode, DatestrFormat, _str_dates_match
@@ -11,26 +11,9 @@ from .utils import LAND_USE_TERMS_FOR_TRANSFORMATION, crop_ipcc_land_use_categor
 from . import MODEL
 
 _MAXIMUM_OFFSET_DAYS = 365 * 2
-_OUTPUT_SIGNIFICANT_DIGITS = 3
 _RESOURCE_USE_TERM_ID = 'landOccupationDuringCycle'
 
 
-def _new_indicator_with_value(
-    term_id: str,
-    land_cover_id: str,
-    previous_land_cover_id: str,
-    value: float
-) -> dict:
-    indicator = _new_indicator(
-        term=term_id,
-        model=MODEL,
-        land_cover_id=land_cover_id,
-        previous_land_cover_id=previous_land_cover_id
-    )
-    indicator["value"] = to_precision(number=value, digits=_OUTPUT_SIGNIFICANT_DIGITS) if value != 0 else 0
-    return indicator
-
-
 def _gap_filled_date_obj(date_str: str) -> datetime:
     return datetime.strptime(
         _gapfill_datestr(datestr=date_str, mode=DatestrGapfillMode.MIDDLE),
@@ -151,8 +134,9 @@ def run_resource_use(
         historic_date_offset=historic_date_offset
     )
     return [
-        _new_indicator_with_value(
-            term_id=term_id,
+        _new_indicator(
+            term=term_id,
+            model=MODEL,
             land_cover_id=i['landCover-id'],
             previous_land_cover_id=i['previous-landCover-id'],
             value=(i['landOccupationDuringCycle'] * i['historical-landUse-change'] / 100) / historic_date_offset

hestia_earth/models/hestia/salineWater.py

@@ -22,8 +22,7 @@ TERM_ID = 'salineWater'
 
 
 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/seed_emissions.py

@@ -4,11 +4,11 @@ from hestia_earth.utils.lookup import (
     download_lookup, column_name, extract_grouped_data_closest_date, find_term_ids_by
 )
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import non_empty_list, flatten, list_sum, safe_parse_float
+from hestia_earth.utils.tools import non_empty_list, flatten, list_sum, safe_parse_float, omit
 from hestia_earth.utils.emission import cycle_emissions_in_system_boundary
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table, debugValues
-from hestia_earth.models.utils import _omit, group_by
+from hestia_earth.models.utils import group_by
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.site import valid_site_type
 from hestia_earth.models.utils.cycle import cycle_end_year
@@ -70,8 +70,7 @@ TIER = EmissionMethodTier.BACKGROUND.value
 
 
 def _emission(term_id: str, value: float, input: dict):
-    emission = _new_emission(term_id, MODEL)
-    emission['value'] = [round(value, 7)]
+    emission = _new_emission(term=term_id, model=MODEL, value=value)
     emission['inputs'] = [input]
     emission['methodTier'] = TIER
     return emission
@@ -284,7 +283,7 @@ def _should_run(cycle: dict):
         logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                         emissions=log_as_table(emissions),
                         emissions_per_group=log_as_table(emissions_per_group),
-                        **_omit(seed_input, 'input'),
+                        **omit(seed_input, 'input'),
                         **logs)
 
         logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
@@ -295,7 +294,7 @@ def _should_run(cycle: dict):
             if not group.get('has-all-emissions') or not should_run:
                 logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY, emission_id=emission_id,
                                 **group,
-                                **_omit(seed_input, 'input'),
+                                **omit(seed_input, 'input'),
                                 **logs)
                 logShouldRun(cycle, MODEL, term_id, False,
                              methodTier=TIER, model_key=MODEL_KEY, emission_id=emission_id)

hestia_earth/models/hestia/slope.py

@@ -0,0 +1,44 @@
+from hestia_earth.utils.model import find_primary_product
+
+from hestia_earth.models.log import logShouldRun
+from hestia_earth.models.utils.measurement import _new_measurement
+from hestia_earth.models.utils.site import related_cycles
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "related": {
+            "Cycle": [{
+                "producst": [{
+                    "@type": "Product",
+                    "primary": "True",
+                    "term.@id": "riceGrainInHuskFlooded"
+                }]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Measurement": [{
+        "value": "0"
+    }]
+}
+TERM_ID = 'slope'
+
+
+def _measurement(): return _new_measurement(term=TERM_ID, model=MODEL, value=0)
+
+
+def _is_valid_product(cycle: dict):
+    return (find_primary_product(cycle) or {}).get('term', {}).get('@id') == 'riceGrainInHuskFlooded'
+
+
+def _run(site: dict):
+    logShouldRun(site, MODEL, TERM_ID, True)
+    return [_measurement()]
+
+
+def run(site: dict):
+    is_relevant_product = any(map(_is_valid_product, related_cycles(site)))
+    # do not log failure when the product is not relevant
+    return _run(site) if is_relevant_product else []

hestia_earth/models/hestia/slopeLength.py

@@ -0,0 +1,44 @@
+from hestia_earth.utils.model import find_primary_product
+
+from hestia_earth.models.log import logShouldRun
+from hestia_earth.models.utils.measurement import _new_measurement
+from hestia_earth.models.utils.site import related_cycles
+from . import MODEL
+
+REQUIREMENTS = {
+    "Site": {
+        "related": {
+            "Cycle": [{
+                "producst": [{
+                    "@type": "Product",
+                    "primary": "True",
+                    "term.@id": "riceGrainInHuskFlooded"
+                }]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Measurement": [{
+        "value": "0"
+    }]
+}
+TERM_ID = 'slopeLength'
+
+
+def _measurement(): return _new_measurement(term=TERM_ID, model=MODEL, value=0)
+
+
+def _is_valid_product(cycle: dict):
+    return (find_primary_product(cycle) or {}).get('term', {}).get('@id') == 'riceGrainInHuskFlooded'
+
+
+def _run(site: dict):
+    logShouldRun(site, MODEL, TERM_ID, True)
+    return [_measurement()]
+
+
+def run(site: dict):
+    is_relevant_product = all(map(_is_valid_product, related_cycles(site)))
+    # do not log failure when the product is not relevant
+    return _run(site) if is_relevant_product else []

hestia_earth/models/hestia/soilMeasurement.py

@@ -32,8 +32,7 @@ STANDARD_DEPTHS = {(0, 30), (0, 50)}
 
 
 def _measurement(value: float, date: str, term_id: str, standard_fields: dict):
-    data = _new_measurement(term_id, MODEL)
-    data["value"] = [value]
+    data = _new_measurement(term=term_id, model=MODEL, value=value)
     data["depthUpper"] = standard_fields["depthUpper"]
     data["depthLower"] = standard_fields["depthLower"]
     data["methodClassification"] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value

hestia_earth/models/hestia/stockingDensityAnimalHousingAverage.py

@@ -27,18 +27,12 @@ LOOKUPS = {
 TERM_ID = 'stockingDensityAnimalHousingAverage'
 
 
-def _practice(value: float):
-    practice = _new_practice(TERM_ID, MODEL)
-    practice['value'] = [round(value, 7)]
-    return practice
-
-
 def _run(values: list):
     # take a weighted average
     value = weighted_average([
         (p.get('lookup'), p.get('value')) for p in values
     ])
-    return [_practice(value)]
+    return [_new_practice(term=TERM_ID, model=MODEL, value=value)]
 
 
 def _should_run(cycle: dict):

hestia_earth/models/hestia/temperatureAnnual.py

@@ -26,8 +26,7 @@ MEASUREMENT_ID = 'temperatureMonthly'
 
 
 def _measurement(value: float, start_date: str, end_date: str):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = [value]
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['startDate'] = start_date
     data['endDate'] = end_date
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value

hestia_earth/models/hestia/temperatureMonthly.py

@@ -25,8 +25,7 @@ MEASUREMENT_ID = 'temperatureDaily'
 
 
 def _measurement(value: list, dates: list):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = value
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['dates'] = dates
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     return data

hestia_earth/models/hestia/totalNitrogenPerKgSoil.py

@@ -25,8 +25,7 @@ BIBLIO_TITLE = 'Reducing food’s environmental impacts through producers and co
 
 
 def _measurement(site: dict, value: float):
-    data = _new_measurement(TERM_ID, MODEL)
-    data['value'] = [value]
+    data = _new_measurement(term=TERM_ID, model=MODEL, value=value)
     data['depthUpper'] = 0
     data['depthLower'] = 50
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value

hestia_earth/models/hestia/unknownPreSeasonWaterRegime.py

@@ -27,12 +27,6 @@ RETURNS = {
 TERM_ID = 'unknownPreSeasonWaterRegime'
 
 
-def _practice():
-    practice = _new_practice(TERM_ID, MODEL)
-    practice['value'] = [100]
-    return practice
-
-
 def _should_run(cycle: dict):
     practices = cycle.get('practices', [])
     flooded_terms = get_flooded_pre_season_terms()
@@ -47,4 +41,4 @@ def _should_run(cycle: dict):
 
 
 def run(cycle: dict):
-    return [_practice()] if _should_run(cycle) else []
+    return [_new_practice(term=TERM_ID, model=MODEL, value=100)] if _should_run(cycle) else []