hestia-earth-models 0.62.3__tar.gz → 0.62.5__tar.gz

{hestia-earth-models-0.62.3/hestia_earth_models.egg-info → hestia-earth-models-0.62.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.62.3
+Version: 0.62.5
 Summary: HESTIA's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: HESTIA Team

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/hestia_earth/models/emepEea2019/co2ToAirFuelCombustion.py

@@ -2,8 +2,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import get_fuel_values
+from .utils import get_fuel_values, _emission
 from . import MODEL
 
 REQUIREMENTS = {
@@ -32,16 +31,9 @@ TERM_ID = 'co2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _run(fuel_values: list):
     value = list_sum(fuel_values)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/hestia_earth/models/emepEea2019/n2OToAirFuelCombustionDirect.py

@@ -2,8 +2,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import get_fuel_values
+from .utils import get_fuel_values, _emission
 from . import MODEL
 
 REQUIREMENTS = {
@@ -32,16 +31,9 @@ TERM_ID = 'n2OToAirFuelCombustionDirect'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _run(fuel_values: list):
     value = list_sum(fuel_values)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/hestia_earth/models/emepEea2019/nh3ToAirExcreta.py

@@ -7,9 +7,9 @@ from hestia_earth.models.log import logRequirements, debugMissingLookup, logShou
 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
+from .utils import _emission
 
 REQUIREMENTS = {
     "Cycle": {
@@ -40,13 +40,6 @@ TERM_ID = 'nh3ToAirExcreta'
 TIER = EmissionMethodTier.TIER_2.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _get_nh3_factor(term_id: str, input: dict):
     input_term_id = input.get('term', {}).get('@id')
     lookup_name = f"{list(LOOKUPS.keys())[0]}.csv"
@@ -57,7 +50,7 @@ def _get_nh3_factor(term_id: str, input: dict):
 
 def _run(excreta_EF_product: float):
     value = excreta_EF_product * get_atomic_conversion(Units.KG_NH3, Units.TO_N)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/hestia_earth/models/emepEea2019/nh3ToAirInorganicFertiliser.py

@@ -10,7 +10,7 @@ from hestia_earth.models.utils.inorganicFertiliser import (
     get_NH3_emission_factor, get_terms, get_term_lookup, get_country_breakdown, get_cycle_inputs
 )
 from hestia_earth.models.utils.constant import Units
-from hestia_earth.models.utils.emission import _new_emission
+from .utils import _emission
 from hestia_earth.models.utils.measurement import most_relevant_measurement_value
 from . import MODEL
 
@@ -58,13 +58,6 @@ TIER = EmissionMethodTier.TIER_2.value
 UNSPECIFIED_TERM_ID = 'inorganicNitrogenFertiliserUnspecifiedKgN'
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _input_with_factor(soilPh: float, temperature: float):
     def get_value(input: dict):
         term_id = input.get('term', {}).get('@id')
@@ -151,4 +144,4 @@ def _should_run(cycle: dict):
 def run(cycle: dict):
     should_run, N_inputs_with_factor = _should_run(cycle)
     value = list_sum([i.get('value') * i.get('factor') for i in N_inputs_with_factor]) if should_run else None
-    return [_emission(value)] if value is not None else []
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)] if value is not None else []

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/hestia_earth/models/emepEea2019/noxToAirFuelCombustion.py

@@ -2,8 +2,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import get_fuel_values
+from .utils import get_fuel_values, _emission
 from . import MODEL
 
 REQUIREMENTS = {
@@ -32,16 +31,9 @@ TERM_ID = 'noxToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _run(fuel_values: list):
     value = list_sum(fuel_values)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

hestia-earth-models-0.62.5/hestia_earth/models/emepEea2019/pm10ToAirAnimalHousing.py

@@ -0,0 +1,57 @@
+"""
+When `otherSites` are provided, `otherSitesDuration` must be set as well so we know the length of time the animals
+spend on each Site.
+"""
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import _emission, get_live_animal_emission_value, should_run_animal
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.animalPopulation": "True",
+        "site": {"@type": "Site"},
+        "siteDuration": "",
+        "animals": [
+            {
+                "@type": "Animal",
+                "term.termType": "liveAnimal",
+                "value": "",
+                "referencePeriod": "average"
+            }
+        ],
+        "optional": {
+            "otherSites": [{"@type": "Site"}],
+            "otherSitesDuration": ""
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "liveAnimal": "pm10ToAirEea2019",
+    "operation": "pm10ToAirAnimalHousingEmepEea2019"
+}
+TERM_ID = 'pm10ToAirAnimalHousing'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _run(animals: list[dict], total_duration: float):
+    return [
+        _emission(
+            value=get_live_animal_emission_value(animals, total_duration, lookup_col=LOOKUPS["liveAnimal"]),
+            tier=TIER,
+            term_id=TERM_ID
+        )
+    ]
+
+
+def run(cycle: dict):
+    should_run, animals, total_duration = should_run_animal(
+        cycle=cycle, model=MODEL, term=TERM_ID, tier=TIER
+    )
+    return _run(animals, total_duration) if should_run else []

hestia-earth-models-0.62.5/hestia_earth/models/emepEea2019/pm25ToAirAnimalHousing.py

@@ -0,0 +1,57 @@
+"""
+When `otherSites` are provided, `otherSitesDuration` must be set as well so we know the length of time the animals
+spend on each Site.
+"""
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import _emission, get_live_animal_emission_value, should_run_animal
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.animalPopulation": "True",
+        "site": {"@type": "Site"},
+        "siteDuration": "",
+        "animals": [
+            {
+                "@type": "Animal",
+                "term.termType": "liveAnimal",
+                "value": "",
+                "referencePeriod": "average"
+            }
+        ],
+        "optional": {
+            "otherSites": [{"@type": "Site"}],
+            "otherSitesDuration": ""
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "liveAnimal": "pm25ToAirEea2019",
+    "operation": "pm25ToAirAnimalHousingEmepEea2019"
+}
+TERM_ID = 'pm25ToAirAnimalHousing'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _run(animals: list[dict], total_duration: float):
+    return [
+        _emission(
+            value=get_live_animal_emission_value(animals, total_duration, lookup_col=LOOKUPS["liveAnimal"]),
+            tier=TIER,
+            term_id=TERM_ID
+        )
+    ]
+
+
+def run(cycle: dict):
+    should_run, animals, total_duration = should_run_animal(
+        cycle=cycle, model=MODEL, term=TERM_ID, tier=TIER
+    )
+    return _run(animals, total_duration) if should_run else []

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/hestia_earth/models/emepEea2019/so2ToAirFuelCombustion.py

@@ -2,8 +2,7 @@ from hestia_earth.schema import EmissionMethodTier
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import get_fuel_values
+from .utils import get_fuel_values, _emission
 from . import MODEL
 
 REQUIREMENTS = {
@@ -32,16 +31,9 @@ TERM_ID = 'so2ToAirFuelCombustion'
 TIER = EmissionMethodTier.TIER_1.value
 
 
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
 def _run(fuel_values: list):
     value = list_sum(fuel_values)
-    return [_emission(value)]
+    return [_emission(value=value, tier=TIER, term_id=TERM_ID)]
 
 
 def _should_run(cycle: dict):

hestia-earth-models-0.62.5/hestia_earth/models/emepEea2019/tspToAirAnimalHousing.py

@@ -0,0 +1,57 @@
+"""
+When `otherSites` are provided, `otherSitesDuration` must be set as well so we know the length of time the animals
+spend on each Site.
+"""
+from hestia_earth.schema import EmissionMethodTier
+
+from .utils import _emission, get_live_animal_emission_value, should_run_animal
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.animalPopulation": "True",
+        "site": {"@type": "Site"},
+        "siteDuration": "",
+        "animals": [
+            {
+                "@type": "Animal",
+                "term.termType": "liveAnimal",
+                "value": "",
+                "referencePeriod": "average"
+            }
+        ],
+        "optional": {
+            "otherSites": [{"@type": "Site"}],
+            "otherSitesDuration": ""
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "liveAnimal": "tspToAirEea2019",
+    "operation": "tspToAirAnimalHousingEmepEea2019"
+}
+TERM_ID = 'tspToAirAnimalHousing'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def _run(animals: list[dict], total_duration: float):
+    return [
+        _emission(
+            value=get_live_animal_emission_value(animals, total_duration, lookup_col=LOOKUPS["liveAnimal"]),
+            tier=TIER,
+            term_id=TERM_ID
+        )
+    ]
+
+
+def run(cycle: dict):
+    should_run, animals, total_duration = should_run_animal(
+        cycle=cycle, model=MODEL, term=TERM_ID, tier=TIER
+    )
+    return _run(animals, total_duration) if should_run else []

hestia-earth-models-0.62.5/hestia_earth/models/emepEea2019/utils.py

@@ -0,0 +1,94 @@
+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.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.completeness import _is_term_type_complete
+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):
+    emission = _new_emission(term_id, MODEL)
+    emission['value'] = [value]
+    emission['methodTier'] = tier
+    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 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 _get_emissions_factor(animal: dict, lookup_col: str) -> float:
+    return safe_parse_float(
+        get_lookup_value(animal.get("term", {}), lookup_col, model=MODEL, term=animal.get("term", ""))
+    )
+
+
+def _duration_in_housing(cycle: dict) -> int:
+    other_sites = cycle.get("otherSites", [])
+    other_durations = cycle.get("otherSitesDuration", [])
+    return list_sum([
+        cycle.get("siteDuration", cycle.get("cycleDuration", 0))
+        if cycle.get("site", {}).get("siteType", "") == SiteSiteType.ANIMAL_HOUSING.value else 0
+    ] + ([
+        other_durations[x]
+        for x in range(len(other_sites))
+        if other_sites[x].get("siteType", "") == SiteSiteType.ANIMAL_HOUSING.value
+    ] if len(other_sites) == len(other_durations) else []))
+
+
+def get_live_animal_emission_value(animals: list[dict], duration: float, lookup_col: str) -> float:
+    return list_sum([
+        animal.get('value') * _get_emissions_factor(animal=animal, lookup_col=lookup_col)
+        for animal in animals
+    ]) * duration / 365
+
+
+def should_run_animal(cycle: dict, model: str, term: str, tier: str) -> tuple[list, bool]:
+    term_type_animalPopulation_complete = _is_term_type_complete(cycle=cycle, term="animalPopulation")
+
+    # models will be set as not relevant is primary `siteType` does not match, so check only `otherSites`.
+
+    total_duration = _duration_in_housing(cycle)
+
+    has_other_sites_and_duration = len(cycle.get("otherSites", [])) == len(cycle.get("otherSitesDuration", []))
+
+    animals = get_animals_by_period(cycle)
+    has_animals = len(animals) > 0
+
+    logRequirements(cycle, model=model, term=term,
+                    term_type_animalPopulation_complete=term_type_animalPopulation_complete,
+                    has_animals=has_animals,
+                    has_other_sites_and_duration=has_other_sites_and_duration,
+                    number_of_days_in_animal_housing=total_duration)
+
+    should_run = all([term_type_animalPopulation_complete, has_animals, has_other_sites_and_duration])
+    logShouldRun(cycle, model, term, should_run, methodTier=tier)
+    return should_run, animals, total_duration

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/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.3 → hestia-earth-models-0.62.5}/hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -18,6 +18,7 @@ from hestia_earth.models.utils.input import _new_input
 from hestia_earth.models.utils.term import get_wool_terms, get_lookup_value
 from hestia_earth.models.utils.completeness import _is_term_type_complete, _is_term_type_incomplete
 from hestia_earth.models.utils.property import get_node_property
+from hestia_earth.models.utils.cycle import get_animals_by_period
 from .. import MODEL
 from ..pastureGrass_utils import (
     practice_input_id,
@@ -29,7 +30,6 @@ from ..pastureGrass_utils import (
     calculate_NEfeed,
     calculate_GE,
     product_wool_energy,
-    get_animals,
     get_animal_values
 )
 
@@ -308,7 +308,7 @@ def _should_run(cycle: dict, animals: list, practices: dict):
 
 
 def run(cycle: dict):
-    animals = get_animals(cycle)
+    animals = get_animals_by_period(cycle)
     practices = list(filter(should_run_practice(cycle), cycle.get('practices', [])))
     should_run, meanDE, meanECHHV, system = _should_run(cycle, animals, practices)
     return list(map(_run_animal(cycle, meanDE, meanECHHV, system, practices), animals)) if should_run else []

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/hestia_earth/models/ipcc2019/pastureGrass.py

@@ -17,6 +17,7 @@ from hestia_earth.models.utils.blank_node import lookups_logs, properties_logs
 from hestia_earth.models.utils.input import _new_input
 from hestia_earth.models.utils.term import get_wool_terms
 from hestia_earth.models.utils.completeness import _is_term_type_complete, _is_term_type_incomplete
+from hestia_earth.models.utils.cycle import get_animals_by_period
 from . import MODEL
 from .pastureGrass_utils import (
     practice_input_id,
@@ -28,7 +29,6 @@ from .pastureGrass_utils import (
     calculate_NEfeed,
     calculate_GE,
     product_wool_energy,
-    get_animals,
     get_animal_values
 )
 
@@ -164,7 +164,7 @@ def calculate_NEwool(cycle: dict) -> float:
 
 
 def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, system: dict):
-    animals = get_animals(cycle)
+    animals = get_animals_by_period(cycle)
     REM = calculate_REM(meanDE)
     REG = calculate_REG(meanDE)
     NEwool = calculate_NEwool(cycle)

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/hestia_earth/models/ipcc2019/pastureGrass_utils.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import TermTermType, AnimalReferencePeriod
+from hestia_earth.schema import TermTermType
 from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
 from hestia_earth.utils.tools import list_sum, safe_parse_float
@@ -341,12 +341,3 @@ def should_run_practice(cycle: dict):
         return all([len(value) > 0, term_id == MODEL_KEY, key_term_type in KEY_TERM_TYPES])
 
     return should_run
-
-
-def get_animals(cycle: dict):
-    return [
-        a for a in cycle.get('animals', []) if all([
-            a.get('value'),
-            a.get('referencePeriod') == AnimalReferencePeriod.AVERAGE.value
-        ])
-    ]

{hestia-earth-models-0.62.3 → hestia-earth-models-0.62.5}/hestia_earth/models/log.py

@@ -63,7 +63,7 @@ def logShouldRun(log_node: dict, model: str, term: Union[str, None], should_run:
 
 
 def debugMissingLookup(lookup_name: str, row: str, row_value: str, col: str, value, **kwargs):
-    if value is None:
+    if value is None or value == '':
         extra = (', ' + _join_args(**kwargs)) if len(kwargs.keys()) > 0 else ''
         logger.warn('Missing lookup=%s, %s=%s, column=%s' + extra, lookup_name, row, row_value, col)