hestia-earth-models 0.73.7__py3-none-any.whl → 0.73.8__py3-none-any.whl

hestia_earth/models/dammgen2009/noxToAirExcreta.py

@@ -22,7 +22,7 @@ RETURNS = {
 }
 TERM_ID = 'noxToAirExcreta'
 TIER = EmissionMethodTier.TIER_1.value
-N2O_TERM_ID = 'n2OToAirExcretaDirect'
+_N2O_TERM_ID = 'n2OToAirExcretaDirect'
 
 
 def _emission(value: float):
@@ -32,22 +32,24 @@ def _emission(value: float):
     return emission
 
 
-def _run(n2o: dict):
-    value = 0.1 * list_sum(n2o.get("value", [])) / get_atomic_conversion(Units.KG_N2O, Units.TO_N)
+def _run(n2o_value: float):
+    value = 0.1 * n2o_value / get_atomic_conversion(Units.KG_N2O, Units.TO_N)
     value = value * get_atomic_conversion(Units.KG_NOX, Units.TO_N)
     return [_emission(value)]
 
 
 def _should_run(cycle: dict):
-    n2o = find_term_match(cycle.get('emissions', []), N2O_TERM_ID)
+    n2o = find_term_match(cycle.get('emissions', []), _N2O_TERM_ID)
+    n2o_value = list_sum(n2o.get("value", []), default=None)
 
-    logRequirements(cycle, model=MODEL, term=TERM_ID, has_n2o=n2o is not None)
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    **{_N2O_TERM_ID: n2o_value})
 
-    should_run = all([n2o])
+    should_run = all([n2o_value is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, n2o
+    return should_run, n2o_value
 
 
 def run(cycle: dict):
-    should_run, n2o = _should_run(cycle)
-    return _run(n2o) if should_run else []
+    should_run, n2o_value = _should_run(cycle)
+    return _run(n2o_value) if should_run else []

hestia_earth/models/ecoalimV9/cycle.py

@@ -1,13 +1,17 @@
 from functools import reduce
 from statistics import mean
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, list_sum
 
-from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
+from hestia_earth.models.log import logShouldRun, logRequirements
 from hestia_earth.models.utils.emission import _new_emission
-from hestia_earth.models.utils.background_emissions import get_background_inputs, no_gap_filled_background_emissions
+from hestia_earth.models.utils.background_emissions import (
+    get_background_inputs,
+    no_gap_filled_background_emissions,
+    log_missing_emissions
+)
 from hestia_earth.models.utils.blank_node import group_by_keys
-from .utils import get_input_mappings, ecoalim_values
+from .utils import get_input_mappings, process_input, parse_term_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -46,19 +50,19 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "ecoalim-emissionsResourceUse": "emission-",
-    "crop": "ecoalimMapping",
-    "processedFood": "ecoalimMapping",
+    "ecoalim-emission": "emission-",
     "animalProduct": "ecoalimMapping",
+    "crop": "ecoalimMapping",
+    "feedFoodAdditive": "ecoalimMapping",
     "forage": "ecoalimMapping",
-    "feedFoodAdditive": "ecoalimMapping"
+    "processedFood": "ecoalimMapping"
 }
 MODEL_KEY = 'cycle'
 TIER = EmissionMethodTier.BACKGROUND.value
 
 
-def _emission(term_id: str, value: float, input: dict):
-    emission = _new_emission(term_id, MODEL)
+def _emission(term_id: str, value: float, input: dict, country_id: str = None, key_id: str = None):
+    emission = _new_emission(term_id, MODEL, country_id, key_id)
     emission['value'] = [value]
     emission['methodTier'] = TIER
     emission['inputs'] = [input.get('term')]
@@ -69,32 +73,9 @@ def _emission(term_id: str, value: float, input: dict):
     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')
-
-    def add(prev: dict, mapping: tuple):
-        gadm_id, ecoalim_key = mapping
-        # all countries have the same coefficient
-        coefficient = 1
-        emissions = ecoalim_values(ecoalim_key, 'emission')
-        for emission_term_id, value in emissions:
-            # log run on each emission so we know it did run
-            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=emission_term_id)
-            debugValues(cycle, model=MODEL, term=emission_term_id, model_key=MODEL_KEY,
-                        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, []) + [value * coefficient]
-        return prev
-    return add
-
-
 def _run_input(cycle: dict):
     no_gap_filled_background_emissions_func = no_gap_filled_background_emissions(cycle)
