hestia-earth-models 0.70.5__py3-none-any.whl → 0.70.6__py3-none-any.whl

hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -118,6 +118,7 @@ def _run_input(cycle: dict):
                         has_ecoinvent_mappings=has_mappings,
                         ecoinvent_mappings=';'.join([v[0] for v in mappings]),
                         has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions,
+                        termType_electricityFuel_complete=electricity_complete,
                         input_value=input_value)
 
         should_run = all([electricity_complete, has_mappings, has_no_gap_filled_background_emissions, input_value])

hestia_earth/models/emepEea2019/co2ToAirFuelCombustion.py

@@ -1,8 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from .utils import get_fuel_values, _emission
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
 from . import MODEL
 
 REQUIREMENTS = {
@@ -20,6 +20,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Emission": [{
         "value": "",
+        "inputs": "",
+        "operation": "",
         "methodTier": "tier 1"
     }]
 }
@@ -31,23 +33,26 @@ TERM_ID = 'co2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _run(fuel_values: list):
-    value = list_sum(fuel_values)
-    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
-
-
 def _should_run(cycle: dict):
-    fuel_values = get_fuel_values(TERM_ID, cycle, LOOKUPS['fuel'])
-    has_fuel = len(fuel_values) > 0
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_fuel=has_fuel)
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
 
-    should_run = any([has_fuel])
+    should_run = any([bool(valid_inputs), electricity_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, fuel_values
+    return should_run, group_fuel_inputs(valid_inputs)
 
 
 def run(cycle: dict):
-    should_run, fuel_values = _should_run(cycle)
-    return _run(fuel_values) if should_run else []
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth/models/emepEea2019/n2OToAirFuelCombustionDirect.py

@@ -1,8 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from .utils import get_fuel_values, _emission
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
 from . import MODEL
 
 REQUIREMENTS = {
@@ -10,7 +10,7 @@ REQUIREMENTS = {
         "or": {
             "inputs": [
                 {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
-                     "operation": ""
+                    "operation": ""
                 }}
             ],
             "completeness.electricityFuel": "True"
@@ -20,6 +20,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Emission": [{
         "value": "",
+        "inputs": "",
+        "operation": "",
         "methodTier": "tier 1"
     }]
 }
@@ -31,23 +33,26 @@ TERM_ID = 'n2OToAirFuelCombustionDirect'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _run(fuel_values: list):
-    value = list_sum(fuel_values)
-    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
-
-
 def _should_run(cycle: dict):
-    fuel_values = get_fuel_values(TERM_ID, cycle, LOOKUPS['fuel'])
-    has_fuel = len(fuel_values) > 0
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_fuel=has_fuel)
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
 
-    should_run = any([has_fuel])
+    should_run = any([bool(valid_inputs), electricity_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, fuel_values
+    return should_run, group_fuel_inputs(valid_inputs)
 
 
 def run(cycle: dict):
-    should_run, fuel_values = _should_run(cycle)
-    return _run(fuel_values) if should_run else []
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth/models/emepEea2019/noxToAirFuelCombustion.py

@@ -1,8 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from .utils import get_fuel_values, _emission
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
 from . import MODEL
 
 REQUIREMENTS = {
@@ -20,6 +20,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Emission": [{
         "value": "",
+        "inputs": "",
+        "operation": "",
         "methodTier": "tier 1"
     }]
 }
@@ -31,23 +33,26 @@ TERM_ID = 'noxToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _run(fuel_values: list):
-    value = list_sum(fuel_values)
-    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
-
-
 def _should_run(cycle: dict):
-    fuel_values = get_fuel_values(TERM_ID, cycle, LOOKUPS['fuel'])
-    has_fuel = len(fuel_values) > 0
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_fuel=has_fuel)
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
 
