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

hestia_earth/models/{cycle → hestia}/energyContentLowerHeatingValue.py

@@ -28,7 +28,7 @@ DRY_VALUE = 19.2  # Bone dry wood has an energy content of 19.2 MJ/kg
 
 
 def _property(value: float):
-    prop = _new_property(TERM_ID)
+    prop = _new_property(TERM_ID, MODEL)
     prop['value'] = value
     return prop
 

hestia_earth/models/{cycle → hestia}/excretaKgMass.py

@@ -14,6 +14,7 @@ REQUIREMENTS = {
         "products": [
             {
                 "@type": "Product",
+                "value": "",
                 "term.termType": "excreta",
                 "term.units": ["kg N", "kg VS"]
             }
@@ -36,16 +37,20 @@ UNITS = [
 
 
 def _product(value: float, term_id: str):
-    product = _new_product(term_id, value)
+    product = _new_product(term_id, value, MODEL)
     return product
 
 
 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
-    value = list_sum(existing_product.get('value', [])) / conversion_to_kg_ratio if conversion_to_kg_ratio else None
+    value = existing_product_value / conversion_to_kg_ratio if all([
+        existing_product_value is not None,
+        conversion_to_kg_ratio
+    ]) else None
 
     debugValues(cycle, model=MODEL, term=term_id,
                 using_excreta_product=existing_product.get('term', {}).get('@id'),
@@ -65,7 +70,7 @@ def _run_product(cycle: dict, product_term_id: str):
     # convert to 1kg first, then apply ratio to current value
     term = download_term(product_term_id, TermTermType.EXCRETA)
     product = {
-        'term': term,
+        'term': term or {},
         'value': [1]
     }
 

hestia_earth/models/{cycle → hestia}/excretaKgN.py

@@ -30,7 +30,7 @@ MODEL_KEY = 'excretaKgN'
 
 
 def _product(value: float, term_id: str):
-    product = _new_product(term_id, value)
+    product = _new_product(term_id, value, MODEL)
     return product
 
 

hestia_earth/models/{cycle → hestia}/excretaKgVs.py

@@ -30,7 +30,7 @@ MODEL_KEY = 'excretaKgVs'
 
 
 def _product(value: float, term_id: str):
-    product = _new_product(term_id, value)
+    product = _new_product(term_id, value, MODEL)
     return product
 
 

hestia_earth/models/{cycle → hestia}/feedConversionRatio/__init__.py

@@ -24,7 +24,7 @@ MODELS = [
 
 
 def _practice(term_id: str, value: float):
-    practice = _new_practice(term_id)
+    practice = _new_practice(term_id, MODEL)
     practice['value'] = [value]
     return practice
 

hestia_earth/models/{site → hestia}/flowingWater.py

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

hestia_earth/models/{site → hestia}/freshWater.py

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

hestia_earth/models/{cycle → hestia}/inorganicFertiliser.py

@@ -70,7 +70,7 @@ VALUE_BY_UNIT = {
 
 
 def _input(term_id: str, value: float, min: float = None, max: float = None):
-    input = _new_input(term_id)
+    input = _new_input(term_id, MODEL)
     input['value'] = [value]
     if min is not None:
         input['min'] = [min]

hestia_earth/models/{cycle → hestia}/irrigatedTypeUnspecified.py

@@ -1,15 +1,13 @@
-from hestia_earth.schema import TermTermType, CycleFunctionalUnit
+from hestia_earth.schema import CycleFunctionalUnit
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.cycle import is_irrigated
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.input import get_total_irrigation_m3
-from hestia_earth.models.utils.completeness import _is_term_type_complete
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "completeness.water": "",
         "functionalUnit": "1 ha",
         "none": {
             "practices": [{"@type": "Practice", "value": "> 0", "term.termType": "waterRegime"}]
@@ -31,38 +29,35 @@ TERM_ID = 'irrigatedTypeUnspecified'
 MIN_IRRIGATION_M3 = 250
 
 
-def _practice(value: float):
-    practice = _new_practice(TERM_ID)
-    practice['value'] = [value]
+def _practice():
+    practice = _new_practice(TERM_ID, MODEL)
+    practice['value'] = [100]
     return practice
 
 
-def _run(irrigation_m3: float):
-    value = 100 if irrigation_m3 > MIN_IRRIGATION_M3 else 0
-    return [_practice(value)]
-
-
 def _should_run(cycle: dict):
     functional_unit = cycle.get('functionalUnit')
-    water_complete = _is_term_type_complete(cycle, TermTermType.WATER)
     irrigation_value_m3 = get_total_irrigation_m3(cycle)
+    is_1_ha_functional_unit = functional_unit == CycleFunctionalUnit._1_HA.value
 
     no_irrigation_practice = not is_irrigated(cycle, model=MODEL, term=TERM_ID)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     no_irrigation_practice=no_irrigation_practice,
-                    term_type_water_complete=water_complete,
-                    irrigation_value_m3=irrigation_value_m3)
+                    is_1_ha_functional_unit=is_1_ha_functional_unit,
+                    irrigation_value_m3=irrigation_value_m3,
+                    irrigation_min_m3=MIN_IRRIGATION_M3,
+                    is_irrigated=irrigation_value_m3 > MIN_IRRIGATION_M3)
 
     should_run = all([
         no_irrigation_practice,
-        functional_unit == CycleFunctionalUnit._1_HA.value,
-        any([water_complete, irrigation_value_m3 > MIN_IRRIGATION_M3])
+        is_1_ha_functional_unit,
+        irrigation_value_m3 > MIN_IRRIGATION_M3
     ])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, irrigation_value_m3
+    return should_run
 
 
 def run(cycle: dict):
-    should_run, irrigation_m3 = _should_run(cycle)
-    return _run(irrigation_m3) if should_run else []
+    should_run = _should_run(cycle)
+    return [_practice()] if should_run else []

hestia_earth/models/hestia/landCover.py

@@ -11,6 +11,7 @@ from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, to_precision
 
 from hestia_earth.models.log import logRequirements, log_as_table, logShouldRun
+from hestia_earth.models.utils import _omit
 from hestia_earth.models.utils.constant import DAYS_IN_YEAR
 from hestia_earth.models.utils.management import _new_management
 from hestia_earth.models.utils.term import get_lookup_value
@@ -91,6 +92,7 @@ SITE_TYPES = {
 DEFAULT_WINDOW_IN_YEARS = 20
 DATE_TOLERANCE_IN_YEARS = 2
 OUTPUT_SIGNIFICANT_DIGITS = 3
+ALLOWED_LAND_USE_TYPES = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE]
 _LOOKUP_EXPANSION = "region-crop-cropGroupingFaostatProduction-areaHarvestedUpTo20YearExpansion.csv"
 
 
@@ -751,16 +753,21 @@ def _collect_land_use_types(nodes: list) -> list:
     """Look up the land use type from management nodes."""
     return [
         {
+            "value": node.get("value", ""),
+            "term": node.get("term", {}),
             "id": node.get("term", {}).get("@id"),
             "land-use-type": _get_land_use_term_from_node(node),
-            "endDate": _gapfill_datestr(datestr=node.get("endDate"), mode=DatestrGapfillMode.END)[:10]
+            "endDate": _gapfill_datestr(datestr=node.get("endDate"), mode=DatestrGapfillMode.END)[:10],
+            "startDate": _gapfill_datestr(
+                datestr=node.get("startDate"), mode=DatestrGapfillMode.START
+            )[:10] if node.get("startDate") else None
         } for node in nodes
     ]
 
 
-def _no_prior_land_cover_data(nodes: list, end_date: str) -> bool:
+def _no_prior_land_cover_data(nodes: list, node: dict) -> bool:
     target_date = (
-        datetime.strptime(end_date, DatestrFormat.YEAR_MONTH_DAY.value)
+        datetime.strptime(node.get('startDate') or node.get('endDate'), DatestrFormat.YEAR_MONTH_DAY.value)
         - timedelta(days=DEFAULT_WINDOW_IN_YEARS * DAYS_IN_YEAR)
     )
     previous_nodes = [
@@ -770,45 +777,46 @@ def _no_prior_land_cover_data(nodes: list, end_date: str) -> bool:
     return len(previous_nodes) == 0
 
 
-def _should_run(site: dict, management_nodes: list) -> tuple[bool, dict]:
-    summarised_nodes = _collect_land_use_types(management_nodes)
-    allowed_land_use_types = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE]
+def _should_run(site: dict) -> tuple[bool, dict]:
+    management_nodes = _collect_land_use_types(
+        [
+            node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+            if not _should_group_landCover(node)
+        ]
+    )
     relevant_nodes = sorted(
         [
-            node for node in summarised_nodes
-            if node["land-use-type"] in allowed_land_use_types
+            node for node in management_nodes
+            if node["land-use-type"] in ALLOWED_LAND_USE_TYPES
         ],
-        key=lambda n: n.get("endDate")
+        key=lambda n: n.get("startDate") or n.get("endDate")
     )
+
     land_use_type = relevant_nodes[0].get("land-use-type") if relevant_nodes else None
 
     has_no_prior_land_cover_data = _no_prior_land_cover_data(
-        nodes=management_nodes,
-        end_date=relevant_nodes[-1:][0].get("endDate")
+        nodes=relevant_nodes,
+        node=relevant_nodes[-1:][0]
     ) if relevant_nodes else None
 
     should_run_nodes, site_area = _should_run_historical_land_use_change(
         site=site,
-        nodes=management_nodes,
+        nodes=relevant_nodes,
         land_use_type=land_use_type
     ) if all([land_use_type, has_no_prior_land_cover_data]) else (False, {})
 
     logRequirements(site, model=MODEL, model_key=MODEL_KEY,
-                    has_management_nodes=bool(management_nodes),
+                    has_management_nodes=bool(relevant_nodes),
                     land_use_type=land_use_type,
-                    allowed_land_use_types=';'.join(allowed_land_use_types),
+                    allowed_land_use_types=';'.join(ALLOWED_LAND_USE_TYPES),
                     has_no_prior_land_cover_data=has_no_prior_land_cover_data,
-                    summarised_nodes=log_as_table(summarised_nodes))
+                    management_nodes=log_as_table([_omit(n, ['term']) for n in relevant_nodes]))
 
     should_run = all([land_use_type, has_no_prior_land_cover_data, should_run_nodes])
     logShouldRun(site, MODEL, None, should_run, model_key=MODEL_KEY)
-    return should_run_nodes, site_area
+    return should_run_nodes, relevant_nodes, site_area
 
 
 def run(site: dict) -> list:
-    management_nodes = [
-        node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
-        if not _should_group_landCover(node)
-    ]
-    should_run, site_area = _should_run(site=site, management_nodes=management_nodes)
-    return _run(site, management_nodes, site_area) if should_run else []
+    should_run, relevant_nodes, site_area = _should_run(site=site)
+    return _run(site, relevant_nodes, site_area) if should_run else []

hestia_earth/models/{cycle → hestia}/liveAnimal.py

@@ -46,7 +46,7 @@ VALID_SITE_TYPES = [SiteSiteType.ANIMAL_HOUSING.value, SiteSiteType.PERMANENT_PA
 
 
 def _product(term: str, value: float):
-    product = _new_product(term, value)
+    product = _new_product(term, value, MODEL)
     return product
 
 

hestia_earth/models/{cycle → hestia}/longFallowRatio.py

@@ -22,7 +22,7 @@ TERM_ID = 'longFallowRatio'
 
 
 def _practice(value: float):
-    practice = _new_practice(TERM_ID)
+    practice = _new_practice(TERM_ID, MODEL)
     practice['value'] = [round(value, 7)]
     return practice
 

hestia_earth/models/{site → hestia}/management.py

@@ -147,7 +147,7 @@ def _get_cycle_duration(cycle: dict, land_cover_id: str):
         land_cover_id,
         column_name('maximumCycleDuration')
     ), default=None)
-    return cycle_duration or (lookup_value - 1 if lookup_value else None)
+    return cycle_duration or lookup_value
 
 
 def _gap_filled_date_only_str(date_str: str, mode: str = DatestrGapfillMode.END) -> str:
@@ -165,11 +165,9 @@ def _gap_filled_start_date(land_cover_id: str, end_date: str, cycle: dict) -> di
     """If possible, gap-fill the startDate based on the endDate - cycleDuration"""
     cycle_duration = _get_cycle_duration(cycle, land_cover_id)
     return {
-        "startDate": max(
-            _gap_filled_date_obj(end_date) - timedelta(days=cycle_duration)
-            if cycle_duration else datetime.fromtimestamp(0),
-            _gap_filled_date_obj(cycle.get("startDate"), mode=DatestrGapfillMode.START)
-            if cycle.get("startDate") else datetime.fromtimestamp(0)
+        "startDate": (
+            _gap_filled_date_obj(cycle.get("startDate"), mode=DatestrGapfillMode.START) if cycle.get("startDate") else
+            _gap_filled_date_obj(end_date) - timedelta(days=cycle_duration - 1)
         )
     } if any([cycle_duration, cycle.get("startDate")]) else {}
 

hestia_earth/models/{cycle → hestia}/materialAndSubstrate.py

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

hestia_earth/models/{cycle → hestia}/milkYield.py

@@ -51,7 +51,7 @@ 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)
+    data = _new_practice(term_id, MODEL)
     data['value'] = [round(value, 2)]
     if properties:
         data['properties'] = properties

hestia_earth/models/{site → hestia}/netPrimaryProduction.py

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

hestia_earth/models/{site → hestia}/organicCarbonPerHa.py

@@ -64,7 +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)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [value]
     data['depthUpper'] = int(depthUpper)
     data['depthLower'] = int(depthLower)

hestia_earth/models/hestia/pToSurfaceWaterAquacultureSystems.py

@@ -0,0 +1,148 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum, non_empty_list
+
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
+from hestia_earth.models.utils import _filter_list_term_unit
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.constant import Units, convert_to_unit, get_atomic_conversion
+from hestia_earth.models.utils.product import convert_product_to_unit
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.animalFeed": "True",
+        "completeness.product": "True",
+        "completeness.fertiliser": "True",
+        "completeness.liveAnimalInput": "True",
+        "inputs": [
+            {
+                "@type": "Input",
+                "term.termType": [
+                    "crop",
+                    "liveAnimal",
+                    "liveAquaticSpecies",
+                    "animalProduct",
+                    "processedFood",
+                    "feedFoodAdditive",
+                    "organicFertiliser",
+                    "forage",
+                    "excreta",
+                    "waste"
+                ],
+                "optional": {
+                    "properties": [
+                        {"@type": "Property", "value": "", "term.@id": "phosphorusContentAsP"},
+                        {"@type": "Property", "value": "", "term.@id": "phosphateContentAsP2O5"}
+                    ]
+                }
+            },
+            {
+                "@type": "Input",
+                "term.termType": "inorganicFertiliser",
+                "term.units": "kg P2O5"
+            }
+        ],
+        "products": [{
+            "@type": "Product",
+            "term.termType": ["liveAquaticSpecies", "liveAnimal", "animalProduct", "crop"],
+            "optional": {
+                "properties": [
+                    {"@type": "Property", "value": "", "term.@id": "phosphorusContentAsP"},
+                    {"@type": "Property", "value": "", "term.@id": "phosphateContentAsP2O5"}
+                ]
+            }
+        }]
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "min": "",
+        "max": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+TERM_ID = 'pToSurfaceWaterAquacultureSystems'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _emission(value: float):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    emission['methodTier'] = TIER
+    return emission
+
+
+def _convert_to_P(blank_node: dict):
+    return {
+        'id': blank_node.get('term', {}).get('@id'),
+        'value': list_sum(blank_node.get('value'), default=None),
+        'value-converted': (
+            convert_product_to_unit(blank_node, Units.KG_P) or
+            convert_product_to_unit(blank_node, Units.KG_P2O5) / get_atomic_conversion(Units.KG_P2O5, Units.KG_P) or
+            convert_to_unit(blank_node, Units.KG_P)
+        )
+    }
+
+
+def _run(cycle: dict):
+    inputs = filter_list_term_type(cycle.get('inputs', []), [
+        TermTermType.CROP,
+        TermTermType.LIVEANIMAL,
+        TermTermType.LIVEAQUATICSPECIES,
+        TermTermType.ANIMALPRODUCT,
+        TermTermType.PROCESSEDFOOD,
+        TermTermType.FEEDFOODADDITIVE,
+        TermTermType.ORGANICFERTILISER,
+        TermTermType.FORAGE,
+        TermTermType.EXCRETA,
+        TermTermType.WASTE,
+    ]) + _filter_list_term_unit(filter_list_term_type(cycle.get('inputs', []), [
+        TermTermType.INORGANICFERTILISER
+    ]), Units.KG_P2O5)
+    inputs_P = list(map(_convert_to_P, inputs))
+    total_inputs_P = list_sum(non_empty_list([i.get('value-converted', 0) for i in inputs_P]))
+
+    products = filter_list_term_type(cycle.get('products', []), [
+        TermTermType.CROP,
+        TermTermType.LIVEANIMAL,
+        TermTermType.LIVEAQUATICSPECIES,
+        TermTermType.ANIMALPRODUCT
+    ])
+    products_P = list(map(_convert_to_P, products))
+    total_products_P = list_sum(non_empty_list([i.get('value-converted', 0) for i in products_P]))
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                inputs_P=log_as_table(inputs_P),
+                products_P=log_as_table(products_P))
+
+    return [_emission(total_inputs_P - total_products_P)]
+
+
+def _should_run(cycle: dict):
+    is_animalFeed_complete = _is_term_type_complete(cycle, 'animalFeed')
+    is_product_complete = _is_term_type_complete(cycle, 'product')
+    is_fertiliser_complete = _is_term_type_complete(cycle, 'fertiliser')
+    is_liveAnimalInput_complete = _is_term_type_complete(cycle, 'liveAnimalInput')
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_term_type_animalFeed_complete=is_animalFeed_complete,
+                    is_term_type_product_complete=is_product_complete,
+                    is_term_type_fertiliser_complete=is_fertiliser_complete,
+                    is_term_type_liveAnimalInput_complete=is_liveAnimalInput_complete)
+
+    should_run = all([
+        is_animalFeed_complete,
+        is_product_complete,
+        is_fertiliser_complete,
+        is_liveAnimalInput_complete
+    ])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []

