hestia-earth-models 0.62.2__tar.gz → 0.62.4__tar.gz

{hestia-earth-models-0.62.2/hestia_earth_models.egg-info → hestia-earth-models-0.62.4}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.62.2
-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.).
+Version: 0.62.4
+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
+Author: HESTIA Team
 Author-email: guillaumeroyer.mail@gmail.com
 License: GPL
 Platform: UNKNOWN
@@ -13,16 +13,16 @@ Description-Content-Type: text/markdown
 Provides-Extra: spatial
 License-File: LICENSE
 
-# Hestia Engine Models
+# HESTIA Engine Models
 
 [![Pipeline Status](https://gitlab.com/hestia-earth/hestia-engine-models/badges/master/pipeline.svg)](https://gitlab.com/hestia-earth/hestia-engine-models/commits/master)
 [![Coverage Report](https://gitlab.com/hestia-earth/hestia-engine-models/badges/master/coverage.svg)](https://gitlab.com/hestia-earth/hestia-engine-models/commits/master)
 
-Hestia's set of models for running calculations or retrieving data using external datasets and internal lookups.
+HESTIA's set of models for running calculations or retrieving data using external datasets and internal lookups.
 
 ## Documentation
 
-Documentation for every model can be found in the [Hestia API Documentation](https://hestia.earth/docs/#hestia-calculation-models).
+Documentation for every model can be found in the [HESTIA API Documentation](https://hestia.earth/docs/#hestia-calculation-models).
 
 ## Install
 

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/README.md

@@ -1,13 +1,13 @@
-# Hestia Engine Models
+# HESTIA Engine Models
 
 [![Pipeline Status](https://gitlab.com/hestia-earth/hestia-engine-models/badges/master/pipeline.svg)](https://gitlab.com/hestia-earth/hestia-engine-models/commits/master)
 [![Coverage Report](https://gitlab.com/hestia-earth/hestia-engine-models/badges/master/coverage.svg)](https://gitlab.com/hestia-earth/hestia-engine-models/commits/master)
 
-Hestia's set of models for running calculations or retrieving data using external datasets and internal lookups.
+HESTIA's set of models for running calculations or retrieving data using external datasets and internal lookups.
 
 ## Documentation
 
-Documentation for every model can be found in the [Hestia API Documentation](https://hestia.earth/docs/#hestia-calculation-models).
+Documentation for every model can be found in the [HESTIA API Documentation](https://hestia.earth/docs/#hestia-calculation-models).
 
 ## Install
 

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/agribalyse2016/fuelElectricity.py

@@ -93,7 +93,7 @@ def _should_run_operation(cycle: dict):
 
         logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                         has_value=has_value,
-                        has_lookup_value=has_lookup_value)
+                        has_fuelUse_lookup_value=has_lookup_value)
 
         should_run = all([has_value, has_lookup_value])
         logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/cycle/animal/input/hestiaAggregatedData.py

@@ -1,5 +1,5 @@
 """
-Animal Input Hestia Aggregated Data
+Animal Input HESTIA Aggregated Data
 
 This model adds `impactAssessment` to Animal inputs based on data which has been aggregated into country level averages.
 Note: to get more accurate impacts, we recommend setting the

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/cycle/cycleDuration.py

@@ -10,7 +10,7 @@ from hestia_earth.schema import TermTermType
 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
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.crop import get_crop_grouping_fao
 from . import MODEL
 
@@ -66,7 +66,12 @@ def _run_by_crop(cycle: dict):
     grouping = get_crop_grouping_fao(MODEL, MODEL_KEY, product.get('term', {}))
     is_permanent_crop = grouping == 'Permanent crops'
     croppingIntensity = find_term_match(cycle.get('practices', []), 'croppingIntensity').get('value', [1])[0]
-    return DEFAULT_DURATION * (1 if is_permanent_crop else croppingIntensity)
+    ratio = 1 if is_permanent_crop else croppingIntensity
+    debugValues(cycle, model=MODEL, key=MODEL_KEY, by='product',
+                crop_grouping=grouping,
+                croppingIntensity=croppingIntensity,
+                ratio=ratio)
+    return round(DEFAULT_DURATION * ratio, 3)
 
 
 def _should_run_by_crop(cycle: dict):

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/cycle/input/hestiaAggregatedData.py

@@ -1,5 +1,5 @@
 """
-Input Hestia Aggregated Data
+Input HESTIA Aggregated Data
 
 This model adds `impactAssessment` to inputs based on data which has been aggregated into country level averages.
 Note: to get more accurate impacts, we recommend setting the

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/cycle/product/price.py

@@ -42,9 +42,13 @@ def _should_run_product_by_share_0(cycle: dict, product: dict):
     return should_run
 
 
+def _should_run_product(product: dict): return product.get(MODEL_KEY) is None
+
+
 def run(cycle: dict):
+    products = list(filter(_should_run_product, cycle.get('products', [])))
     return non_empty_list([
         (
             _product(p, 0) if _should_run_product_by_share_0(cycle, p) else None
-        ) for p in cycle.get('products', [])
+        ) for p in products
     ])

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/cycle/product/revenue.py

@@ -53,23 +53,22 @@ def _should_run(cycle: dict):
         has_yield_and_price = has_yield and has_price
         is_yield_0 = list_sum(product.get('value', []), -1) == 0
         is_price_0 = product.get('price', -1) == 0
-        not_already_set = MODEL_KEY not in product.keys()
 
         logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY,
-                        not_already_set=not_already_set,
                         has_yield_and_price=has_yield_and_price,
                         is_yield_0=is_yield_0,
                         is_price_0=is_price_0)
 
-        should_run = all([
-            not_already_set,
-            any([has_yield_and_price, is_yield_0, is_price_0])
-        ])
+        should_run = any([has_yield_and_price, is_yield_0, is_price_0])
         logShouldRun(cycle, MODEL, term_id, should_run, key=MODEL_KEY)
         return should_run
     return should_run_product
 
 
+def _should_run_product(product: dict): return product.get(MODEL_KEY) is None
+
+
 def run(cycle: dict):
-    products = list(filter(_should_run(cycle), cycle.get('products', [])))
+    products = list(filter(_should_run_product, cycle.get('products', [])))
+    products = list(filter(_should_run(cycle), products))
     return non_empty_list(map(_run(cycle), products))

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/ecoinventV3/__init__.py

@@ -4,7 +4,7 @@ ecoinvent v3
 This model calculates background emissions related to the production of Inputs from the ecoinvent database, version 3.
 
 Note: to use the `ecoinventV3` model locally or in the
-[Hestia Community Edition](https://gitlab.com/hestia-earth/hestia-community-edition) you need a valid ecoinvent license.
+[HESTIA Community Edition](https://gitlab.com/hestia-earth/hestia-community-edition) you need a valid ecoinvent license.
 Please contact us at community@hestia.earth for instructions to download the required file to run the model.
 
 **Pesticide Brand Name**
@@ -15,16 +15,15 @@ default list of [Pesticide Active Ingredient](https://hestia.earth/glossary?pest
 """
 from functools import reduce
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import flatten, list_sum, non_empty_list
+from hestia_earth.utils.tools import flatten, list_sum
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
 from hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
-from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.pesticideAI import get_pesticides_from_inputs
 from hestia_earth.models.utils.fertiliser import get_fertilisers_from_inputs
+from .utils import get_background_inputs, get_input_mappings
 
 REQUIREMENTS = {
     "Cycle": {
@@ -96,69 +95,43 @@ def _add_emission(cycle: dict, input: dict):
     def add(prev: dict, mapping: tuple):
         ecoinventName, coefficient = mapping
         emissions = ecoinventV3_emissions(ecoinventName)
-        for id, value in emissions:
+        for emission_term_id, value in emissions:
             # log run on each emission so we know it did run
-            debugValues(cycle, model=MODEL, term=id,
+            debugValues(cycle, model=MODEL, term=emission_term_id,
                         value=value,
                         coefficient=coefficient,
                         input=input_term_id,
                         operation=operation_term_id,
                         animal=animal_term_id)
-            prev[id] = prev.get(id, 0) + (value * coefficient)
+            prev[emission_term_id] = prev.get(emission_term_id, 0) + (value * coefficient)
         return prev
     return add
 
 
-def _get_input_mappings(cycle: dict, input: dict):
-    term = input.get('term', {})
-    term_id = term.get('@id')
-    value = get_lookup_value(term, 'ecoinventMapping', model=MODEL, term=term_id)
-    mappings = non_empty_list(value.split(';')) if value else []
-    logRequirements(cycle, model=MODEL, term=term_id,
-                    mappings=';'.join(mappings))
-    return [(m.split(':')[0], float(m.split(':')[1])) for m in mappings]
-
-
 def _run_input(cycle: dict):
     def run(inputs: list):
         input = inputs[0]
+        input_term_id = input.get('term', {}).get('@id')
         input_value = list_sum(flatten(input.get('value', []) for input in inputs))
-        mappings = _get_input_mappings(cycle, input)
-        term_id = input.get('term', {}).get('@id')
-        should_run = len(mappings) > 0
-        logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER)
-        grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
-        return [_emission(term_id, value * input_value, input) for term_id, value in grouped_emissions.items()]
-    return run
+        mappings = get_input_mappings(MODEL, cycle, input)
+        has_mappings = len(mappings) > 0
 
+        logRequirements(cycle, model=MODEL, term=input_term_id,
+                        has_ecoinvent_mappings=has_mappings,
+                        ecoinvent_mappings=';'.join([v[0] for v in mappings]))
 
-def _should_run_input(products: list):
-    def should_run(input: dict):
-        return all([
-            list_sum(input.get('value', [])) > 0,
-            # make sure Input is not a Product as well or we might double-count emissions
-            find_term_match(products, input.get('term', {}).get('@id'), None) is None,
-            # ignore inputs which are flagged as Product of the Cycle
-            not input.get('fromCycle', False),
-            not input.get('producedInCycle', False)
-        ])
-    return should_run
-
-
-def _animal_inputs(animal: dict):
-    inputs = animal.get('inputs', [])
-    return [(input | {'animal': animal.get('term', {})}) for input in inputs]
+        should_run = all([has_mappings])
+        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
+        grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
+        return [
+            _emission(term_id, value * input_value, input)
+            for term_id, value in grouped_emissions.items()
+        ]
+    return run
 
 
 def run(_, cycle: dict):
-    # add all the properties of some Term that inlcude others with the mapping
-    inputs = flatten(
-        cycle.get('inputs', []) +
-        list(map(_animal_inputs, cycle.get('animals', []))) +
-        get_pesticides_from_inputs(cycle) +
-        get_fertilisers_from_inputs(cycle)
-    )
-    inputs = list(filter(_should_run_input(cycle.get('products', [])), inputs))
-    # group inputs with same id/operation to avoid adding emissions twice
-    inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
-    return flatten(map(_run_input(cycle), inputs.values()))
+    extra_inputs = get_pesticides_from_inputs(cycle) + get_fertilisers_from_inputs(cycle)
+    inputs = get_background_inputs(cycle, extra_inputs=extra_inputs)
+    grouped_inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
+    return flatten(map(_run_input(cycle), grouped_inputs.values()))

hestia-earth-models-0.62.4/hestia_earth/models/ecoinventV3/utils.py

@@ -0,0 +1,40 @@
+from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import list_sum, flatten, non_empty_list
+
+from hestia_earth.models.utils.term import get_lookup_value
+
+
+def _animal_inputs(animal: dict):
+    inputs = animal.get('inputs', [])
+    return [(input | {'animal': animal.get('term', {})}) for input in inputs]
+
+
+def _should_run_input(products: list):
+    def should_run(input: dict):
+        return all([
+            list_sum(input.get('value', [])) > 0,
+            # make sure Input is not a Product as well or we might double-count emissions
+            find_term_match(products, input.get('term', {}).get('@id'), None) is None,
+            # ignore inputs which are flagged as Product of the Cycle
+            not input.get('fromCycle', False),
+            not input.get('producedInCycle', False)
+        ])
+    return should_run
+
+
+def get_background_inputs(cycle: dict, extra_inputs: list = []):
+    # add all the properties of some Term that inlcude others with the mapping
+    inputs = flatten(
+        cycle.get('inputs', []) +
+        list(map(_animal_inputs, cycle.get('animals', []))) +
+        extra_inputs
+    )
+    return list(filter(_should_run_input(cycle.get('products', [])), inputs))
+
+
+def get_input_mappings(model: str, cycle: dict, input: dict):
+    term = input.get('term', {})
+    term_id = term.get('@id')
+    value = get_lookup_value(term, 'ecoinventMapping', model=model, term=term_id)
+    mappings = non_empty_list(value.split(';')) if value else []
+    return [(m.split(':')[0], float(m.split(':')[1])) for m in mappings]

hestia-earth-models-0.62.4/hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -0,0 +1,144 @@
+"""
+ecoinvent v3 and Ember Climate
+
+This model calculates background emissions related to the production of Inputs from the ecoinvent database, version 3,
+and using the percentage of production for each energy source from
+[Ember](https://ember-climate.org/data-catalogue/yearly-electricity-data/).
+
+Note: to use the `ecoinventV3AndEmberClimate` model locally or in the
+[Hestia Community Edition](https://gitlab.com/hestia-earth/hestia-community-edition) you need a valid ecoinvent license.
+Please contact us at community@hestia.earth for instructions to download the required file to run the model.
+"""
+from functools import reduce
+from hestia_earth.utils.tools import list_sum, flatten
+from hestia_earth.schema import EmissionMethodTier
+
+from hestia_earth.models.log import logShouldRun, logRequirements, debugValues
+from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.blank_node import group_by_keys
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from hestia_earth.models.utils.term import get_electricity_grid_mix_terms
+from hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
+from .utils import get_input_coefficient
+from ..ecoinventV3.utils import get_background_inputs, get_input_mappings
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.electricityFuel": "True",
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "inputs": [{
+            "@type": "Input",
+            "term.@id": ["electricityGridMarketMix", "electricityGridRenewableMix"],
+            "value": "> 0",
+            "none": {
+                "fromCycle": "True",
+                "producedInCycle": "True"
+            }
+        }],
+        "optional": {
+            "animals": [{
+                "@type": "Animal",
+                "inputs": [{
+                    "@type": "Input",
+                    "term.@id": ["electricityGridMarketMix", "electricityGridRenewableMix"],
+                    "value": "> 0",
+                    "none": {
+                        "fromCycle": "True",
+                        "producedInCycle": "True"
+                    }
+                }]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "background",
+        "@type": "Emission",
+        "inputs": ""
+    }]
+}
+LOOKUPS = {
+    "electricity": "ecoinventMapping",
+    "region-ember-energySources": "using `country`",
+    "ember-ecoinvent-mapping": ["ember", "ecoinventId", "ecoinventName"]
+}
+
+MODEL = 'ecoinventV3AndEmberClimate'
+MODEL_KEY = 'impactAssessment'  # keep to generate entry in "model-links.json"
+TIER = EmissionMethodTier.BACKGROUND.value
+
+
+def _emission(term_id: str, value: float, input: dict):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = TIER
+    emission['inputs'] = [input.get('term')]
+    if input.get('operation'):
+        emission['operation'] = input.get('operation')
+    if input.get('animal'):
+        emission['animals'] = [input.get('animal')]
+    return emission
+
+
+def _add_emission(cycle: dict, input: dict):
+    input_term_id = input.get('term', {}).get('@id')
+    operation_term_id = input.get('operation', {}).get('@id')
+    animal_term_id = input.get('animal', {}).get('@id')
+    # TODO: as inputs are grouped, there could be more than 1 country
+    country_id = input.get('country', cycle.get('site', {}).get('country', {})).get('@id')
+
+    def add(prev: dict, mapping: tuple):
+        ecoinventName, _coefficient = mapping
+        # recalculate the coefficient using the country and year if it should be included
+        coefficient = get_input_coefficient(MODEL, cycle, country_id, ecoinventName) if _coefficient > 0 else 0
+        emissions = ecoinventV3_emissions(ecoinventName)
+        for emission_term_id, value in emissions:
+            # log run on each emission so we know it did run
+            debugValues(cycle, model=MODEL, term=emission_term_id,
+                        value=value,
+                        coefficient=coefficient,
+                        input=input_term_id,
+                        operation=operation_term_id,
+                        animal=animal_term_id)
+            prev[emission_term_id] = prev.get(emission_term_id, 0) + (value * coefficient)
+        return prev
+    return add
+
+
+def _run_input(cycle: dict):
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+
+    def run(inputs: list):
+        input = inputs[0]
+        input_value = list_sum(flatten(input.get('value', []) for input in inputs))
+        input_term_id = input.get('term', {}).get('@id')
+        mappings = get_input_mappings(MODEL, cycle, input)
+        has_mappings = len(mappings) > 0
+
+        logRequirements(cycle, model=MODEL, term=input_term_id,
+                        has_ecoinvent_mappings=has_mappings,
+                        ecoinvent_mappings=';'.join([v[0] for v in mappings]))
+
+        should_run = all([electricity_complete, has_mappings])
+        logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
+
+        grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
+        return [
+            _emission(term_id, value * input_value, input)
+            for term_id, value in grouped_emissions.items()
+        ]
+    return run
+
+
+def run(_, cycle: dict):
+    terms = get_electricity_grid_mix_terms()
+    inputs = get_background_inputs(cycle)
+    # only keep the inputs matching the grid terms
+    inputs = [i for i in inputs if i.get('term', {}).get('@id') in terms]
+    grouped_inputs = reduce(group_by_keys(['term', 'operation', 'animal']), inputs, {})
+    return flatten(map(_run_input(cycle), grouped_inputs.values()))

hestia-earth-models-0.62.4/hestia_earth/models/ecoinventV3AndEmberClimate/utils.py

@@ -0,0 +1,26 @@
+from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
+from hestia_earth.utils.tools import safe_parse_float
+
+from hestia_earth.models.log import debugMissingLookup
+from hestia_earth.models.utils.cycle import cycle_end_year
+
+EMBER_ECOINVENT_LOOKUP_NAME = "ember-ecoinvent-mapping.csv"
+REGION_EMBER_SOURCES_LOOKUP_NAME = "region-ember-energySources.csv"
+
+
+def get_input_coefficient(model: str, cycle: dict, country_id: str, ecoinventName: str):
+    year = cycle_end_year(cycle)
+
+    # find the matching ember source with the ecoinventName.
+    # example: "electricity, high voltage, electricity production, hard coal" > "Coal"
+    ember_ecoinvent_lookup = download_lookup(EMBER_ECOINVENT_LOOKUP_NAME)
+    source_name = get_table_value(ember_ecoinvent_lookup, column_name('ecoinventName'), ecoinventName, 'ember')
+
+    # find the ratio for the country / year
+    region_ember_sources_lookup = download_lookup(REGION_EMBER_SOURCES_LOOKUP_NAME)
+    data = get_table_value(region_ember_sources_lookup, 'termid', country_id, column_name(source_name))
+    percentage = extract_grouped_data(data, str(year))
+    debugMissingLookup(REGION_EMBER_SOURCES_LOOKUP_NAME,
+                       'termid', country_id, source_name, percentage, year=year, model=model)
+
+    return safe_parse_float(percentage, 0) / 100

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/faostat2018/liveweightPerHead.py

@@ -77,7 +77,7 @@ def _run_liveAnimal(cycle: dict, product: dict, year: int, country_id: str):
     product_id = product.get('term', {}).get('@id')
     animal_product_id = get_liveAnimal_to_animalProduct_id(product_id, LOOKUPS['liveAnimal'][0], term=TERM_ID)
 
-    animal_product_term = download_hestia(animal_product_id)
+    animal_product_term = download_hestia(animal_product_id) if animal_product_id else {}
     kg_liveweight, groupingFAO = _product_value({**product, 'term': animal_product_term}, year, country_id)
 
     logRequirements(cycle, model=MODEL, term=product_id, property=TERM_ID,

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/faostat2018/product/price.py

@@ -157,8 +157,7 @@ def _run_by_country(cycle: dict, product: dict, country_id: str, year: int = Non
     return _product(product, value / 1000 * conversion_to_number) if value is not None else None
 
 
-def _should_run_product(product: dict):
-    return product.get(MODEL_KEY) is None
+def _should_run_product(product: dict): return product.get(MODEL_KEY) is None
 
 
 def run(cycle: dict):

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/geospatialDatabase/croppingIntensity.py

@@ -37,7 +37,8 @@ TERM_ID = 'croppingIntensity'
 
 def _practice(value: float):
     practice = _new_practice(TERM_ID)
-    practice['value'] = [round(value, 7)]
+    # force conversion to float from numpy, avoiding errors when reading it in other models
+    practice['value'] = [float(round(value, 7))]
     return practice
 
 

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/geospatialDatabase/utils.py

@@ -152,7 +152,7 @@ def _get_cached_data(term: str, site: dict, data: dict):
 
 def download(term: str, site: dict, data: dict, only_coordinates=False) -> dict:
     """
-    Downloads data from Hestia Earth Engine API.
+    Downloads data from HESTIA Earth Engine API.
 
     Returns
     -------

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/ipcc2019/aboveGroundCropResidueTotal.py

@@ -2,7 +2,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.property import get_node_property
@@ -46,16 +46,21 @@ def _product_value(product: dict):
     value = list_sum(product.get('value'))
     dm = get_node_property(product, PROPERTY_KEY).get('value', 0)
     yield_dm = get_yield_dm(TERM_ID, term) or 0
-    debugValues(product, model=MODEL, term=TERM_ID,
-                product=term_id,
-                value=value,
-                dryMatter=dm,
-                ratio_yield_dm=yield_dm)
-    return value * dm / 100 * yield_dm
+    total = value * dm / 100 * yield_dm
+    return {
+        'id': term_id,
+        'value': value,
+        'dryMatter': dm,
+        'RatioYieldDM': yield_dm,
+        'total': total
+    }
 
 
-def _run(products: list):
-    value = sum(map(_product_value, products))
+def _run(cycle: dict, products: list):
+    values = list(map(_product_value, products))
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                details=log_as_table(values))
+    value = sum([value.get('total', 0) for value in values])
     return [_product(value)]
 
 
@@ -85,4 +90,4 @@ def _should_run(cycle: dict):
 
 def run(cycle: dict):
     should_run, products = _should_run(cycle)
-    return _run(products) if should_run else []
+    return _run(cycle, products) if should_run else []

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/ipcc2019/belowGroundCropResidue.py

@@ -2,7 +2,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import list_sum, safe_parse_float
 
-from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.property import get_node_property
@@ -52,17 +52,22 @@ def _product_value(product: dict):
     dm = get_node_property(product, PROPERTY_KEY).get('value', 0)
     yield_dm = get_yield_dm(TERM_ID, term) or 0
     ratio = _get_lookup_value(term, 'IPCC_2019_Ratio_BGRes_AGRes') or 0
-    debugValues(product, model=MODEL, term=TERM_ID,
-                product=term_id,
-                value=value,
-                dryMatter=dm,
-                ratio_yield_dm=yield_dm,
-                ratio=ratio)
-    return value * dm / 100 * yield_dm * ratio
+    total = value * dm / 100 * yield_dm * ratio
+    return {
+        'id': term_id,
+        'value': value,
+        'dryMatter': dm,
+        'RatioYieldDM': yield_dm,
+        'RatioAboveGroundToBelowGround': ratio,
+        'total': total
+    }
 
 
-def _run(products: list):
-    value = sum(map(_product_value, products))
+def _run(cycle: dict, products: list):
+    values = list(map(_product_value, products))
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                details=log_as_table(values))
+    value = sum([value.get('total', 0) for value in values])
     return [_product(value)]
 
 
@@ -92,4 +97,4 @@ def _should_run(cycle: dict):
 
 def run(cycle: dict):
     should_run, products = _should_run(cycle)
-    return _run(products) if should_run else []
+    return _run(cycle, products) if should_run else []

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/ipcc2019/carbonContent.py

@@ -114,7 +114,7 @@ def _multiple_product_values(crop: dict, residue_id: str):
     # LIGNIN_CONTENT_AG_CROP_RESIDUE or LIGNIN_CONTENT_BG_CROP_RESIDUE
     c_content = _get_lookup_value(term, _crop_residue_lookup_col(residue_id))
     ratio = _get_lookup_value(term, 'IPCC_2019_Ratio_BGRes_AGRes') if residue_id == 'belowGroundCropResidue' else 1
-    debugValues(crop, model=MODEL, term=residue_id,
+    debugValues(crop, model=MODEL, term=residue_id, property=TERM_ID,
                 crop=term_id,
                 dryMatter=dm,
                 ratio_yield_dm=yield_dm,

{hestia-earth-models-0.62.2 → hestia-earth-models-0.62.4}/hestia_earth/models/ipcc2019/croppingDuration.py

@@ -80,11 +80,11 @@ def _should_run(cycle: dict):
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     country=country,
                     has_flooded_rice=flooded_rice,
-                    cycleDuration=cycleDuration,
+                    cycleDuration=cycle.get('cycleDuration'),
                     croppingDuration=croppingDuration,
                     croppingDuration_below_cycleDuration=croppingDuration_below_cycleDuration)
 
-    should_run = all([country, cycleDuration, flooded_rice])
+    should_run = all([country, cycleDuration > 0, croppingDuration_below_cycleDuration, flooded_rice])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
     return should_run, country