-    should_run = any([has_fuel])
+    should_run = any([bool(valid_inputs), electricity_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, fuel_values
+    return should_run, group_fuel_inputs(valid_inputs)
 
 
 def run(cycle: dict):
-    should_run, fuel_values = _should_run(cycle)
-    return _run(fuel_values) if should_run else []
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth/models/emepEea2019/so2ToAirFuelCombustion.py

@@ -1,8 +1,8 @@
 from hestia_earth.schema import EmissionMethodTier
-from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from .utils import get_fuel_values, _emission
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+from .utils import get_fuel_inputs, group_fuel_inputs, _emission, _run_inputs
 from . import MODEL
 
 REQUIREMENTS = {
@@ -20,6 +20,8 @@ REQUIREMENTS = {
 RETURNS = {
     "Emission": [{
         "value": "",
+        "inputs": "",
+        "operation": "",
         "methodTier": "tier 1"
     }]
 }
@@ -31,23 +33,26 @@ TERM_ID = 'so2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _run(fuel_values: list):
-    value = list_sum(fuel_values)
-    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
-
-
 def _should_run(cycle: dict):
-    fuel_values = get_fuel_values(TERM_ID, cycle, LOOKUPS['fuel'])
-    has_fuel = len(fuel_values) > 0
+    electricity_complete = _is_term_type_complete(cycle, 'electricityFuel')
+    fuel_inputs, valid_inputs = get_fuel_inputs(TERM_ID, cycle, LOOKUPS['fuel'])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_fuel=has_fuel)
+                    termType_electricityFuel_complete=electricity_complete,
+                    fuel_inputs=log_as_table(fuel_inputs))
 
-    should_run = any([has_fuel])
+    should_run = any([bool(valid_inputs), electricity_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, fuel_values
+    return should_run, group_fuel_inputs(valid_inputs)
 
 
 def run(cycle: dict):
-    should_run, fuel_values = _should_run(cycle)
-    return _run(fuel_values) if should_run else []
+    should_run, fuel_inputs = _should_run(cycle)
+    return (
+        [
+            _run_inputs(inputs, tier=TIER, term_id=TERM_ID)
+            for inputs in fuel_inputs.values()
+        ] if fuel_inputs else [
+            _emission(value=0, tier=TIER, term_id=TERM_ID)
+        ]
+    ) if should_run else []

hestia_earth/models/emepEea2019/utils.py

@@ -1,48 +1,96 @@
+from functools import reduce
 from hestia_earth.schema import TermTermType, SiteSiteType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.lookup import extract_grouped_data
-from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
+from hestia_earth.utils.tools import list_sum, safe_parse_float
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.completeness import _is_term_type_complete
+from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.cycle import get_animals_by_period
 from hestia_earth.models.utils.emission import _new_emission
 from . import MODEL
 
 
-def _emission(value: float, tier: str, term_id: str):
+def _emission(value: float, tier: str, term_id: str, input: dict = None, operation: dict = None):
     emission = _new_emission(term_id, MODEL)
     emission['value'] = [value]
     emission['methodTier'] = tier
+    if input:
+        emission['inputs'] = [input]
+    if operation:
+        emission['operation'] = operation
     return emission
 
 
-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)
-        factor = safe_parse_float(input_factor, None)
-
-        return input_value * factor if factor is not None else None
-    return get_value
-
+def _run_inputs(inputs: list, tier: str, term_id: str):
+    total_value = list_sum([
+        (i.get('input-value') or 0) * (i.get('operation-factor') or i.get('input-default-factor') or 0)
+        for i in inputs
+    ])
+    input_term = {
+        '@type': 'Term',
+        '@id': inputs[0].get('input-id'),
+        'termType': inputs[0].get('input-termType'),
+        'units': inputs[0].get('input-units'),
+    }
+    operation_term = {
+        '@type': 'Term',
+        '@id': inputs[0].get('operation-id'),
+        'termType': inputs[0].get('operation-termType'),
+        'units': inputs[0].get('operation-units'),
+    } if inputs[0].get('operation-id') else None
+    return _emission(
+        value=total_value,
+        tier=tier,
+        term_id=term_id,
+        input=input_term,
+        operation=operation_term
+    )
 
-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(_get_fuel_input_value(term_id, lookup_col), inputs))
 
-    return [0] if all([
-        len(values) == 0,
-        _is_term_type_complete(cycle, 'electricityFuel')
-    ]) else values
+def _fuel_input_data(term_id: str, lookup_col: str, 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', []), None)
+
+    operation_factor = extract_grouped_data(
+        data=get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id),
+        key=input_term_id
+    ) if operation_term else None
+    input_factor = get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id)
+
+    return {
+        'input-id': input_term_id,
+        'input-termType': input_term.get('termType'),
+        'input-units': input_term.get('units'),
+        'input-value': input_value,
+        'input-default-factor': safe_parse_float(input_factor, default=None),
+        'operation-id': operation_term.get('@id'),
+        'operation-termType': operation_term.get('termType'),
+        'operation-units': operation_term.get('units'),
+        'operation-factor': safe_parse_float(operation_factor, default=None)
+    }
+
+
+def get_fuel_inputs(term_id: str, cycle: dict, lookup_col: str):
+    inputs = [
+        _fuel_input_data(term_id, lookup_col, i)
+        for i in filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
+    ]
+    valid_inputs = [
+        i for i in inputs if all([
+            i.get('input-value') is not None,
+            (i.get('operation-factor') or i.get('input-default-factor')) is not None
+        ])
+    ]
+    return inputs, valid_inputs
+
+
+def group_fuel_inputs(inputs: list):
+    return reduce(group_by_keys(['input-id', 'operation-id']), inputs, {}) if len(inputs) > 0 else None
 
 
 def _get_emissions_factor(animal: dict, lookup_col: str) -> float:

hestia_earth/models/hestia/management.py

@@ -135,9 +135,9 @@ def management(data: dict):
     return node
 
 
-def _get_cycle_duration(cycle: dict, land_cover_id: str):
+def _get_cycle_duration(cycle: dict, land_cover_id: str = None):
     cycle_duration = cycle.get('cycleDuration')
-    lookup_value = None if cycle_duration else safe_parse_float(get_table_value(
+    lookup_value = None if cycle_duration or not land_cover_id else safe_parse_float(get_table_value(
         download_lookup("crop.csv"),
         column_name('landCoverTermId'),
         land_cover_id,
@@ -157,7 +157,7 @@ def _gap_filled_date_obj(date_str: str, mode: str = DatestrGapfillMode.END) -> d
     )
 
 
-def _gap_filled_start_date(land_cover_id: str, end_date: str, cycle: dict) -> dict:
+def _gap_filled_start_date(cycle: dict, end_date: str, land_cover_id: str = None) -> dict:
     """If possible, gap-fill the startDate based on the endDate - cycleDuration"""
     cycle_duration = _get_cycle_duration(cycle, land_cover_id)
     return {
@@ -216,9 +216,9 @@ def _get_relevant_items(cycle: dict, item_name: str, term_types: List[TermTermTy
         _include_with_date_gap_fill(cycle, ["startDate", "endDate"]) |
         _include(
             _gap_filled_start_date(
-                land_cover_id=get_landCover_term_id(item.get('term', {})),
+                cycle=cycle,
                 end_date=item.get("endDate") if "endDate" in item else cycle.get("endDate", ""),
-                cycle=cycle
+                land_cover_id=get_landCover_term_id(item.get('term', {})),
             ) if "startDate" not in item else {},
             "startDate"
         ) |
@@ -255,12 +255,17 @@ def _run_from_siteType(site: dict, cycle: dict):
     site_type = site.get('siteType')
     site_type_id = get_landCover_term_id_from_site_type(site_type) if site_type not in _SKIP_LAND_COVER_SITE_TYPES \
         else None
+    start_date = cycle.get('startDate') or _gap_filled_start_date(
+        cycle=cycle,
+        end_date=cycle.get('endDate'),
+        land_cover_id=site_type_id
+    ).get('startDate')
 
-    should_run = all([site_type_id])
+    should_run = all([site_type_id, start_date])
     return [{
         'id': site_type_id,
         'value': 100,
-        'startDate': cycle.get('startDate'),
+        'startDate': start_date,
         'endDate': cycle.get('endDate')
     }] if should_run else []