+    log_missing_emissions_func = log_missing_emissions(cycle, model=MODEL, methodTier=TIER)
 
     def run(inputs: list):
         input = inputs[0]
@@ -107,18 +88,27 @@ def _run_input(cycle: dict):
         has_no_gap_filled_background_emissions = no_gap_filled_background_emissions_func(input)
 
         logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
-                        has_ecoalim_mappings=has_mappings,
-                        ecoalim_mappings=';'.join([v[1] for v in mappings]),
+                        has_mappings=has_mappings,
+                        mappings=';'.join([v[1] for v in mappings]),
                         has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
                         input_value=input_value)
 
         should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY)
 
-        grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
+        results = process_input(
+            cycle, input, mappings, TermTermType.EMISSION, model_key=MODEL_KEY
+        ) if should_run else {}
+        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())))
         return [
-            _emission(term_id, mean(value) * input_value, input)
-            for term_id, value in grouped_emissions.items()
+            _emission(
+                term_id=parse_term_id(term_id),
+                value=mean([v['value'] * v['coefficient'] for v in values]) * input_value,
+                input=input,
+                country_id=values[0].get('country'),
+                key_id=values[0].get('key'),
+            )
+            for term_id, values in results.items()
         ]
     return run
 

hestia_earth/models/ecoalimV9/impact_assessment.py

@@ -1,13 +1,13 @@
 from functools import reduce
 from statistics import mean
-from hestia_earth.schema import IndicatorMethodTier
+from hestia_earth.schema import IndicatorMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, list_sum
 
-from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
+from hestia_earth.models.log import logShouldRun, logRequirements
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.background_emissions import get_background_inputs
+from hestia_earth.models.utils.background_emissions import get_background_inputs, log_missing_emissions
 from hestia_earth.models.utils.blank_node import group_by_keys
-from .utils import get_input_mappings, ecoalim_values
+from .utils import get_input_mappings, process_input, parse_term_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -48,19 +48,27 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "ecoalim-emissionsResourceUse": "resourceUse-",
-    "crop": "ecoalimMapping",
-    "processedFood": "ecoalimMapping",
+    "ecoalim-resourceUse": "resourceUse-",
     "animalProduct": "ecoalimMapping",
+    "crop": "ecoalimMapping",
+    "feedFoodAdditive": "ecoalimMapping",
     "forage": "ecoalimMapping",
-    "feedFoodAdditive": "ecoalimMapping"
+    "processedFood": "ecoalimMapping"
 }
 MODEL_KEY = 'impact_assessment'
 TIER = IndicatorMethodTier.BACKGROUND.value
 
 
-def _indicator(term_id: str, value: float, input: dict):
-    indicator = _new_indicator(term_id, MODEL)
+def _indicator(
+    term_id: str,
+    value: float,
+    input: dict,
+    country_id: str = None,
+    key_id: str = None,
+    land_cover_id: str = None,
+    previous_land_cover_id: str = None,
+):
+    indicator = _new_indicator(term_id, MODEL, land_cover_id, previous_land_cover_id, country_id, key_id)
     indicator['value'] = value
     indicator['methodTier'] = TIER
     indicator['inputs'] = [input.get('term')]
@@ -69,32 +77,11 @@ def _indicator(term_id: str, value: float, input: dict):
     return indicator
 
 
-def _add_indicator(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')
-
-    def add(prev: dict, mapping: tuple):
-        gadm_id, ecoalim_key = mapping
-        # all countries have the same coefficient
-        coefficient = 1
-        indicators = ecoalim_values(ecoalim_key, 'resourceUse')
-        for indicator_term_id, value in indicators:
-            # log run on each indicator so we know it did run
-            logShouldRun(cycle, MODEL, input_term_id, True, methodTier=TIER, emission_id=indicator_term_id)
-            debugValues(cycle, model=MODEL, term=indicator_term_id, model_key=MODEL_KEY,
-                        value=value,
-                        coefficient=coefficient,
-                        input=input_term_id,
-                        operation=operation_term_id,
-                        animal=animal_term_id)
-            if value is not None:
-                prev[indicator_term_id] = prev.get(indicator_term_id, []) + [value * coefficient]
-        return prev
-    return add
-
-
 def _run_input(impact_assessment: dict):
+    log_missing_emissions_func = log_missing_emissions(
+        impact_assessment, TermTermType.RESOURCEUSE, model=MODEL, methodTier=TIER
+    )
+
     def run(inputs: list):
         input = inputs[0]
         input_term_id = input.get('term', {}).get('@id')
@@ -103,8 +90,8 @@ def _run_input(impact_assessment: dict):
         has_mappings = len(mappings) > 0
 
         logRequirements(impact_assessment, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
-                        has_ecoalim_mappings=has_mappings,
-                        ecoalim_mappings=';'.join([v[1] for v in mappings]),
+                        has_mappings=has_mappings,
+                        mappings=';'.join([v[1] for v in mappings]),
                         input_value=input_value)
 
         should_run = all([has_mappings, input_value])
@@ -112,10 +99,21 @@ def _run_input(impact_assessment: dict):
             impact_assessment, MODEL, input_term_id, should_run, methodTier=TIER, model_key=MODEL_KEY
         )
 