hestia_earth/models/{cycle → hestia}/pastureGrass.py

@@ -25,7 +25,7 @@ KEY_TERM_ID = 'genericGrassPlant'
 
 
 def _practice():
-    node = _new_practice(TERM_ID)
+    node = _new_practice(TERM_ID, MODEL)
     node['value'] = [100]
     node['key'] = linked_node(download_term(KEY_TERM_ID, TermTermType.LANDCOVER))
     return node

hestia_earth/models/{cycle → hestia}/pastureSystem.py

@@ -33,7 +33,7 @@ VALID_SITE_TYPES = [SiteSiteType.PERMANENT_PASTURE.value]
 
 
 def _practice(term_id: str):
-    practice = _new_practice(term_id)
+    practice = _new_practice(term_id, MODEL)
     practice['value'] = [100]
     return practice
 

hestia_earth/models/{site → hestia}/potentialEvapotranspirationAnnual.py

@@ -3,7 +3,7 @@ from hestia_earth.utils.tools import flatten, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.measurement import _new_measurement
-from .utils import _slice_by_year
+from .utils import slice_by_year
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ MEASUREMENT_ID = 'potentialEvapotranspirationMonthly'
 
 
 def _measurement(value: float, start_date: str, end_date: str):
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [value]
     data['startDate'] = start_date
     data['endDate'] = end_date
