hestia-earth-models 0.64.1__tar.gz → 0.64.3__tar.gz

{hestia-earth-models-0.64.1/hestia_earth_models.egg-info → hestia-earth-models-0.64.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.64.1
+Version: 0.64.3
 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.1 → hestia-earth-models-0.64.3}/hestia_earth/models/agribalyse2016/machineryInfrastructureDepreciatedAmountPerCycle.py

@@ -12,7 +12,7 @@ of less than 0.8.
 from hestia_earth.utils.tools import list_sum, flatten
 
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
-from hestia_earth.models.utils.productivity import _get_productivity, PRODUCTIVITY
+from hestia_earth.models.utils.productivity import get_productivity, PRODUCTIVITY
 from hestia_earth.models.utils.input import _new_input
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from hestia_earth.models.utils.term import get_liquid_fuel_terms
@@ -58,7 +58,7 @@ def _get_input_value_from_term(inputs: list, term_id: str):
 
 def get_value(country: dict, cycle: dict):
     liquid_fuels = get_liquid_fuel_terms()
-    productivity_key = _get_productivity(country)
+    productivity_key = get_productivity(country)
     machinery_usage = 11.5 if productivity_key == PRODUCTIVITY.HIGH else 23
     values = [(term_id, _get_input_value_from_term(cycle.get('inputs', []), term_id)) for term_id in liquid_fuels]
     value_logs = log_as_table([{'id': term_id, 'value': value} for term_id, value in values])

{hestia-earth-models-0.64.1 → hestia-earth-models-0.64.3}/hestia_earth/models/cycle/animal/input/hestiaAggregatedData.py

@@ -48,9 +48,12 @@ def _run_animal_input(cycle: dict, input: dict):
 
 
 def _run_animal(cycle: dict, animal: dict):
-    inputs = [input for input in animal.get('inputs', []) if should_link_input_to_impact(cycle)(input)]
     return animal | {
-        'inputs': [_run_animal_input(cycle, input) for input in inputs]
+        'inputs': [
+            (
+                _run_animal_input(cycle, input) if should_link_input_to_impact(cycle)(input) else input
+            ) for input in animal.get('inputs', [])
+        ]
     }
 
 

{hestia-earth-models-0.64.1 → hestia-earth-models-0.64.3}/hestia_earth/models/cycle/animal/input/properties.py

@@ -12,6 +12,7 @@ from hestia_earth.utils.model import find_term_match
 
 from hestia_earth.models.log import logShouldRun
 from hestia_earth.models.utils import _load_calculated_node
+from hestia_earth.models.utils.blank_node import merge_blank_nodes
 from hestia_earth.models.utils.feedipedia import rescale_properties_from_dryMatter
 from ...utils import should_run_properties_value, average_blank_node_properties_value
 from ... import MODEL
@@ -61,7 +62,7 @@ def _run_input_by_impactAssessment(cycle: dict):
         new_properties = [p for p in properties if not find_term_match(all_properties, p.get('term', {}).get('@id'))]
         for prop in new_properties:
             logShouldRun(cycle, MODEL, term_id, True, property=prop.get('term', {}).get('@id'))
-        return {**input, 'properties': all_properties + new_properties} if new_properties else input
+        return {**input, 'properties': merge_blank_nodes(all_properties, new_properties)} if new_properties else input
     return exec
 
 

{hestia-earth-models-0.64.1 → hestia-earth-models-0.64.3}/hestia_earth/models/cycle/animal/milkYield.py

@@ -10,6 +10,7 @@ from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import non_empty_list, safe_parse_float
 
 from hestia_earth.models.log import logShouldRun, logRequirements, log_blank_nodes_id
+from hestia_earth.models.utils.blank_node import merge_blank_nodes
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.practice import _new_practice
 from .. import MODEL
@@ -68,7 +69,7 @@ def _run(cycle: dict, animal: dict):
 
     return {
         **animal,
-        'practices': animal.get('practices', []) + practices
+        'practices': merge_blank_nodes(animal.get('practices', []), practices)
     } if practices else None
 
 

{hestia-earth-models-0.64.1 → hestia-earth-models-0.64.3}/hestia_earth/models/cycle/concentrateFeed.py