-        grouped_indicators = reduce(_add_indicator(impact_assessment, input), mappings, {}) if should_run else {}
+        results = process_input(
+            impact_assessment, input, mappings, TermTermType.RESOURCEUSE, model_key=MODEL_KEY
+        ) if should_run else {}
+        log_missing_emissions_func(input_term_id, list(map(parse_term_id, results.keys())))
         return [
-            _indicator(term_id, mean(value) * input_value, input)
-            for term_id, value in grouped_indicators.items()
+            _indicator(
+                term_id=parse_term_id(term_id),
+                value=mean([v['value'] * v['coefficient'] for v in values]) * input_value,
+                input=input,
+                country_id=values[0].get('country'),
+                key_id=values[0].get('key'),
+                land_cover_id=values[0].get('landCover'),
+                previous_land_cover_id=values[0].get('previousLandCover'),
+            )
+            for term_id, values in results.items()
         ]
     return run
 

hestia_earth/models/ecoalimV9/utils.py

@@ -1,10 +1,15 @@
-from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, lookup_columns
-from hestia_earth.utils.tools import non_empty_list
+from functools import lru_cache, reduce
+from hestia_earth.schema import EmissionMethodTier, TermTermType
+from hestia_earth.utils.lookup import download_lookup, _is_missing_value, column_name, lookup_columns
+from hestia_earth.utils.tools import non_empty_list, safe_parse_float
 
+from hestia_earth.models.log import debugValues, logShouldRun
+from hestia_earth.models.utils import _omit
 from hestia_earth.models.utils.term import get_lookup_value
+from . import MODEL
 
-
-_LOOKUP = "ecoalim-emissionsResourceUse.csv"
+_LOOKUP_INDEX_KEY = column_name('ecoalimMappingName')
+_TIER = EmissionMethodTier.BACKGROUND.value
 
 
 def get_input_mappings(model: str, input: dict):
@@ -15,17 +20,78 @@ def get_input_mappings(model: str, input: dict):
     return [(m.split(':')[0], m.split(':')[1]) for m in mappings]
 
 
-def ecoalim_values(mapping: str, column_prefix: str):
-    lookup = download_lookup(_LOOKUP)
-    col_name = column_name('ecoalimMappingName')
+def parse_term_id(term_id: str): return term_id.split('-')[0]
+
+
+def _process_mapping(node: dict, input: dict, term_type: TermTermType, **log_args):
+    input_term_id = input.get('term', {}).get('@id')
+    operation_term_id = input.get('operation', {}).get('@id')
+    animal_term_id = input.get('animal', {}).get('@id')
+
+    def add(prev: dict, mapping: tuple):
+        gadm_id, ecoalim_key = mapping
+        # all countries have the same coefficient
+        coefficient = 1
+        values = ecoalim_values(ecoalim_key, term_type)
+        for term_id, data in values:
+            # log run on each node so we know it did run
+            logShouldRun(node, MODEL, input_term_id, True, methodTier=_TIER, emission_id=term_id)
+            debugValues(node, model=MODEL, term=term_id,
+                        value=data.get('value'),
+                        coefficient=coefficient,
+                        input=input_term_id,
+                        operation=operation_term_id,
+                        animal=animal_term_id,
+                        **log_args)
+            group_id = '-'.join(non_empty_list([term_id] + list(_omit(data, ['value']).values())))
+            prev[group_id] = prev.get(group_id, []) + [data | {'coefficient': coefficient}]
+        return prev
+    return add
+
+
+def process_input(node: dict, input: dict, mappings: list, term_type: TermTermType, **log_args):
+    return reduce(_process_mapping(node, input, term_type, **log_args), mappings, {})
+
+
+_KEY_TO_FIELD = {
+    'inputs': 'key'
+}
+
+
+def _key_to_field(key: str): return _KEY_TO_FIELD.get(key) or key
+
+
+def _values_from_column(column: str, value: str):
+    values = column.split('+')
+    term_id = values[0]
+    value = safe_parse_float(value, default=None)
+    return {
+        term_id: {
+            'value': value
+        } | {
+            _key_to_field(v.split('[')[0]): v.split('[')[1][:-1] for v in values[1:]
+        }
+    } if all([
+        column != _LOOKUP_INDEX_KEY,
+        not _is_missing_value(value)
+    ]) else {}
+
+
+@lru_cache()
+def _build_lookup(term_type: str):
+    lookup = download_lookup(f"ecoalim-{term_type}.csv", keep_in_memory=False)
+    columns = lookup_columns(lookup)
+    return {
+        row[_LOOKUP_INDEX_KEY]: reduce(
+            lambda prev, curr: prev | _values_from_column(curr, row[curr]),
+            columns,
+            {}
+        )
+        for row in lookup
+    }
 
