hestia-earth-models 0.64.10__py3-none-any.whl → 0.64.12__py3-none-any.whl

hestia_earth/models/cml2001Baseline/eutrophicationPotentialExcludingFate.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/cml2001Baseline/terrestrialAcidificationPotentialIncludingFateAverageEurope.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/cml2001NonBaseline/eutrophicationPotentialIncludingFateAverageEurope.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/cml2001NonBaseline/terrestrialAcidificationPotentialExcludingFate.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -26,7 +26,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/cycle/completeness/cropResidue.py

@@ -5,6 +5,7 @@ This model checks if we have the requirements below and updates the
 [Data Completeness](https://hestia.earth/schema/Completeness#cropResidue) value.
 """
 from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements
 from hestia_earth.models.utils.term import get_crop_residue_terms
@@ -14,15 +15,15 @@ REQUIREMENTS = {
     "Cycle": {
         "completeness.cropResidue": "False",
         "products": [
-            {"@type": "Product", "value": "", "term.@id": "belowGroundCropResidue"},
-            {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueTotal"}
+            {"@type": "Product", "value": ">= 0", "term.@id": "belowGroundCropResidue"},
+            {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueTotal"}
         ],
         "optional": {
             "products": [
-                {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueRemoved"},
-                {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueIncorporated"},
-                {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueBurnt"},
-                {"@type": "Product", "value": "", "term.@id": "aboveGroundCropResidueLeftOnField"}
+                {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueRemoved"},
+                {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueIncorporated"},
+                {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueBurnt"},
+                {"@type": "Product", "value": "> 0", "term.@id": "aboveGroundCropResidueLeftOnField"}
             ]
         }
     }
@@ -44,17 +45,21 @@ def _optional_term_ids():
     return [term for term in terms if term not in REQUIRED_TERM_IDS]
 
 
-def _has_product(products):
+def _has_product(products, zero_allowed=True):
     def has_product(term_id: str):
-        return (term_id, find_term_match(products, term_id, None) is not None)
+        value = list_sum(find_term_match(products, term_id).get('value', [-1]))
+        return (term_id, value >= 0 if zero_allowed else value > 0)
     return has_product
 
 
 def run(cycle: dict):
     products = cycle.get('products', [])
     # all required terms + at least one of the optional terms must be present
-    required_products_map = list(map(_has_product(products), REQUIRED_TERM_IDS))
-    optional_products_map = list(map(_has_product(products), _optional_term_ids()))
+    required_products_map = [
+        _has_product(products, zero_allowed=True)('belowGroundCropResidue'),
+        _has_product(products, zero_allowed=False)('aboveGroundCropResidueTotal'),
+    ]
+    optional_products_map = list(map(_has_product(products, zero_allowed=False), _optional_term_ids()))
 
     has_required_products = all([has_product for _term_id, has_product in required_products_map])
     has_optional_product = any([has_product for _term_id, has_product in optional_products_map])

hestia_earth/models/cycle/completeness/freshForage.py

@@ -0,0 +1,60 @@
+"""
+Completeness Fresh Forage
+
+This model checks if we have the requirements below and updates the
+[Data Completeness](https://hestia.earth/schema/Completeness#cropResidue) value.
+"""
+from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements
+from hestia_earth.models.utils import is_from_model
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.freshForage": "False",
+        "site": {
+            "@type": "Site",
+            "siteType": "permanent pasture"
+        },
+        "or": {
+            "inputs": [{"@type": "Input", "termType": "forage", "value": "> 0", "added": ["value"]}],
+            "animals": [{
+                "@type": "Animal",
+                "inputs": [{"@type": "Input", "termType": "forage", "value": "> 0", "added": ["value"]}]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Completeness": {
+        "freshForage": ""
+    }
+}
+MODEL_KEY = 'freshForage'
+ALLOWED_SITE_TYPES = [
+    SiteSiteType.PERMANENT_PASTURE.value
+]
+
+
+def _valid_input(input: dict): return is_from_model(input) and list_sum(input.get('value', [-1])) > 0
+
+
+def run(cycle: dict):
+    site_type = cycle.get('site', {}).get('siteType')
+    site_type_allowed = site_type in ALLOWED_SITE_TYPES
+
+    cycle_has_added_forage_input = any(map(_valid_input, cycle.get('inputs', [])))
+
+    animals = cycle.get('animals', [])
+    all_animals_have_added_forage_input = bool(animals) and all([
+        any(map(_valid_input, animal.get('inputs', []))) for animal in animals
+    ])
+
+    logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
+                    site_type_allowed=site_type_allowed,
+                    cycle_has_added_forage_input=cycle_has_added_forage_input,
+                    all_animals_have_added_forage_input=all_animals_have_added_forage_input)
+
+    return all([site_type_allowed, cycle_has_added_forage_input or all_animals_have_added_forage_input])

hestia_earth/models/cycle/concentrateFeed.py

@@ -8,7 +8,7 @@ from hestia_earth.schema import TermTermType
 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.log import logRequirements, logShouldRun, log_as_table
 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
@@ -42,7 +42,6 @@ LOOKUPS = {
     "property": "commonToSupplementInAnimalFeed"
 }
 TERM_ID = 'concentrateFeedBlend,concentrateFeedUnspecified,feedMix'
-FIRST_TERM_ID = TERM_ID.split(',')[0]
 INPUT_TERM_TYPES = [
     TermTermType.CROP.value,
     TermTermType.FORAGE.value,
@@ -70,40 +69,53 @@ def _weighted_value(values: list):
 
 
 def _calculate_value(cycle: dict, product: dict, inputs: list, property_id: str, values: list):
-    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
+    valid_values = [
+        (value.get('property-value'), value.get('input-value'))
+        for value in values
+        if all([value.get('property-value'), value.get('input-value')])
+    ]
+    ratio_inputs_with_props = len(valid_values) / len(inputs) if len(inputs) and len(valid_values) else 0
     min_ratio = _min_ratio(property_id)
 
     term_id = product.get('term', {}).get('@id')
     logRequirements(cycle, model=MODEL, term=term_id, property=property_id,
                     nb_inputs=len(inputs),
-                    nb_inputs_with_prop=len(values),
+                    nb_inputs_with_prop=len(valid_values),
                     ratio_inputs_with_props=ratio_inputs_with_props,
-                    min_ratio=min_ratio)
+                    min_ratio=min_ratio,
+                    details=log_as_table(values))
 
     should_run = all([ratio_inputs_with_props >= min_ratio])
     logShouldRun(cycle, MODEL, term_id, should_run, property=property_id)
 
-    return [(property_id, _weighted_value(values))] if should_run else []
+    return [(property_id, _weighted_value(valid_values))] if should_run else []
 
 
 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=FIRST_TERM_ID),
-        list_sum(i.get('value', []))
-    ) for i in inputs]
+    term_id = product.get('term', {}).get('@id')
+    values = [{
+        'input-id': i.get('term', {}).get('@id'),
+        'input-value': list_sum(i.get('value', [])),
+        'property-id': property_id,
+        'property-value': get_node_property_value(
+            MODEL, i, property_id, handle_percents=False, term=term_id, property=property_id
+        ),
+    } for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
 
 
 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=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]
+    term_id = product.get('term', {}).get('@id')
+    values = [{
+        'input-id': i.get('term', {}).get('@id'),
+        'input-value': list_sum(i.get('value', [])),
+        'property-id': property_id,
+        'property-value': get_node_property_value(
+            MODEL, i, property_id, handle_percents=False, term=term_id, property=property_id
+        ) or get_node_property_value(
+            MODEL, i, 'crudeProteinContent', default=0, handle_percents=False, term=term_id, property=property_id
+        ) * 0.16
+    } for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
 
 

hestia_earth/models/edip2003/ozoneDepletionPotential.py

@@ -1,6 +1,6 @@
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -27,7 +27,7 @@ def _indicator(value: float):
 
 
 def run(impact_assessment: dict):
-    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    value = impact_emission_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
     logShouldRun(impact_assessment, MODEL, TERM_ID, True)

hestia_earth/models/fantkeEtAl2016/damageToHumanHealthParticulateMatterFormation.py

@@ -1,33 +1,23 @@
-from hestia_earth.utils.lookup import column_name
-
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.impact_assessment import impact_emission_lookup_value
+from hestia_earth.models.utils.indicator import _new_indicator
 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"
-            }
-        ]
+        "emissionsResourceUse": [{"@type": "Indicator", "value": "", "term.termType": "emission"}]
     }
 }
-
-TERM_ID = 'damageToHumanHealthParticulateMatterFormation'
-
 LOOKUPS = {
     "emission": "damageToHumanHealthParticulateMatterFormationFantkeEtAl2016"
 }
-
 RETURNS = {
     "Indicator": {
         "value": ""
     }
 }
 
-default_group_key = 'default'
+TERM_ID = 'damageToHumanHealthParticulateMatterFormation'
 
 
 def _indicator(value: float):
@@ -37,9 +27,9 @@ def _indicator(value: float):
 
 
 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)
+    value = impact_emission_lookup_value(
+        model=MODEL, term_id=TERM_ID, impact=impact_assessment, lookup_col=LOOKUPS['emission'], grouped_key='default'
+    )
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     value=value)
 

hestia_earth/models/faostat2018/utils.py

@@ -2,6 +2,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data_closest_date
 from hestia_earth.utils.tools import safe_parse_float
+from numpy import recarray
 
 from hestia_earth.models.log import logger, debugMissingLookup
 from hestia_earth.models.utils.animalProduct import (
@@ -53,7 +54,7 @@ def product_equivalent_value(product: dict, year: int, country: str):
     return conv_value
 
 
-def _cropland_split_delta(table_value: str, start_year: int, end_year: int):
+def _split_delta(table_value: str, start_year: int, end_year: int):
     start_value = extract_grouped_data_closest_date(table_value, start_year)
     end_value = extract_grouped_data_closest_date(table_value, end_year)
     return safe_parse_float(end_value) - safe_parse_float(start_value) if all([
@@ -61,22 +62,81 @@ def _cropland_split_delta(table_value: str, start_year: int, end_year: int):
     ]) else None
 
 
-def get_cropland_ratio(country: str, start_year: int, end_year: int):
+def get_sum_of_columns(lookup: recarray, country: str, year: int, columns_list: list) -> float:
+    return sum(
+        [safe_parse_float(
+            extract_grouped_data_closest_date(
+                data=get_table_value(lookup, 'termid', country, column_name(col)),
+                year=year
+            )
+        ) for col in columns_list]
+    )
+
+
+def get_single_delta(country: str, start_year: int, end_year: int, column: str):
     lookup = download_lookup('region-faostatArea.csv')
-    total_delta = _cropland_split_delta(
-        get_table_value(lookup, 'termid', country, column_name('Cropland')), start_year, end_year
+    return _split_delta(
+        get_table_value(lookup, 'termid', country, column_name(column)), start_year, end_year
     )
 
-    # get both values and only return result if we have both
-    permanent_delta = _cropland_split_delta(
-        get_table_value(lookup, 'termid', country, column_name('Permanent crops')), start_year, end_year
+
+def get_land_ratio(
+    country: str, start_year: int, end_year: int, first_column: str, second_column: str, total_column: str = None
+):
+    """
+    total_column is optional. Assumes that, if missing, total is the sum of values from first and second.
+    """
+    lookup = download_lookup('region-faostatArea.csv')
+    first_delta = _split_delta(
+        get_table_value(lookup, 'termid', country, column_name(first_column)), start_year, end_year
+    )
+    second_delta = _split_delta(
+        get_table_value(lookup, 'termid', country, column_name(second_column)), start_year, end_year
     )
-    temporary_delta = _cropland_split_delta(
-        get_table_value(lookup, 'termid', country, column_name('Arable land')), start_year, end_year
+    total_delta = (
+        get_sum_of_columns(
+            lookup=lookup,
+            country=country,
+            year=end_year,
+            columns_list=[first_column, second_column]
+        ) - get_sum_of_columns(
+            lookup=lookup,
+            country=country,
+            year=start_year,
+            columns_list=[first_column, second_column]
+        )
+    ) if total_column is None else _split_delta(
+        get_table_value(lookup, 'termid', country, column_name(total_column)), start_year, end_year
     )
 
     return (None, None, None) if any([
         total_delta is None,
-        permanent_delta is None,
-        temporary_delta is None
-    ]) else (total_delta, permanent_delta, temporary_delta)
+        first_delta is None,
+        second_delta is None
+    ]) else (total_delta, first_delta, second_delta)
+
+
+def get_cropland_ratio(country: str, start_year: int, end_year: int):
+    return get_land_ratio(
+        country=country,
+        start_year=start_year,
+        end_year=end_year,
+        first_column='Permanent crops',
+        second_column='Arable land',
+        total_column='Cropland'
+    )
+
+
+def get_change_in_harvested_area_for_crop(country_id: str, crop_name: str, start_year: int, end_year: int = 0):
+    lookup = download_lookup('region-crop-cropGroupingFaostatProduction-areaHarvested.csv')
+    if end_year == 0 or end_year == start_year:
+        return safe_parse_float(
+            extract_grouped_data_closest_date(
+                data=get_table_value(lookup, 'termid', country_id, column_name(crop_name)),
+                year=start_year
+            )
+        )
+    else:
+        return _split_delta(
+            get_table_value(lookup, 'termid', country_id, column_name(crop_name)), start_year, end_year
+        )

hestia_earth/models/hestia/__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 = 'hestia'
+PKG = '.'.join(['hestia_earth', 'models', MODEL])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))