@@ -15,7 +15,9 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "inputs": [{"@type": "Practice", "value": "", "term.termType": ["crop", "animalProduct"]}],
+        "inputs": [{
+            "@type": "Input", "value": "", "term.termType": ["crop", "forage", "processedFood", "animalProduct"]
+        }],
         "products": [
             {
                 "@type": "Product",
@@ -34,10 +36,17 @@ RETURNS = {
 }
 LOOKUPS = {
     "crop-property": "crudeProteinContent",
+    "forage-property": "crudeProteinContent",
+    "processedFood-property": "crudeProteinContent",
     "property": "commonToSupplementInAnimalFeed"
 }
 TERM_ID = 'concentrateFeedBlend,concentrateFeedUnspecified,feedMix'
-INPUT_TERM_TYPES = [TermTermType.CROP.value, TermTermType.ANIMALPRODUCT.value]
+INPUT_TERM_TYPES = [
+    TermTermType.CROP.value,
+    TermTermType.FORAGE.value,
+    TermTermType.PROCESSEDFOOD.value,
+    TermTermType.ANIMALPRODUCT.value
+]
 
 
 def _property(term_id: str, value: float):
@@ -49,18 +58,18 @@ def _property(term_id: str, value: float):
 def _min_ratio(term_id: str):
     value = get_property_lookup_value(MODEL, term_id, LOOKUPS['property'])
     # value is a Numpy bool so use negation
-    return 1 if not value else 0.8
+    return 0.8 if not value else 1
 
 
 def _weighted_value(values: list):
-    total_weight = sum(weight for _v, weight in values)
-    weighted_values = [value * weight for value, weight in values]
+    total_weight = sum(input_value for prop_value, input_value in values)
+    weighted_values = [prop_value * input_value for prop_value, input_value in values]
     return sum(weighted_values) / (total_weight if total_weight != 0 else 1)
 
 
 def _calculate_value(cycle: dict, product: dict, inputs: list, property_id: str, values: list):
-    values = [(prop_value, value) for id, prop_value, value in values if value and prop_value]
-    ratio_inputs_with_props = len(inputs) / len(values) if len(inputs) and len(values) else 0
+    values = [(prop_value, input_value) for id, prop_value, input_value in values if input_value and prop_value]
+    ratio_inputs_with_props = len(values) / len(inputs) if len(inputs) and len(values) else 0
     min_ratio = _min_ratio(property_id)
 
     term_id = product.get('term', {}).get('@id')
@@ -79,7 +88,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, term=TERM_ID),
+        get_node_property_value(MODEL, i, property_id, handle_percents=False, term=TERM_ID),
         list_sum(i.get('value', []))
     ) for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
@@ -88,8 +97,8 @@ 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, term=TERM_ID) or
-        get_node_property_value(MODEL, i, 'crudeProteinContent', default=0, term=TERM_ID) * 0.16,
+        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,
         list_sum(i.get('value', []))
     ) for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)

{hestia-earth-models-0.64.1 → hestia-earth-models-0.64.3}/hestia_earth/models/cycle/cycleDuration.py