-    def emission(column: str):
-        id = get_table_value(lookup, col_name, mapping, column)
-        value = get_table_value(lookup, col_name, mapping, column.replace('term', 'value'))
-        return (id, value) if id else None
 
-    columns = [
-        col for col in lookup_columns(lookup)
-        if col.startswith(column_name(column_prefix)) and col.endswith(column_name('term'))
-    ]
-    return non_empty_list(map(emission, columns))
+@lru_cache()
+def ecoalim_values(mapping: str, term_type: TermTermType):
+    data = _build_lookup(term_type.value)
+    return list(data[mapping].items())

hestia_earth/models/ecoinventV3/__init__.py

@@ -129,11 +129,11 @@ def _run_input(cycle: dict):
         should_run = all([has_mappings, has_no_gap_filled_background_emissions, input_value])
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER, **extra_logs)
 
-        grouped_emissions = reduce(_add_emission(cycle, input, **extra_logs), mappings, {}) if should_run else {}
-        log_missing_emissions_func(input_term_id, list(grouped_emissions.keys()), **extra_logs)
+        results = reduce(_add_emission(cycle, input, **extra_logs), mappings, {}) if should_run else {}
+        log_missing_emissions_func(input_term_id, list(results.keys()), **extra_logs)
         return [
             _emission(term_id, value * input_value, input)
-            for term_id, value in grouped_emissions.items()
+            for term_id, value in results.items()
         ]
     return run
 

hestia_earth/models/emepEea2019/n2OToAirFuelCombustionDirect.py

@@ -26,8 +26,8 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "fuel": "n2OToAirFuelCombustionEmepEea2019",
-    "operation": "n2OToAirFuelCombustionEmepEea2019"
+    "fuel": "n2oToAirFuelCombustionEmepEea2019",
+    "operation": "n2oToAirFuelCombustionEmepEea2019"
 }
 TERM_ID = 'n2OToAirFuelCombustionDirect'
 TIER = EmissionMethodTier.TIER_1.value

hestia_earth/models/hestia/default_emissions.py

@@ -1,10 +1,9 @@
 from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import flatten, safe_parse_float
-from hestia_earth.utils.emission import cycle_emissions_in_system_boundary
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils import _omit
-from hestia_earth.models.utils.emission import _new_emission
+from hestia_earth.models.utils.emission import _new_emission, background_emissions_in_system_boundary
 from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.input import unique_background_inputs
@@ -51,10 +50,7 @@ def _default_value(input: dict):
 
 
 def _run_input(cycle: dict):
-    required_emission_term_ids = [
-        id for id in cycle_emissions_in_system_boundary(cycle)
-        if id.endswith('InputsProduction')
-    ]
+    required_emission_term_ids = background_emissions_in_system_boundary(cycle)
 
     def run(input: dict):
         input_term = input.get('input').get('term')

hestia_earth/models/hestia/default_resourceUse.py

@@ -1,9 +1,9 @@
 from hestia_earth.schema import IndicatorMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, safe_parse_float
-from hestia_earth.utils.emission import emissions_in_system_boundary
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils import _omit
+from hestia_earth.models.utils.emission import background_emissions_in_system_boundary
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.background_emissions import no_gap_filled_background_emissions
 from hestia_earth.models.utils.term import get_lookup_value
