hestia-earth-models 0.64.11__py3-none-any.whl → 0.64.13__py3-none-any.whl

hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -102,7 +102,7 @@ def _run(impact_assessment: dict):
         multiply_values([fresh_water, factor]),
         inputs_value
     ])
-    return _indicator(value)
+    return _indicator(value) if value is not None else None
 
 
 def _should_run(impact_assessment: dict):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandOccupation.py

@@ -83,7 +83,7 @@ def _run(impact_assessment: dict):
         multiply_values([land_occupation_m2_kg, factor]),
         inputs_value
     ])
-    return _indicator(value)
+    return _indicator(value) if value is not None else None
 
 
 def _should_run(impact_assessment: dict):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandTransformation.py

@@ -81,7 +81,7 @@ def _run(impact_assessment: dict):
         multiply_values([landTransformation, region_factor]),
         inputs_value
     ])
-    return _indicator(value)
+    return _indicator(value) if value is not None else None
 
 
 def _should_run(impact_assessment: dict):

hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsTotalLandUseEffects.py

@@ -59,8 +59,9 @@ def run(impact_assessment: dict):
     inputs_value = convert_value_from_cycle(
         product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
     )
+    value = sum_values([landUseEffects, inputs_value])
     logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
                     landUseEffects=landUseEffects,
                     inputs_value=inputs_value)
-    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
-    return _indicator(sum_values([landUseEffects, inputs_value]))
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cml2001Baseline/eutrophicationPotentialExcludingFate.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     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)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cml2001Baseline/terrestrialAcidificationPotentialIncludingFateAverageEurope.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     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)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cml2001NonBaseline/eutrophicationPotentialIncludingFateAverageEurope.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     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)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cml2001NonBaseline/terrestrialAcidificationPotentialExcludingFate.py

@@ -29,5 +29,5 @@ def run(impact_assessment: dict):
     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)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/cycle/completeness/seed.py

@@ -15,7 +15,7 @@ REQUIREMENTS = {
     "Cycle": {
         "completeness.seed": "False",
         "inputs": [
-            {"@type": "Input", "value": "", "term.@id": ["seed", "saplings"]}
+            {"@type": "Input", "value": "", "term.@id": ["seed", "saplingsDepreciatedAmountPerCycle"]}
         ],
         "site": {
             "@type": "Site",
@@ -46,11 +46,13 @@ def run(cycle: dict):
 
     product = find_primary_product(cycle) or {}
     term_id = product.get('term', {}).get('@id')
-    has_saplings = find_term_match(cycle.get('inputs', []), 'saplings', None) and is_plantation(MODEL, None, term_id)
+    has_saplingsDepreciatedAmountPerCycle = find_term_match(cycle.get('inputs', []),
+                                                            'saplingsDepreciatedAmountPerCycle',
+                                                            None) and is_plantation(MODEL, None, term_id)
 
     logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
                     site_type_allowed=site_type_allowed,
                     has_seed=has_seed,
-                    has_saplings=has_saplings)
+                    has_saplingsDepreciatedAmountPerCycle=has_saplingsDepreciatedAmountPerCycle)
 
-    return all([site_type_allowed, has_seed or has_saplings])
+    return all([site_type_allowed, has_seed or has_saplingsDepreciatedAmountPerCycle])

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,58 @@ 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') is not None, value.get('input-value') is not None])
+    ]
+    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')
+
+    def fallback_value(input: dict):
+        value = get_node_property_value(
+            MODEL, input, 'crudeProteinContent', handle_percents=False, term=term_id, property=property_id
+        )
+        return value * 0.16 if value is not None else None
+
+    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 fallback_value(input=i)
+    } for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
 
 

hestia_earth/models/cycle/endDate.py

