hestia-earth-models 0.64.2__py3-none-any.whl → 0.64.4__py3-none-any.whl

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/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/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/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/cycle/concentrateFeed.py

@@ -16,7 +16,7 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "inputs": [{
-            "@type": "Practice", "value": "", "term.termType": ["crop", "forage", "processedFood", "animalProduct"]
+            "@type": "Input", "value": "", "term.termType": ["crop", "forage", "processedFood", "animalProduct"]
         }],
         "products": [
             {
@@ -58,17 +58,17 @@ 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]
+    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)
 
@@ -88,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)
@@ -97,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/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/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/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/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 []

hestia_earth/models/fantkeEtAl2016/__init__.py

@@ -0,0 +1,13 @@
+from os.path import dirname, abspath
+import sys
+from importlib import import_module
+
+from hestia_earth.models.utils.blank_node import run_if_required
+
+CURRENT_DIR = dirname(abspath(__file__)) + '/'
+sys.path.append(CURRENT_DIR)
+MODEL = 'fantkeEtAl2016'
+PKG = '.'.join(['hestia_earth', 'models', MODEL])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/fantkeEtAl2016/damageToHumanHealthParticulateMatterFormation.py

@@ -0,0 +1,49 @@
+from hestia_earth.utils.lookup import column_name
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from . import MODEL
+from ..utils.impact_assessment import impact_lookup_value
+from ..utils.indicator import _new_indicator
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {
+                "@type": "Indicator", "value": "", "term.termType": "emission"
+            }
+        ]
+    }
+}
+
+TERM_ID = 'damageToHumanHealthParticulateMatterFormation'
+
+LOOKUPS = {
+    "emission": "damageToHumanHealthParticulateMatterFormationFantkeEtAl2016"
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+default_group_key = 'default'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_lookup_value(model=MODEL, term_id=TERM_ID, impact=impact_assessment,
+                                lookup_col=column_name(LOOKUPS['emission']),
+                                grouped_key=default_group_key)
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    value=value)
+
+    should_run = all([value is not None])
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+
+    return _indicator(value) if should_run else None

hestia_earth/models/frischknechtEtAl2000/__init__.py

@@ -0,0 +1,13 @@
+from os.path import dirname, abspath
+import sys
+from importlib import import_module
+
+from hestia_earth.models.utils.blank_node import run_if_required
+
+CURRENT_DIR = dirname(abspath(__file__)) + '/'
+sys.path.append(CURRENT_DIR)
+MODEL = 'frischknechtEtAl2000'
+PKG = '.'.join(['hestia_earth', 'models', MODEL])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/frischknechtEtAl2000/ionisingRadiationKbqU235Eq.py

@@ -0,0 +1,90 @@
+from functools import reduce
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.tools import list_sum, flatten, non_empty_list
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.emission import filter_emission_inputs
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.lookup import factor_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "value": "",
+            "term.@id": [
+                "ionisingCompoundsToAirInputsProduction",
+                "ionisingCompoundsToWaterInputsProduction",
+                "ionisingCompoundsToSaltwaterInputsProduction"
+            ],
+            "inputs": [{"@type": "Input", "term.termType": "waste"}]
+        }]
+    }
+}
+LOOKUPS = {
+    "waste": [
+        "ionisingCompoundsToAirInputsProduction",
+        "ionisingCompoundsToWaterInputsProduction",
+        "ionisingCompoundsToSaltwaterInputsProduction"
+    ]
+}
+RETURNS = {
+    "Indicator": {
+        "value": "",
+        "inputs": ""
+    }
+}
+
+TERM_ID = 'ionisingRadiationKbqU235Eq'
+
+
+def _indicator(value: float, input: dict):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    indicator['inputs'] = [input]
+    return indicator
+
+
+def _run(grouped_emissions_inputs: list):
+    input = grouped_emissions_inputs[0].get('input')
+    values = [
+        factor_value(
+            model=MODEL,
+            term_id=TERM_ID,
+            lookup_name=f"{TermTermType.WASTE.value}.csv",
+            lookup_col=i.get('emission').get('term', {}).get('@id')
+        )(data=i.get('emission') | {'term': i.get('input')})
+        for i in grouped_emissions_inputs
+    ]
+    value = list_sum(values)
+    return _indicator(value, input) if value else None
+
+
+def _should_run(impact_assessment: dict):
+    emissions = flatten([
+        ([
+            {'emission': emission, 'input': input}
+            for input in filter_emission_inputs(emission, TermTermType.WASTE)
+        ])
+        for emission in impact_assessment.get('emissionsResourceUse', [])
+        if emission.get('term', {}).get('@id') in LOOKUPS[TermTermType.WASTE.value]
+    ])
+    emissions_per_input = reduce(
+        lambda p, c: p | {c.get('input').get('@id'): p.get(c.get('input').get('@id'), []) + [c]},
+        emissions,
+        {}
+    )
+
+    logRequirements(impact_assessment, model=MODEL,
+                    has_emissions=bool(emissions_per_input))
+
+    should_run = all([emissions_per_input])
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, emissions_per_input
+
+
+def run(impact_assessment: dict):
+    should_run, emissions_per_input = _should_run(impact_assessment)
+    return non_empty_list(map(_run, emissions_per_input.values())) if should_run else []