hestia-earth-models 0.62.3__py3-none-any.whl → 0.62.5__py3-none-any.whl

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/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/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/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/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/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/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/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/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/emepEea2019/utils.py

@@ -1,13 +1,23 @@
-from hestia_earth.schema import TermTermType
+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', {})
@@ -33,3 +43,52 @@ def get_fuel_values(term_id: str, cycle: dict, lookup_col: str):
         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/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/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/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/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/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)
 

hestia_earth/models/mocking/search-results.json

@@ -1486,7 +1486,7 @@
         "@type": "Term",
         "name": "Generic crop, seed",
         "@id": "genericCropSeed",
-        "_score": 25.968466
+        "_score": 26.312824
       }
     ]
   },
@@ -1636,6 +1636,150 @@
       }
     ]
   },
+  {
+    "name": "get_land_cover_siteTypes",
+    "query": {
+      "bool": {
+        "must": [
+          {
+            "match": {
+              "@type": "Term"
+            }
+          },
+          {
+            "match": {
+              "termType": "landCover"
+            }
+          }
+        ],
+        "should": [
+          {
+            "match": {
+              "name": "agri-food processor"
+            }
+          },
+          {
+            "match": {
+              "name": "animal housing"
+            }
+          },
+          {
+            "match": {
+              "name": "cropland"
+            }
+          },
+          {
+            "match": {
+              "name": "food retailer"
+            }
+          },
+          {
+            "match": {
+              "name": "forest"
+            }
+          },
+          {
+            "match": {
+              "name": "glass or high accessible cover"
+            }
+          },
+          {
+            "match": {
+              "name": "lake"
+            }
+          },
+          {
+            "match": {
+              "name": "other natural vegetation"
+            }
+          },
+          {
+            "match": {
+              "name": "permanent pasture"
+            }
+          },
+          {
+            "match": {
+              "name": "pond"
+            }
+          },
+          {
+            "match": {
+              "name": "river or stream"
+            }
+          },
+          {
+            "match": {
+              "name": "sea or ocean"
+            }
+          }
+        ],
+        "minimum_should_match": 1
+      }
+    },
+    "results": [
+      {
+        "@type": "Term",
+        "name": "Glass or high accessible cover",
+        "@id": "glassOrHighAccessibleCover",
+        "_score": 59.49422
+      },
+      {
+        "@type": "Term",
+        "name": "River or stream",
+        "@id": "riverOrStream",
+        "_score": 50.673336
+      },
+      {
+        "@type": "Term",
+        "name": "Other natural vegetation",
+        "@id": "otherNaturalVegetation",
+        "_score": 40.97334
+      },
+      {
+        "@type": "Term",
+        "name": "Natural forest",
+        "@id": "naturalForest",
+        "_score": 31.583748
+      },
+      {
+        "@type": "Term",
+        "name": "Permanent pasture",
+        "@id": "permanentPasture",
+        "_score": 28.25857
+      },
+      {
+        "@type": "Term",
+        "name": "Animal housing",
+        "@id": "animalHousing",
+        "_score": 27.218006
+      },
+      {
+        "@type": "Term",
+        "name": "Root or tuber crop plant",
+        "@id": "rootOrTuberCropPlant",
+        "_score": 25.098145
+      },
+      {
+        "@type": "Term",
+        "name": "High intensity grazing pasture",
+        "@id": "highIntensityGrazingPasture",
+        "_score": 23.833916
+      },
+      {
+        "@type": "Term",
+        "name": "Permanent cropland",
+        "@id": "permanentCropland",
+        "_score": 20.639563
+      },
+      {
+        "@type": "Term",
+        "name": "Forest",
+        "@id": "forest",
+        "_score": 20.246805
+      }
+    ]
+  },
   {
     "name": "get_liquid_fuel_terms",
     "query": {