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

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