@@ -8,6 +8,7 @@ assumed it ended on the 14th of the month.
 from hestia_earth.utils.date import is_in_months
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils import last_day_of_month
 from . import MODEL
 
 REQUIREMENTS = {
@@ -24,9 +25,17 @@ RETURNS = {
 MODEL_KEY = 'endDate'
 
 
+def _end_of_month(date: str):
+    year = int(date[0:4])
+    month = int(date[5:7])
+    return last_day_of_month(year, month).strftime('%Y-%m-%d')
+
+
 def _run(cycle: dict):
     endDate = cycle.get('endDate')
-    return f"{endDate}-14"
+    is_same_month = endDate[0:7] == cycle.get('startDate', '')[0:7]
+    # end of the month if same month as startDate
+    return _end_of_month(endDate) if is_same_month else f"{endDate}-14"
 
 
 def _should_run(cycle: dict):

hestia_earth/models/cycle/milkYield.py

@@ -87,15 +87,16 @@ def _run(cycle: dict, product: dict):
 
     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)
+    animal_value = live_animal_node.get('value', 0)
 
-    value = list_sum(product.get('value')) / cycleDuration / live_animal_node.get('value')
-    sd = list_sum(product.get('sd')) / cycleDuration / live_animal_node.get('value') if all([
+    value = list_sum(product.get('value')) / cycleDuration / animal_value
+    sd = list_sum(product.get('sd')) / cycleDuration / animal_value if all([
         list_sum(product.get('sd', [])) > 0
     ]) else None
-    min = list_sum(product.get('min')) / cycleDuration / live_animal_node.get('value') if all([
+    min = list_sum(product.get('min')) / cycleDuration / animal_value if all([
         list_sum(product.get('min', [])) > 0
     ]) else None
-    max = list_sum(product.get('max')) / cycleDuration / live_animal_node.get('value') if all([
+    max = list_sum(product.get('max')) / cycleDuration / animal_value if all([
         list_sum(product.get('max', [])) > 0
     ]) else None
 
@@ -136,7 +137,7 @@ def _should_run_product(cycle: dict, product: dict):
                     missing_milkYield_practice=missing_milkYield_practice)
 
     should_run = all([
-        has_product_value, has_live_animal_node_value, practice_id, missing_milkYield_practice
+        cycleDuration, has_product_value, has_live_animal_node_value, practice_id, missing_milkYield_practice
     ])
     logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
     return should_run

hestia_earth/models/cycle/startDate.py

@@ -36,22 +36,24 @@ def _run_by_cycleDuration(cycle: dict):
 
 def _should_run_by_cycleDuration(cycle: dict):
     has_endDate = cycle.get('endDate') is not None
-    has_day_precision = has_endDate and is_in_days(cycle.get('endDate'))
+    has_endDate_day_precision = has_endDate and is_in_days(cycle.get('endDate'))
     has_cycleDuration = cycle.get('cycleDuration') is not None
 
     logRequirements(cycle, model=MODEL, key=MODEL_KEY, by='cycleDuration',
                     has_endDate=has_endDate,
-                    has_day_precision=has_day_precision,
+                    has_endDate_day_precision=has_endDate_day_precision,
                     has_cycleDuration=has_cycleDuration)
 
-    should_run = all([has_endDate, has_day_precision, has_cycleDuration])
+    should_run = all([has_endDate, has_endDate_day_precision, has_cycleDuration])
     logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY, by='cycleDuration')
     return should_run
 
 
 def _run_by_startDate(cycle: dict):
     startDate = cycle.get('startDate')
-    return f"{startDate}-15"
+    is_same_month = startDate[0:7] == cycle.get('endDate', '')[0:7]
+    # start of the month if same month as end date
+    return f"{startDate}-01" if is_same_month else f"{startDate}-15"
 
 
 def _should_run_by_startDate(cycle: dict):

hestia_earth/models/edip2003/ozoneDepletionPotential.py

@@ -30,5 +30,5 @@ def run(impact_assessment: dict):
     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)
-    return _indicator(value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth/models/emissionNotRelevant/__init__.py

@@ -4,9 +4,10 @@ Emission not relevant
 The emission is not relevant for this Site, Cycle, or Product.
 """
 from hestia_earth.schema import NodeType, TermTermType, EmissionMethodTier
+from hestia_earth.utils.emission import emission_is_in_system_boundary
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission, is_in_system_boundary
+from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.blank_node import _run_required
 from hestia_earth.models.utils.term import get_all_emission_terms
 
@@ -38,7 +39,7 @@ def _emission(term_id: str):
 def _should_run_emission(cycle: dict):
     def run(term_id: str):
         is_not_relevant = not _run_required(MODEL, {'@id': term_id, 'termType': TermTermType.EMISSION.value}, cycle)
-        in_system_boundary = is_in_system_boundary(term_id)
+        in_system_boundary = emission_is_in_system_boundary(term_id)
 
         should_run = all([is_not_relevant, in_system_boundary])
         if should_run:

hestia_earth/models/environmentalFootprintV3/freshwaterEcotoxicityPotentialCtue.py

@@ -1,5 +1,5 @@
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.pesticideAI import impact_lookup_value, impact_value_set_none
+from hestia_earth.models.utils.pesticideAI import impact_lookup_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -30,5 +30,4 @@ def _indicator(value: float):
 
 def run(impact_assessment: dict):
     value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['pesticideAI'])
-    should_run = any([value is not None, impact_value_set_none(impact_assessment)])
-    return _indicator(value) if should_run else None
+    return _indicator(value) if value is not None else None

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))