hestia-earth-models 0.50.0__py3-none-any.whl → 0.51.1__py3-none-any.whl

hestia_earth/models/agribalyse2016/fuelElectricity.py

@@ -8,7 +8,7 @@ from hestia_earth.schema import InputStatsDefinition, TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import flatten, list_sum, non_empty_list
 
-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.term import get_lookup_value
 from hestia_earth.models.utils.input import _new_input
 from . import MODEL
@@ -53,9 +53,12 @@ def _operation_input(operation: dict):
 def _run_operation(cycle: dict):
     def exec(operations: list):
         input_term_id = operations[0].get('input').get('id')
-        values_logs = ';'.join([
-            f"id:{p.get('term').get('@id')}_value:{p.get('value')}_coefficient:{p.get('input').get('value')}"
-            for p in operations
+        values_logs = log_as_table([
+            {
+                'id': p.get('term').get('@id'),
+                'value': p.get('value'),
+                'coefficient': p.get('input').get('value')
+            } for p in operations
         ])
 
         debugValues(cycle, model=MODEL, term=input_term_id,

hestia_earth/models/agribalyse2016/machineryInfrastructureDepreciatedAmountPerCycle.py

@@ -10,9 +10,9 @@ the machinery-to-diesel ratio was doubled in countries with a [Human Development
 of less than 0.8.
 """
 from hestia_earth.schema import InputStatsDefinition
-from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import list_sum, flatten
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
 from hestia_earth.models.utils.productivity import _get_productivity, PRODUCTIVITY
 from hestia_earth.models.utils.input import _new_input
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
@@ -55,15 +55,24 @@ def _input(value: float):
 
 
 def _get_input_value_from_term(inputs: list, term_id: str):
-    val = find_term_match(inputs, term_id, None)
-    return val.get('value', [0])[0] if val is not None else 0
+    values = flatten([
+        input.get('value', []) for input in inputs if input.get('term', {}).get('@id') == term_id
+    ])
+    return list_sum(values, 0) if len(values) > 0 else None
 
 
 def get_value(country: dict, cycle: dict):
     liquid_fuels = get_liquid_fuel_terms()
     productivity_key = _get_productivity(country)
     machinery_usage = 11.5 if productivity_key == PRODUCTIVITY.HIGH else 23
-    fuel_use = sum([_get_input_value_from_term(cycle.get('inputs', []), term_id) for term_id in liquid_fuels])
+    values = [(term_id, _get_input_value_from_term(cycle.get('inputs', []), term_id)) for term_id in liquid_fuels]
+    value_logs = log_as_table([{'id': term_id, 'value': value} for term_id, value in values])
+    values = [value for term_id, value in values if value is not None]
+    fuel_use = list_sum(values, 0)
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                productivity_key=productivity_key.value,
+                fuel_use_details=value_logs,
+                fuel_use=fuel_use)
     return fuel_use/machinery_usage if fuel_use > 0 else None
 
 

hestia_earth/models/cycle/input/ecoinventV3.py

@@ -27,7 +27,13 @@ from hestia_earth.models.utils.blank_node import group_by_keys
 
 REQUIREMENTS = {
     "Cycle": {
-        "inputs": [{"@type": "Input", "value": "> 0"}]
+        "inputs": [{
+            "@type": "Input",
+            "value": "> 0",
+            "none": {
+                "fromCycle": "True"
+            }
+        }]
     }
 }
 RETURNS = {
@@ -113,7 +119,9 @@ def _should_run_input(products: list):
         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
+            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)
         ])
     return should_run
 

hestia_earth/models/cycle/input/hestiaAggregatedData.py

@@ -23,7 +23,8 @@ REQUIREMENTS = {
             "@type": "Input",
             "value": "",
             "none": {
-                "impactAssessment": ""
+                "impactAssessment": "",
+                "fromCycle": "True"
             },
             "optional": {
                 "country": {"@type": "Term", "termType": "region"},
@@ -196,7 +197,9 @@ def _should_run_input(products: list):
             not input.get(MODEL_KEY),
             _should_aggregate_input(term),
             # make sure Input is not a Product as well or we might double-count emissions
-            find_term_match(products, term.get('@id'), None) is None
+            find_term_match(products, term.get('@id'), None) is None,
+            # ignore inputs which are flagged as Product of the Cycle
+            not input.get('fromCycle', False)
         ])
     return should_run
 

hestia_earth/models/emepEea2019/co2ToAirFuelCombustion.py

@@ -10,7 +10,9 @@ REQUIREMENTS = {
     "Cycle": {
         "or": {
             "inputs": [
-                {"@type": "Input", "value": "", "term.termType": "fuel"}
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
             ],
             "completeness.electricityFuel": "True"
         }
@@ -24,7 +26,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "fuel": "co2ToAirFuelCombustionEmepEea2019"
+    "fuel": "co2ToAirFuelCombustionEmepEea2019",
+    "operation": "co2ToAirFuelCombustionEmepEea2019"
 }
 TERM_ID = 'co2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value

hestia_earth/models/emepEea2019/n2OToAirFuelCombustionDirect.py

@@ -10,7 +10,9 @@ REQUIREMENTS = {
     "Cycle": {
         "or": {
             "inputs": [
-                {"@type": "Input", "value": "", "term.termType": "fuel"}
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                     "operation": ""
+                }}
             ],
             "completeness.electricityFuel": "True"
         }
@@ -24,7 +26,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "fuel": "n2oToAirFuelCombustionEmepEea2019"
+    "fuel": "n2OToAirFuelCombustionEmepEea2019",
+    "operation": "n2OToAirFuelCombustionEmepEea2019"
 }
 TERM_ID = 'n2OToAirFuelCombustionDirect'
 TIER = EmissionMethodTier.TIER_1.value

hestia_earth/models/emepEea2019/nh3ToAirExcreta.py

@@ -3,9 +3,10 @@ from hestia_earth.utils.lookup import column_name, download_lookup, get_table_va
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, list_sum
 
-from hestia_earth.models.log import logRequirements, debugMissingLookup, logShouldRun
+from hestia_earth.models.log import logRequirements, debugMissingLookup, logShouldRun, log_as_table
 from hestia_earth.models.utils import _filter_list_term_unit
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.input import total_excreta_tan
 from . import MODEL
@@ -62,6 +63,8 @@ def _run(excreta_EF_product: float):
 
 
 def _should_run(cycle: dict):
+    excreta_complete = _is_term_type_complete(cycle, {'termType': TermTermType.EXCRETA.value})
+
     practices = filter_list_term_type(cycle.get('practices', []), TermTermType.EXCRETAMANAGEMENT)
     practice_id = practices[0].get('term', {}).get('@id') if len(practices) > 0 else None
 
@@ -71,18 +74,21 @@ def _should_run(cycle: dict):
     excreta_values = [
         (i.get('term', {}).get('@id'), total_excreta_tan([i]), _get_nh3_factor(practice_id, i)) for i in excreta
     ]
-    excreta_logs = ';'.join([f"id:{id}_value:{v}_EF:{f}" for id, v, f in excreta_values])
+    excreta_logs = log_as_table([
+        {'id': id, 'value': v, 'EF': ef} for id, v, ef in excreta_values
+    ])
     excreta_EF_products = [v * f for id, v, f in excreta_values if f is not None]
     has_excreta_EF_products = len(excreta_EF_products) > 0
-    excreta_EF_product = list_sum(excreta_EF_products)
+    excreta_EF_product = list_sum(excreta_EF_products, 0)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    excreta_complete=excreta_complete,
                     practice_id=practice_id,
                     excreta=excreta_logs,
                     excreta_EF_product=excreta_EF_product,
                     has_excreta_EF_products=has_excreta_EF_products)
 
-    should_run = all([has_excreta_EF_products])
+    should_run = excreta_complete or all([has_excreta_EF_products])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, excreta_EF_product
 

hestia_earth/models/emepEea2019/noxToAirFuelCombustion.py

@@ -10,7 +10,9 @@ REQUIREMENTS = {
     "Cycle": {
         "or": {
             "inputs": [
-                {"@type": "Input", "value": "", "term.termType": "fuel"}
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
             ],
             "completeness.electricityFuel": "True"
         }
@@ -24,7 +26,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "fuel": "noxToAirFuelCombustionEmepEea2019"
+    "fuel": "noxToAirFuelCombustionEmepEea2019",
+    "operation": "noxToAirFuelCombustionEmepEea2019"
 }
 TERM_ID = 'noxToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value

hestia_earth/models/emepEea2019/so2ToAirFuelCombustion.py

@@ -10,7 +10,9 @@ REQUIREMENTS = {
     "Cycle": {
         "or": {
             "inputs": [
-                {"@type": "Input", "value": "", "term.termType": "fuel"}
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
             ],
             "completeness.electricityFuel": "True"
         }
@@ -24,7 +26,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "fuel": "so2ToAirFuelCombustionEmepEea2019"
+    "fuel": "so2ToAirFuelCombustionEmepEea2019",
+    "operation": "so2ToAirFuelCombustionEmepEea2019"
 }
 TERM_ID = 'so2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value

hestia_earth/models/emepEea2019/utils.py

@@ -1,14 +1,33 @@
 from hestia_earth.schema import NodeType, TermTermType
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import non_empty_list
+from hestia_earth.utils.lookup import extract_grouped_data
+from hestia_earth.utils.tools import list_sum, safe_parse_float
 
 from hestia_earth.models.utils.completeness import _is_term_type_complete
-from hestia_earth.models.utils.lookup import factor_value
+from hestia_earth.models.utils.term import get_lookup_value
+from . import MODEL
+
+
+def _get_fuel_input_value(term_id: str, lookup_col: str):
+    def get_value(input: dict):
+        input_term = input.get('term', {})
+        input_term_id = input_term.get('@id')
+        operation_term = input.get('operation', {})
+        input_value = list_sum(input.get('value', []))
+
+        operation_factor = extract_grouped_data(
+            get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id), input_term_id
+        ) if operation_term else None
+        input_factor = operation_factor or get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id)
+
+        return input_value * safe_parse_float(input_factor)
+    return get_value
 
 
 def get_fuel_values(term_id: str, cycle: dict, lookup_col: str):
     inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
-    values = non_empty_list(map(factor_value(None, term_id, f"{TermTermType.FUEL.value}.csv", lookup_col), inputs))
+    values = list(map(_get_fuel_input_value(term_id, lookup_col), inputs))
+
     return [0] if all([
         len(values) == 0,
         _is_term_type_complete(cycle, {'termType': 'electricityFuel'}),

hestia_earth/models/environmentalFootprintV3/{freshwaterEcotoxicityPotentialPaf.py → freshwaterEcotoxicityPotentialCtue.py}

@@ -17,9 +17,9 @@ RETURNS = {
     }
 }
 LOOKUPS = {
-    "pesticideAI": "pafM3DFreshwaterEcotoxicityUsetoxHC20EC10eq"
+    "pesticideAI": "pafM3DFreshwaterEcotoxicityUsetox2-1Hc20Ec10eq"
 }
-TERM_ID = 'freshwaterEcotoxicityPotentialPaf'
+TERM_ID = 'freshwaterEcotoxicityPotentialCtue'
 
 
 def _indicator(value: float):

hestia_earth/models/geospatialDatabase/aware.py

@@ -11,7 +11,8 @@ REQUIREMENTS = {
     "Site": {
         "or": [
             {"latitude": "", "longitude": ""},
-            {"boundary": {}}
+            {"boundary": {}},
+            {"region": {"@type": "Term", "termType": "region"}}
         ]
     }
 }
@@ -27,15 +28,15 @@ EE_PARAMS = {
 
 
 def _download(site: dict):
-    return download(MODEL_KEY, site, EE_PARAMS, EE_PARAMS['field'], by_region=False)
+    return download(MODEL_KEY, site, EE_PARAMS, EE_PARAMS['field'])
 
 
 def _run(site: dict): return _download(site)
 
 
 def _should_run(site: dict):
-    contains_geospatial_data = has_geospatial_data(site, by_region=False)
-    below_max_area_size = should_download(MODEL_KEY, site, by_region=False)
+    contains_geospatial_data = has_geospatial_data(site)
+    below_max_area_size = should_download(MODEL_KEY, site)
 
     logRequirements(site, model=MODEL, model_key=MODEL_KEY,
                     contains_geospatial_data=contains_geospatial_data,

hestia_earth/models/geospatialDatabase/ecoregion.py

@@ -13,7 +13,8 @@ REQUIREMENTS = {
     "Site": {
         "or": [
             {"latitude": "", "longitude": ""},
-            {"boundary": {}}
+            {"boundary": {}},
+            {"region": {"@type": "Term", "termType": "region"}}
         ]
     }
 }
@@ -29,7 +30,7 @@ EE_PARAMS = {
 
 
 def _download(site: dict):
-    return download(MODEL_KEY, site, EE_PARAMS, EE_PARAMS['fields'], by_region=False)
+    return download(MODEL_KEY, site, EE_PARAMS, EE_PARAMS['fields'])
 
 
 def _run(site: dict):
@@ -41,8 +42,8 @@ def _run(site: dict):
 
 
 def _should_run(site: dict):
-    contains_geospatial_data = has_geospatial_data(site, by_region=False)
-    below_max_area_size = should_download(MODEL_KEY, site, by_region=False)
+    contains_geospatial_data = has_geospatial_data(site)
+    below_max_area_size = should_download(MODEL_KEY, site)
 
     logRequirements(site, model=MODEL, key=MODEL_KEY,
                     contains_geospatial_data=contains_geospatial_data,

hestia_earth/models/geospatialDatabase/region.py

@@ -8,15 +8,13 @@ from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import linked_node
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
-from .utils import download, has_geospatial_data, should_download
+from .utils import download, has_coordinates
 from . import MODEL
 
 REQUIREMENTS = {
     "Site": {
-        "or": [
-            {"latitude": "", "longitude": ""},
-            {"boundary": {}}
-        ]
+        "latitude": "",
+        "longitude": ""
     }
 }
 RETURNS = {
@@ -39,7 +37,7 @@ def _download_by_level(site: dict, level: int):
             'fields': field
         },
         field,
-        by_region=False
+        only_coordinates=True
     )
     try:
         return None if gadm_id is None else linked_node(download_hestia(f"GADM-{gadm_id}"))
@@ -60,14 +58,12 @@ def _run(site: dict):
 
 
 def _should_run(site: dict):
-    contains_geospatial_data = has_geospatial_data(site, by_region=False)
-    below_max_area_size = should_download(MODEL_KEY, site, by_region=False)
+    contains_coordinates = has_coordinates(site)
 
     logRequirements(site, model=MODEL, key=MODEL_KEY,
-                    contains_geospatial_data=contains_geospatial_data,
-                    below_max_area_size=below_max_area_size)
+                    contains_coordinates=contains_coordinates)
 
-    should_run = all([contains_geospatial_data, below_max_area_size])
+    should_run = all([contains_coordinates])
     logShouldRun(site, MODEL, None, should_run, key=MODEL_KEY)
     return should_run
 

hestia_earth/models/geospatialDatabase/utils.py

@@ -15,13 +15,16 @@ MAX_AREA_SIZE = int(os.getenv('MAX_AREA_SIZE', '5000'))
 def _collection_name(id: str): return id if '/' in id else f"users/hestiaplatform/{id}"
 
 
-def _has_coordinates(site: dict): return site.get('latitude') is not None and site.get('longitude') is not None
+def has_coordinates(site: dict): return all([site.get('latitude') is not None, site.get('longitude') is not None])
+
+
+def has_boundary(site: dict): return site.get('boundary') is not None
 
 
 def _site_gadm_id(site: dict): return site.get('region', site.get('country', {})).get('@id')
 
 
-def has_geospatial_data(site: dict, by_region=True):
+def has_geospatial_data(site: dict):
     """
     Determines whether the Site has enough geospatial data to run calculations. We are checking for:
     1. If the coordinates (latitude and longitude) are present
@@ -33,49 +36,60 @@ def has_geospatial_data(site: dict, by_region=True):
     ----------
     site : dict
         The `Site` node.
-    by_region : bool
-        If we can run using the region ID (`region` or `country` fields). Defaults to true.
 
     Returns
     -------
     bool
         If we should run geospatial calculations on this model or not.
     """
-    has_region = _site_gadm_id(site) is not None
-    has_boundary = site.get('boundary') is not None
-    return _has_coordinates(site) or (by_region and has_region) or has_boundary
+    return has_coordinates(site) or _site_gadm_id(site) is not None or has_boundary(site)
 
 
-def _geospatial_data(site: dict, by_region=True):
+def _geospatial_data(site: dict, only_coordinates=False):
     return {
         'latitude': site.get('latitude'),
         'longitude': site.get('longitude'),
-        'boundary': site.get('boundary'),
-        **({'gadm_id': _site_gadm_id(site)} if by_region else {})
+        **({} if only_coordinates else {
+            'boundary': site.get('boundary'),
+            'gadm_id': _site_gadm_id(site)
+        })
     }
 
 
-def should_download(term: str, site: dict, by_region=True) -> bool:
+def _get_geospatial_area_size(site: dict):
     try:
         from hestia_earth.earth_engine import get_size_km2
     except ImportError:
         raise ImportError("Run `pip install hestia_earth.earth_engine` to use this functionality")
 
     try:
-        current_size = get_size_km2(_geospatial_data(site, by_region))
-        # coordinates will not return a size
-        if current_size is not None:
-            logRequirements(site, model=MODEL, term=term,
-                            current_size=int(current_size),
-                            max_area_size=MAX_AREA_SIZE)
-            return current_size <= MAX_AREA_SIZE
-        return True
-    except Exception as e:
-        # if the type is unknown, a geospatial param is missing and will be detected by `has_geospatial_data`
-        return 'Unkown type' in str(e)
+        return get_size_km2(_geospatial_data(site))
+    except Exception:
+        return None
+
+
+def _get_area_size(site: dict):
+    return (
+        # fallback if `boundary` provided but no `boundaryArea` was computed
+        site.get('boundaryArea') or _get_geospatial_area_size(site)
+    ) if has_boundary(site) else download_hestia(_site_gadm_id(site)).get('area')
+
+
+def _is_below_max_size(term: str, site: dict) -> bool:
+    current_size = _get_area_size(site)
+    if current_size is not None:
+        logRequirements(site, model=MODEL, term=term,
+                        current_size=int(current_size),
+                        max_area_size=MAX_AREA_SIZE)
+        return current_size <= MAX_AREA_SIZE
+    return True
+
+
+def should_download(term: str, site: dict) -> bool:
+    return has_coordinates(site) or _is_below_max_size(term, site)
 
 
-def download(term: str, site: dict, data: dict, field: str, by_region=True) -> dict:
+def download(term: str, site: dict, data: dict, field: str, only_coordinates=False) -> dict:
     """
     Downloads data from Hestia Earth Engine API.
 
@@ -93,7 +107,7 @@ def download(term: str, site: dict, data: dict, field: str, by_region=True) -> d
         collection = data.get('collection')
         res = run({
             **data,
-            **_geospatial_data(site, by_region=by_region),
+            **_geospatial_data(site, only_coordinates=only_coordinates),
             'max_area': MAX_AREA_SIZE,
             'collection': _collection_name(collection)
         })
@@ -124,7 +138,7 @@ def _coordinates_query(site: dict):
                 }
             }
         }
-    } if _has_coordinates(site) else None
+    } if has_coordinates(site) else None
 
 
 def _region_query(site: dict):

