hestia-earth-models 0.64.11__tar.gz → 0.64.12__tar.gz

{hestia-earth-models-0.64.11/hestia_earth_models.egg-info → hestia-earth-models-0.64.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.64.11
+Version: 0.64.12
 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.11 → hestia-earth-models-0.64.12}/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-0.64.11 → hestia-earth-models-0.64.12}/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-0.64.12/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))