@@ -38,7 +38,7 @@ def _run(measurement: dict):
     values = measurement.get('value', [])
     dates = measurement.get('dates', [])
     term_id = measurement.get('term', {}).get('@id')
-    results = _slice_by_year(term_id, dates, values)
+    results = slice_by_year(term_id, dates, values)
     return [_measurement(value, start_date, end_date) for (value, start_date, end_date) in results]
 
 

hestia_earth/models/{site → hestia}/potentialEvapotranspirationMonthly.py

@@ -3,7 +3,7 @@ from hestia_earth.utils.tools import flatten, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.measurement import _new_measurement
-from .utils import _group_by_month
+from .utils import group_by_month
 from . import MODEL
 
 REQUIREMENTS = {
@@ -25,7 +25,7 @@ MEASUREMENT_ID = 'potentialEvapotranspirationDaily'
 
 
 def _measurement(value: list, dates: list):
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = value
     data['dates'] = dates
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
@@ -36,7 +36,7 @@ def _run(measurement: dict):
     values = measurement.get('value', [])
     dates = measurement.get('dates', [])
     term_id = measurement.get('term', {}).get('@id')
-    result = _group_by_month(term_id, dates, values)
+    result = group_by_month(term_id, dates, values)
     return _measurement(result[0], result[1]) if len(result[0]) > 0 else None
 
 

hestia_earth/models/{site → hestia}/precipitationAnnual.py

@@ -3,7 +3,7 @@ from hestia_earth.utils.tools import flatten, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.measurement import _new_measurement
-from .utils import _slice_by_year
+from .utils import slice_by_year
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ MEASUREMENT_ID = 'precipitationMonthly'
 
 
 def _measurement(value: float, start_date: str, end_date: str):
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [value]
     data['startDate'] = start_date
     data['endDate'] = end_date
@@ -38,7 +38,7 @@ def _run(measurement: dict):
     values = measurement.get('value', [])
     dates = measurement.get('dates', [])
     term_id = measurement.get('term', {}).get('@id')
-    results = _slice_by_year(term_id, dates, values)
+    results = slice_by_year(term_id, dates, values)
     return [_measurement(value, start_date, end_date) for (value, start_date, end_date) in results]
 
 

hestia_earth/models/{site → hestia}/precipitationMonthly.py

@@ -3,7 +3,7 @@ from hestia_earth.utils.tools import flatten, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.measurement import _new_measurement
-from .utils import _group_by_month
+from .utils import group_by_month
 from . import MODEL
 
 REQUIREMENTS = {
@@ -25,7 +25,7 @@ MEASUREMENT_ID = 'precipitationDaily'
 
 
 def _measurement(value: list, dates: list):
-    data = _new_measurement(TERM_ID)
+    data = _new_measurement(TERM_ID, MODEL)
     data['value'] = value
     data['dates'] = dates
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
@@ -36,7 +36,7 @@ def _run(measurement: dict):
     values = measurement.get('value', [])
     dates = measurement.get('dates', [])
     term_id = measurement.get('term', {}).get('@id')
-    result = _group_by_month(term_id, dates, values)
+    result = group_by_month(term_id, dates, values)
     return _measurement(result[0], result[1]) if len(result[0]) > 0 else None