hestia_earth/models/geospatialDatabase/waterDepth.py

@@ -9,7 +9,8 @@ REQUIREMENTS = {
     "Site": {
         "or": [
             {"latitude": "", "longitude": ""},
-            {"boundary": {}}
+            {"boundary": {}},
+            {"region": {"@type": "Term", "termType": "region"}}
         ]
     }
 }
@@ -38,7 +39,7 @@ def _measurement(value: float):
 
 
 def _download(site: dict):
-    return download(TERM_ID, site, EE_PARAMS, EE_PARAMS['reducer'], by_region=False)
+    return download(TERM_ID, site, EE_PARAMS, EE_PARAMS['reducer'])
 
 
 def _run(site: dict):
@@ -47,8 +48,8 @@ def _run(site: dict):
 
 
 def _should_run(site: dict):
-    contains_geospatial_data = has_geospatial_data(site, by_region=False)
-    below_max_area_size = should_download(TERM_ID, site, by_region=False)
+    contains_geospatial_data = has_geospatial_data(site)
+    below_max_area_size = should_download(TERM_ID, site)
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,

hestia_earth/models/impact_assessment/__init__.py

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

hestia_earth/models/ipcc2019/ch4ToAirExcreta.py

@@ -4,7 +4,7 @@ from hestia_earth.utils.lookup import column_name, download_lookup, get_table_va
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, list_sum
 