@@ -11,7 +11,7 @@ from hestia_earth.utils.model import find_term_match, find_primary_product
 from hestia_earth.utils.date import diff_in_days
 
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
-from hestia_earth.models.utils.crop import get_crop_grouping_fao
+from hestia_earth.models.utils.crop import is_permanent_crop
 from . import MODEL
 
 REQUIREMENTS = {
@@ -63,12 +63,11 @@ def _should_run_by_dates(cycle: dict):
 
 def _run_by_crop(cycle: dict):
     product = find_primary_product(cycle)
-    grouping = get_crop_grouping_fao(MODEL, MODEL_KEY, product.get('term', {}))
-    is_permanent_crop = grouping == 'Permanent crops'
+    permanent_crop = is_permanent_crop(MODEL, MODEL_KEY, product.get('term', {}))
     croppingIntensity = find_term_match(cycle.get('practices', []), 'croppingIntensity').get('value', [1])[0]
-    ratio = 1 if is_permanent_crop else croppingIntensity
+    ratio = 1 if permanent_crop else croppingIntensity
     debugValues(cycle, model=MODEL, key=MODEL_KEY, by='product',
-                crop_grouping=grouping,
+                is_permanent_crop=permanent_crop,
                 croppingIntensity=croppingIntensity,
                 ratio=ratio)
     return round(DEFAULT_DURATION * ratio, 3)

{hestia-earth-models-0.64.1 → hestia-earth-models-0.64.3}/hestia_earth/models/cycle/siteDuration.py

@@ -4,12 +4,15 @@ Site duration
 This model calculates the `siteDuration` on the `Cycle` to the same value as `cycleDuration`
 when only a single `Site` is present.
 
-Note: on `crop` production cycles, the model will only run if `startDateDefinition` = `harvest of previous crop`.
+Note: on `crop` production cycles:
+* For temporary crops, gap fill only when `startDateDefinition` = `harvest of previous crop`.
+* For permanent crops, no restriction applies.
 """
 from hestia_earth.schema import TermTermType, CycleStartDateDefinition
 from hestia_earth.utils.model import find_primary_product
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.crop import is_permanent_crop
 from . import MODEL
 
 REQUIREMENTS = {
@@ -39,20 +42,27 @@ def _run(cycle: dict): return cycle.get('cycleDuration')
 
 def _should_run(cycle: dict):
     cycleDuration = cycle.get('cycleDuration', 0)
-    has_other_sites = len(cycle.get('otherSites', [])) == 0
+    has_single_site = len(cycle.get('otherSites', [])) == 0
 
     product = find_primary_product(cycle)
-    is_primary_crop_product = (product or {}).get('term', {}).get('termType') == TermTermType.CROP.value
+    product_term = (product or {}).get('term', {})
+    is_primary_crop_product = product_term.get('termType') == TermTermType.CROP.value
+    permanent_crop = is_permanent_crop(MODEL, MODEL_KEY, product_term)
     harvest_previous_crop = CycleStartDateDefinition.HARVEST_OF_PREVIOUS_CROP.value
     is_harvest_previous_crop = cycle.get('startDateDefinition') == harvest_previous_crop
 
     logRequirements(cycle, model=MODEL, key=MODEL_KEY,
                     cycleDuration=cycleDuration,
-                    has_other_sites=has_other_sites,
+                    has_single_site=has_single_site,
                     is_primary_crop_product=is_primary_crop_product,
+                    is_permanent_crop=permanent_crop,
                     is_harvest_previous_crop=is_harvest_previous_crop)
 
-    should_run = all([cycleDuration > 0, has_other_sites, not is_primary_crop_product or is_harvest_previous_crop])
+    should_run = all([
+        cycleDuration > 0,
+        has_single_site,
+        not is_primary_crop_product or permanent_crop or is_harvest_previous_crop
+    ])
     logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY)
     return should_run
 

{hestia-earth-models-0.64.1 → hestia-earth-models-0.64.3}/hestia_earth/models/cycle/startDateDefinition.py

@@ -8,7 +8,7 @@ from hestia_earth.schema import TermTermType, CycleStartDateDefinition
 from hestia_earth.utils.model import find_primary_product
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.crop import get_crop_grouping_fao
+from hestia_earth.models.utils.crop import is_permanent_crop
 from . import MODEL
 
 REQUIREMENTS = {
@@ -40,12 +40,11 @@ def _is_last_day_of_month(date: str):
 
 def _run(cycle: dict):
     product = find_primary_product(cycle)
-    grouping = get_crop_grouping_fao(MODEL, MODEL_KEY, product.get('term', {}))
-    is_permanent_crop = grouping == 'Permanent crops'
+    permanent_crop = is_permanent_crop(MODEL, MODEL_KEY, product.get('term', {}))
     return (
         CycleStartDateDefinition.START_OF_YEAR.value if _is_last_day_of_month(cycle.get('endDate'))
         else CycleStartDateDefinition.ONE_YEAR_PRIOR.value
-    ) if is_permanent_crop else (
+    ) if permanent_crop else (
         CycleStartDateDefinition.HARVEST_OF_PREVIOUS_CROP.value
     )
 

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

@@ -0,0 +1,52 @@
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import find_primary_product
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+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": {
+        "products": [{
+            "@type": "Product",
+            "primary": "True",
+            "term.termType": "liveAnimal"
+        }]
+    }
+}
+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 _should_run(cycle: dict):
+    product = find_primary_product(cycle)
+    is_live_animal_product = (product or {}).get('term', {}).get('termType') == TermTermType.LIVEANIMAL.value
+
+    lookup_value = get_lookup_value((product or {}).get('term', {}), LOOKUPS['liveAnimal'])
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_live_animal_product=is_live_animal_product,
+                    lookup_value=lookup_value)
+
+    should_run = all([is_live_animal_product > 0, lookup_value is not None])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run, lookup_value
+
+
+def run(cycle: dict):
+    should_run, lookup_value = _should_run(cycle)
+    return _practice(lookup_value) if should_run else []