hestia-earth-models 0.64.4__tar.gz → 0.64.5__tar.gz

{hestia-earth-models-0.64.4/hestia_earth_models.egg-info → hestia-earth-models-0.64.5}/PKG-INFO

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

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/blonkConsultants2016/ch4ToAirNaturalVegetationBurning.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, CycleFunctionalUnit
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
@@ -8,16 +8,10 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "functionalUnit": "1 ha",
         "or": [
             {
-                "@doc": "if the [cycle.functionalUnit](https://hestia.earth/schema/Cycle#functionalUnit) = 1 ha, additional properties are required",  # noqa: E501
                 "cycleDuration": "",
-                "products": [{
-                    "@type": "Product",
-                    "primary": "True",
-                    "value": "> 0",
-                    "economicValueShare": "> 0"
-                }],
                 "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
             },
             {
@@ -65,14 +59,16 @@ def _run(land_occupation: float, ch4_forest_biomass_burning: float):
 
 
 def _should_run(cycle: dict):
+    is_1_ha_functional_unit = cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value
     land_occupation = land_occupation_per_ha(MODEL, TERM_ID, cycle)
     ch4_forest_biomass_burning = get_emission_factor(TERM_ID, cycle, 'ch4forestBiomassBurning')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_1_ha_functional_unit=is_1_ha_functional_unit,
                     land_occupation=land_occupation,
                     ch4_forest_biomass_burning=ch4_forest_biomass_burning)
 
-    should_run = all([land_occupation, ch4_forest_biomass_burning is not None])
+    should_run = all([is_1_ha_functional_unit, land_occupation, ch4_forest_biomass_burning is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, land_occupation, ch4_forest_biomass_burning
 

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/blonkConsultants2016/co2ToAirAboveGroundBiomassStockChangeLandUseChange.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, CycleFunctionalUnit
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
@@ -8,16 +8,10 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "functionalUnit": "1 ha",
         "or": [
             {
-                "@doc": "if the [cycle.functionalUnit](https://hestia.earth/schema/Cycle#functionalUnit) = 1 ha, additional properties are required",  # noqa: E501
                 "cycleDuration": "",
-                "products": [{
-                    "@type": "Product",
-                    "primary": "True",
-                    "value": "> 0",
-                    "economicValueShare": "> 0"
-                }],
                 "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
             },
             {
@@ -65,14 +59,16 @@ def _run(land_occupation: float, co2_land_use_change: float):
 
 
 def _should_run(cycle: dict):
+    is_1_ha_functional_unit = cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value
     land_occupation = land_occupation_per_ha(MODEL, TERM_ID, cycle)
     co2_land_use_change = get_emission_factor(TERM_ID, cycle, 'co2LandUseChange')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_1_ha_functional_unit=is_1_ha_functional_unit,
                     land_occupation=land_occupation,
                     co2_land_use_change=co2_land_use_change)
 
-    should_run = all([land_occupation, co2_land_use_change is not None])
+    should_run = all([is_1_ha_functional_unit, land_occupation, co2_land_use_change is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, land_occupation, co2_land_use_change
 

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/blonkConsultants2016/n2OToAirNaturalVegetationBurningDirect.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, CycleFunctionalUnit
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
@@ -8,20 +8,11 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "functionalUnit": "1 ha",
         "or": [
             {
-                "@doc": "if the [cycle.functionalUnit](https://hestia.earth/schema/Cycle#functionalUnit) = 1 ha, additional properties are required",  # noqa: E501
                 "cycleDuration": "",
-                "products": [{
-                    "@type": "Product",
-                    "primary": "True",
-                    "value": "> 0",
-                    "economicValueShare": "> 0"
-                }],
-                "site": {
-                    "@type": "Site",
-                    "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
-                }
+                "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
             },
             {
                 "@doc": "for plantations, additional properties are required",
@@ -68,14 +59,16 @@ def _run(land_occupation: float, n2o_forest_biomass_burning: float):
 
 
 def _should_run(cycle: dict):
+    is_1_ha_functional_unit = cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value
     land_occupation = land_occupation_per_ha(MODEL, TERM_ID, cycle)
     n2o_forest_biomass_burning = get_emission_factor(TERM_ID, cycle, 'n2oforestBiomassBurning')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_1_ha_functional_unit=is_1_ha_functional_unit,
                     land_occupation=land_occupation,
                     n2o_forest_biomass_burning=n2o_forest_biomass_burning)
 
-    should_run = all([land_occupation, n2o_forest_biomass_burning is not None])
+    should_run = all([is_1_ha_functional_unit, land_occupation, n2o_forest_biomass_burning is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, land_occupation, n2o_forest_biomass_burning
 

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/animal/input/properties.py

@@ -41,6 +41,12 @@ RETURNS = {
         }]
     }]
 }
+LOOKUPS = {
+    "crop-property": "dryMatter",
+    "forage-property": "dryMatter",
+    "processedFoor-property": "dryMatter",
+    "property": "feedipediaConversionEnum"
+}
 MODEL_KEY = 'properties'
 
 

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/completeness/soilAmendment.py

@@ -6,7 +6,8 @@ This model checks if we have the requirements below and updates the
 """
 from hestia_earth.models.log import logRequirements
 from hestia_earth.models.utils import is_from_model
-from hestia_earth.models.utils.measurement import most_relevant_measurement, measurement_value
+from hestia_earth.models.utils.measurement import measurement_value
+from hestia_earth.models.utils.blank_node import most_relevant_blank_node_by_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -30,7 +31,7 @@ MODEL_KEY = 'soilAmendment'
 def run(cycle: dict):
     end_date = cycle.get('endDate')
     measurements = cycle.get('site', {}).get('measurements', [])
-    soilPh_measurement = most_relevant_measurement(measurements, 'soilPh', end_date)
+    soilPh_measurement = most_relevant_blank_node_by_id(measurements, 'soilPh', end_date)
     soilPh = measurement_value(soilPh_measurement)
 
     soilPh_added = is_from_model(soilPh_measurement)

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/concentrateFeed.py

@@ -9,6 +9,7 @@ from hestia_earth.utils.model import find_primary_product
 from hestia_earth.utils.tools import list_sum, non_empty_list, flatten
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.blank_node import merge_blank_nodes
 from hestia_earth.models.utils.property import _new_property, get_node_property_value, get_property_lookup_value
 from hestia_earth.models.utils.term import get_digestible_energy_terms, get_energy_digestibility_terms
 from . import MODEL
@@ -41,6 +42,7 @@ LOOKUPS = {
     "property": "commonToSupplementInAnimalFeed"
 }
 TERM_ID = 'concentrateFeedBlend,concentrateFeedUnspecified,feedMix'
+FIRST_TERM_ID = TERM_ID.split(',')[0]
 INPUT_TERM_TYPES = [
     TermTermType.CROP.value,
     TermTermType.FORAGE.value,
@@ -88,7 +90,7 @@ def _calculate_value(cycle: dict, product: dict, inputs: list, property_id: str,
 def _calculate_default_value(cycle: dict, product: dict, inputs: list, property_id: str):
     values = [(
         i.get('term', {}).get('@id'),
-        get_node_property_value(MODEL, i, property_id, handle_percents=False, term=TERM_ID),
+        get_node_property_value(MODEL, i, property_id, handle_percents=False, term=FIRST_TERM_ID),
         list_sum(i.get('value', []))
     ) for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
@@ -97,8 +99,9 @@ def _calculate_default_value(cycle: dict, product: dict, inputs: list, property_
 def _calculate_N_value(cycle: dict, product: dict, inputs: list, property_id: str):
     values = [(
         i.get('term', {}).get('@id'),
-        get_node_property_value(MODEL, i, property_id, handle_percents=False, term=TERM_ID) or
-        get_node_property_value(MODEL, i, 'crudeProteinContent', default=0, handle_percents=False, term=TERM_ID) * 0.16,
+        get_node_property_value(MODEL, i, property_id, handle_percents=False, term=FIRST_TERM_ID) or
+        get_node_property_value(
+            MODEL, i, 'crudeProteinContent', default=0, handle_percents=False, term=FIRST_TERM_ID) * 0.16,
         list_sum(i.get('value', []))
     ) for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
@@ -136,7 +139,10 @@ def _run_property(cycle: dict, product: dict, inputs: list):
 
 def _run(cycle: dict, product: dict, inputs: list):
     properties = non_empty_list(flatten(map(_run_property(cycle, product, inputs), PROPERTY_TO_VALUE.items())))
-    return [{**product, 'properties': product.get('properties', []) + properties}] if len(properties) > 0 else []
+    return [product | {
+        # keep the original values, so merge orignal in new values
+        'properties': merge_blank_nodes(properties, product.get('properties', []))
+    }] if len(properties) > 0 else []
 
 
 def _should_run(cycle: dict):

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/input/properties.py

@@ -34,6 +34,12 @@ RETURNS = {
         }]
     }]
 }
+LOOKUPS = {
+    "crop-property": "dryMatter",
+    "forage-property": "dryMatter",
+    "processedFoor-property": "dryMatter",
+    "property": "feedipediaConversionEnum"
+}
 MODEL_KEY = 'properties'
 
 

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/liveAnimal.py

@@ -10,7 +10,7 @@ from hestia_earth.utils.tools import list_sum, safe_parse_float
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.site import valid_site_type
-from .utils import _get_liveAnimal_term_id
+from .utils import get_liveAnimal_term_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -74,7 +74,7 @@ def _should_run(cycle: dict):
     propertyPerHead_value = safe_parse_float(propertyPerHead.get('value'), None)
 
     # make sure the `liveAnimal` Term is not already present as a Product or Input
-    term_id = _get_liveAnimal_term_id(product, model_key=MODEL_KEY)
+    term_id = get_liveAnimal_term_id(product, model_key=MODEL_KEY)
     has_liveAnimal_product = find_term_match(cycle.get('products', []), term_id, None) is not None
     has_liveAnimal_input = find_term_match(cycle.get('products', []), term_id, None) is not None
 

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/milkYield.py

@@ -16,7 +16,7 @@ from hestia_earth.models.log import logRequirements, logShouldRun, log_blank_nod
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.site import valid_site_type
 from hestia_earth.models.utils.term import get_lookup_value
-from .utils import _get_liveAnimal_term_id
+from .utils import get_liveAnimal_term_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -85,7 +85,7 @@ def _run(cycle: dict, product: dict):
     term = product.get('term', {})
     practice_id = _practice_id(term)
 
-    live_animal_term_id = _get_liveAnimal_term_id(product, model_key=MODEL_KEY)
+    live_animal_term_id = get_liveAnimal_term_id(product, model_key=MODEL_KEY)
     live_animal_node = find_term_match(cycle.get('animals', []), live_animal_term_id)
 
     value = list_sum(product.get('value')) / cycleDuration / live_animal_node.get('value')
@@ -115,7 +115,7 @@ def _should_run_product(cycle: dict, product: dict):
 
     has_product_value = list_sum(product.get('value', [])) > 0
 
-    live_animal_term_id = _get_liveAnimal_term_id(product, model_key=MODEL_KEY)
+    live_animal_term_id = get_liveAnimal_term_id(product, model_key=MODEL_KEY)
     live_animal_node = find_term_match(cycle.get('animals', []), live_animal_term_id)
     has_live_animal_node_value = live_animal_node.get('value', 0) > 0
 

hestia-earth-models-0.64.5/hestia_earth/models/cycle/otherSitesArea.py

@@ -0,0 +1,59 @@
+"""
+Other Sites Area
+
+For animal production cycles, use the `stockingDensityAnimalHousingAverage` to calculate the average area required
+for all animals.
+"""
+from hestia_earth.schema import SiteSiteType
+
+from .siteArea import _is_site_valid, _should_run as _should_run_site, _run
+
+REQUIREMENTS = {
+    "Cycle": {
+        "otherSites": [{
+            "@type": "Site",
+            "siteType": "animal housing"
+        }],
+        "none": {
+            "site": {
+                "@type": "Site",
+                "siteType": "animal housing"
+            }
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "value": "> 0"
+        }],
+        "practices": [{
+            "@type": "Practice",
+            "term.@id": "stockingDensityAnimalHousingAverage"
+        }]
+    }
+}
+RETURNS = {
+    "The otherSitesArea as an array of number": ""
+}
+MODEL_KEY = 'otherSitesArea'
+
+
+def _should_run(cycle: dict):
+    other_sites_valid = list(filter(
+        lambda site: site.get('siteType') == SiteSiteType.ANIMAL_HOUSING.value,
+        cycle.get('otherSites', [])
+    ))
+
+    should_run = all([
+        not _is_site_valid(cycle.get('site', {})),
+        len(other_sites_valid) == 1
+    ]) and _should_run_site(cycle, other_sites_valid[0], key=MODEL_KEY)
+    return should_run
+
+
+def run(cycle: dict):
+    other_sites = cycle.get('otherSites', [])
+    other_sites_area = cycle.get('otherSitesArea')
+    return [
+        _run(cycle) if _is_site_valid(site) else other_sites_area[index] if other_sites_area else None
+        for index, site in enumerate(other_sites)
+    ] if _should_run(cycle) else []

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/otherSitesUnusedDuration.py

@@ -51,6 +51,13 @@ def _find_site_practice(practices: list, site_id: str):
     ).get('value'), None)
 
 
+def _is_valid(data: dict): return all([
+        data.get('valid-site'),
+        data.get(_PRACTICE_TERM_ID) is not None,
+        data.get('site-duration') is not None
+    ])
+
+
 def _should_run(cycle: dict):
     otherSitesDuration = cycle.get('otherSitesDuration', [])
     practices = cycle.get('practices', [])
@@ -66,13 +73,7 @@ def _should_run(cycle: dict):
         for index, site in enumerate(cycle.get('otherSites', []))
     ]
 
-    has_valid_sites = any([
-        all([
-            data.get('valid-site'),
-            data.get(_PRACTICE_TERM_ID) is not None,
-            (data.get('site-duration') or 0) >= 0
-        ]) for data in site_data
-    ])
+    has_valid_sites = any(map(_is_valid, site_data))
 
     logRequirements(cycle, model=MODEL, key=MODEL_KEY,
                     has_valid_sites=has_valid_sites,
@@ -86,6 +87,6 @@ def _should_run(cycle: dict):
 def run(cycle: dict):
     should_run, site_data = _should_run(cycle)
     return [
-        _run(data.get('site-duration'), data.get(_PRACTICE_TERM_ID)) if data.get('valid-site') else None
+        _run(data.get('site-duration'), data.get(_PRACTICE_TERM_ID)) if _is_valid(data) else None
         for data in site_data
     ] if should_run else []

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/pastureSystem.py

@@ -10,7 +10,8 @@ from hestia_earth.utils.model import find_primary_product, find_term_match
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.site import valid_site_type
-from hestia_earth.models.utils.measurement import most_relevant_measurement, measurement_value
+from hestia_earth.models.utils.measurement import measurement_value
+from hestia_earth.models.utils.blank_node import most_relevant_blank_node_by_id
 from hestia_earth.models.utils.term import get_pasture_system_terms
 from . import MODEL
 
@@ -46,7 +47,7 @@ def _practice(term_id: str):
 def _run(cycle: dict):
     end_date = cycle.get('endDate')
     measurements = cycle.get('site', {}).get('measurements', [])
-    slope = measurement_value(most_relevant_measurement(measurements, 'slope', end_date))
+    slope = measurement_value(most_relevant_blank_node_by_id(measurements, 'slope', end_date))
     term_id = 'confinedPastureSystem' if slope <= 2.5 else 'hillyPastureSystem'
 
     debugValues(cycle, model=MODEL, term=term_id,

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/product/properties.py

@@ -28,6 +28,12 @@ RETURNS = {
         }]
     }]
 }
+LOOKUPS = {
+    "crop-property": "dryMatter",
+    "forage-property": "dryMatter",
+    "processedFoor-property": "dryMatter",
+    "property": "feedipediaConversionEnum"
+}
 MODEL_KEY = 'properties'
 DRY_MATTER_TERM_ID = 'dryMatter'
 

hestia-earth-models-0.64.5/hestia_earth/models/cycle/siteArea.py

@@ -0,0 +1,83 @@
+"""
+Site Area
+
+For animal production cycles, use the `stockingDensityAnimalHousingAverage` to calculate the average area required
+for all animals.
+"""
+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
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "siteType": "animal housing"
+        },
+        "none": {
+            "otherSites": [{
+                "@type": "Site",
+                "siteType": "animal housing"
+            }]
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "value": "> 0"
+        }],
+        "practices": [{
+            "@type": "Practice",
+            "term.@id": "stockingDensityAnimalHousingAverage",
+            "value": "> 0"
+        }]
+    }
+}
+RETURNS = {
+    "The siteArea as a number": ""
+}
+MODEL_KEY = 'siteArea'
+
+
+def _is_site_valid(site: dict): return site.get('siteType') == SiteSiteType.ANIMAL_HOUSING.value
+
+
+def _run(cycle: dict):
+    animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
+    stocking_density = find_term_match(
+        cycle.get('practices', []), 'stockingDensityAnimalHousingAverage', {}).get('value', [])
+    return round(list_sum([a.get('value') for a in animals]) / list_sum(stocking_density), 7)
+
+
+def _should_run(cycle: dict, site: dict, key=MODEL_KEY):
+    site_type_valid = _is_site_valid(site)
+    animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
+    values = [{
+        'id': p.get('term', {}).get('@id'),
+        'value': p.get('value')
+    } for p in animals]
+    has_animals = bool(animals)
+    stocking_density = list_sum(
+        find_term_match(cycle.get('practices', []), 'stockingDensityAnimalHousingAverage', {}).get('value', [-1])
+    )
+
+    logRequirements(cycle, model=MODEL, key=key,
+                    site_type_valid=site_type_valid,
+                    values=log_as_table(values),
+                    stocking_density=stocking_density)
+
+    should_run = all([
+        site_type_valid,
+        has_animals,
+        (stocking_density or 0) > 0
+    ])
+    logShouldRun(cycle, MODEL, None, should_run, key=key)
+    return should_run
+
+
+def run(cycle: dict):
+    site = cycle.get('site')
+    has_other_sites_valid = any(map(_is_site_valid, cycle.get('otherSites', [])))
+    return _run(cycle) if _should_run(cycle, site, key=MODEL_KEY) and not has_other_sites_valid else None

hestia-earth-models-0.64.5/hestia_earth/models/cycle/stockingDensityAnimalHousingAverage.py

@@ -0,0 +1,64 @@
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import weighted_average
+from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.practice import _new_practice
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "value": "> 0"
+        }]
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "value": ""
+    }]
+}
+LOOKUPS = {
+    "liveAnimal": "stockingDensityAnimalHousing"
+}
+TERM_ID = 'stockingDensityAnimalHousingAverage'
+
+
+def _practice(value: float):
+    practice = _new_practice(TERM_ID)
+    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)]
+
+
+def _should_run(cycle: dict):
+    animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
+    values = [{
+        'id': p.get('term', {}).get('@id'),
+        'value': p.get('value'),
+        'lookup': get_lookup_value(p.get('term', {}), LOOKUPS['liveAnimal'])
+    } for p in animals]
+    has_animals = bool(animals)
+    has_values = all([all([p.get('value') is not None, p.get('lookup') is not None]) for p in values])
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    values=log_as_table(values))
+
+    should_run = all([has_animals, has_values])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run, values
+
+
+def run(cycle: dict):
+    should_run, values = _should_run(cycle)
+    return _run(values) if should_run else []

{hestia-earth-models-0.64.4 → hestia-earth-models-0.64.5}/hestia_earth/models/cycle/utils.py

@@ -5,7 +5,7 @@ from hestia_earth.models.utils.term import get_lookup_value
 from . import MODEL
 
 
-def _get_liveAnimal_term_id(product: dict, **log_ars):
+def get_liveAnimal_term_id(product: dict, **log_ars):
     term_id = get_lookup_value(product.get('term', {}), 'liveAnimalTermId', model=MODEL, **log_ars)
     return term_id.split(';')[0] if term_id else None