-from hestia_earth.models.log import debugValues, logRequirements, debugMissingLookup, logShouldRun
+from hestia_earth.models.log import debugValues, logRequirements, debugMissingLookup, logShouldRun, log_as_table
 from hestia_earth.models.utils import _filter_list_term_unit
 from hestia_earth.models.utils.constant import Units
 from hestia_earth.models.utils.completeness import _is_term_type_complete
@@ -142,7 +142,9 @@ def _should_run(cycle: dict):
     excreta_values = [
         (i.get('term', {}).get('@id'), total_excreta([i], Units.KG_VS), _get_excreta_b0(country, i)) for i in excreta
     ]
-    excreta_logs = ';'.join([f"id:{id}_value:{v}_b0:{f}" for id, v, f in excreta_values])
+    excreta_logs = log_as_table([
+        {'id': id, 'value': v, 'b0': b0} for id, v, b0 in excreta_values
+    ])
     excreta_b0_product = list_sum([v * f for id, v, f in excreta_values])
 
     ch4_conv_factor = _get_ch4_conv_factor(cycle)

hestia_earth/models/ipcc2019/croppingDuration.py

@@ -76,7 +76,7 @@ def _should_run(cycle: dict):
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     country=country,
                     cycleDuration=cycleDuration,
-                    flooded_rice=flooded_rice)
+                    has_flooded_rice=flooded_rice)
 
     should_run = all([country, cycleDuration, flooded_rice])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)