@@ -54,10 +54,7 @@ def _default_value(input: dict):
 
 
 def _run_input(impact: dict):
-    required_resourceUse_term_ids = [
-        id for id in emissions_in_system_boundary(TermTermType.RESOURCEUSE)
-        if id.endswith('InputsProduction')
-    ]
+    required_resourceUse_term_ids = background_emissions_in_system_boundary(impact, TermTermType.RESOURCEUSE)
 
     def run(input: dict):
         input_term = input.get('input').get('term')

hestia_earth/models/hestia/seed_emissions.py

@@ -109,10 +109,11 @@ def _map_group_emissions(group_id: str, required_emission_term_ids: list, emissi
     missing_emissions = list(filter(lambda v: v not in emission_ids, emissions))
     return {
         'group-id': group_id,
+        'is-group-in-system-boundary': group_id in required_emission_term_ids,
         'total-emissions': len(emissions),
         'included-emissions': len(included_emissions),
         'missing-emissions': '-'.join(missing_emissions),
-        'is-valid': len(emissions) == len(included_emissions)
+        'has-all-emissions': len(emissions) == len(included_emissions)
     }
 
 
@@ -140,7 +141,10 @@ def _filter_emissions(cycle: dict):
         for group_id in group_ids
     ]
     # only keep groups that have all emissions present in the Cycle
-    valid_groups = list(filter(lambda group: group.get('is-valid'), emissions_per_group))
+    valid_groups = list(filter(lambda group: all([
+        group.get('has-all-emissions'),
+        group.get('is-group-in-system-boundary')
+    ]), emissions_per_group))
     valid_group_ids = set([v.get('group-id') for v in valid_groups])
 
     # finally, only return emissions which groups are valid
@@ -283,7 +287,7 @@ def _should_run(cycle: dict):
         # log failed emissions to show in the logs
         for group in emissions_per_group:
             emission_id = group.get('group-id')
-            if not group.get('is-valid') or not should_run:
+            if not group.get('has-all-emissions') or not should_run:
                 logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY, emission_id=emission_id,
                                 **group,
                                 **_omit(seed_input, 'input'),

hestia_earth/models/impact_assessment/emissions.py

@@ -2,6 +2,7 @@ from hestia_earth.utils.tools import list_sum
 from hestia_earth.utils.emission import cycle_emissions_in_system_boundary
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils import _include
 from hestia_earth.models.utils.impact_assessment import get_product, convert_value_from_cycle
 from hestia_earth.models.utils.indicator import _new_indicator
 from . import MODEL
@@ -44,11 +45,8 @@ def _indicator(impact_assessment: dict, product: dict):
 
         if len(emission.get('inputs', [])):
             indicator['inputs'] = emission['inputs']
-        if emission.get('operation'):
-            indicator['operation'] = emission.get('operation')
-        if emission.get('transformation'):
-            indicator['transformation'] = emission.get('transformation')
-        return indicator
+
+        return indicator | _include(emission, ['operation', 'transformation', 'country', 'key'])
     return run
 
 

hestia_earth/models/ipcc2019/biocharOrganicCarbonPerHa.py

@@ -57,12 +57,16 @@ RETURNS = {
         "statsDefinition": "simulated",
         "observations": "",
         "dates": "",
+        "depthUpper": "",
+        "depthLower": "",
         "methodClassification": "tier 1 model"
     }]
 }
 TERM_ID = 'biocharOrganicCarbonPerHa'
 
 _ITERATIONS = 1000
+_DEPTH_UPPER = 0
+_DEPTH_LOWER = 30
 _METHOD_CLASSIFICATION = MeasurementMethodClassification.TIER_1_MODEL.value
 _STATS_DEFINITION = MeasurementStatsDefinition.SIMULATED.value
 
@@ -172,7 +176,7 @@ def _compile_inventory(
     cycle_data = {
         cycle.get("@id"): {
             "biochar_nodes": filter_list_term_type(cycle.get("inputs", []), TermTermType.BIOCHAR),
-            **{field: cycle.get(field) for field in COPY_FIELDS}
+            **{k: v for k in COPY_FIELDS if (v := cycle.get(k)) is not None}
         } for cycle in cycles
     }
 
@@ -201,7 +205,7 @@ def _compile_inventory(
         [
             {
                 "total_oc": total_oc.get(id, 0),
-                **{field: data.get(field) for field in COPY_FIELDS}
+                **data
             } for id, data in cycle_data.items()
         ],
         include_spillovers=True
@@ -427,9 +431,11 @@ def _measurement(
         "statsDefinition": statsDefinition,
         "observations": observations,
         "dates": dates,
+        "depthUpper": _DEPTH_UPPER,
+        "depthLower": _DEPTH_LOWER,
         "methodClassification": _METHOD_CLASSIFICATION
     }
     measurement = _new_measurement(TERM_ID, MODEL) | {
-        key: value for key, value in update_dict.items() if value
+        key: value for key, value in update_dict.items() if value is not None
     }
     return measurement

hestia_earth/models/ipcc2019/co2ToAirAboveGroundBiomassStockChange.py

@@ -78,9 +78,7 @@ def _emission(
     min: list[float] = None,
     max: list[float] = None,
     statsDefinition: str = None,
-    observations: list[int] = None,
-    start_date: str,
-    end_date: str
+    observations: list[int] = None
 ) -> dict:
     """
     Create an emission node based on the provided value and method tier.
@@ -108,8 +106,6 @@ def _emission(
         "max": max,
         "statsDefinition": statsDefinition,
         "observations": observations,
-        "startDate": start_date,
-        "endDate": end_date,
         "methodTier": method_tier.value,
     }
     emission = _new_emission(term_id, MODEL) | {

hestia_earth/models/ipcc2019/co2ToAirBelowGroundBiomassStockChange.py

@@ -69,9 +69,7 @@ def _emission(
     min: list[float] = None,
     max: list[float] = None,
     statsDefinition: str = None,
-    observations: list[int] = None,
-    start_date: str,
-    end_date: str
+    observations: list[int] = None
 ) -> dict:
     """
     Create an emission node based on the provided value and method tier.
@@ -99,8 +97,6 @@ def _emission(
         "max": max,
         "statsDefinition": statsDefinition,
         "observations": observations,
-        "startDate": start_date,
-        "endDate": end_date,
         "methodTier": method_tier.value,
         "depth": _DEPTH_LOWER
     }

hestia_earth/models/ipcc2019/co2ToAirCarbonStockChange_utils.py

@@ -2,7 +2,7 @@
 Utilities for calculating CO2 emissions based on changes in carbon stocks (e.g., `organicCarbonPerHa`,
 `aboveGroundBiomass` and `belowGroundBiomass`).
 """
-from datetime import datetime, timedelta
+from datetime import datetime
 from enum import Enum
 from functools import reduce
 from itertools import product
@@ -1506,8 +1506,6 @@ def create_run_function(
             new_emission_func(
                 term_id=emission_term_id,
                 method_tier=_get_emission_method(total_emission),
-                start_date=_get_emission_start_date(total_emission, cycle_start_date),
-                end_date=_get_emission_end_date(total_emission, cycle_end_date),
                 **calc_descriptive_stats(
                     total_emission.value,
                     EmissionStatsDefinition.SIMULATED,
@@ -1532,33 +1530,3 @@ def get_zero_emission(year):
 def _get_emission_method(emission: CarbonStockChangeEmission):
     method = emission.method
     return method if isinstance(method, EmissionMethodTier) else EmissionMethodTier.TIER_1
-
-
-def _get_emission_start_date(emission: CarbonStockChangeEmission, cycle_start_date: str) -> str:
-    cycle_datetime = safe_parse_date(_gapfill_datestr(cycle_start_date))
-    emission_datetime = safe_parse_date(emission.start_date)
-
-    should_run = (
-        cycle_datetime and emission_datetime
-        and cycle_datetime < emission_datetime  # If the cycle starts before the emission, add a `startDate`
-    )
-
-    return (
-        (emission_datetime + timedelta(seconds=1)).strftime(DatestrFormat.YEAR_MONTH_DAY.value) if should_run
-        else None
-    )
-
-
-def _get_emission_end_date(emission: CarbonStockChangeEmission, cycle_end_date: str) -> str:
-    cycle_datetime = safe_parse_date(_gapfill_datestr(cycle_end_date, DatestrGapfillMode.END))
-    emission_datetime = safe_parse_date(emission.end_date)
-
-    should_run = (
-        cycle_datetime and emission_datetime
-        and cycle_datetime > emission_datetime  # If the cycle ends after the emission, add an `endDate`
-    )
-
-    return (
-        emission_datetime.strftime(DatestrFormat.YEAR_MONTH_DAY.value) if should_run
-        else None
-    )