hestia-earth-models 0.64.7__py3-none-any.whl → 0.64.9__py3-none-any.whl

hestia_earth/models/frischknechtEtAl2000/ionisingRadiationKbqU235Eq.py

@@ -1,11 +1,11 @@
-from functools import reduce
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.tools import list_sum, flatten, non_empty_list
+from hestia_earth.utils.lookup import get_table_value, download_lookup, column_name
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import flatten
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import filter_emission_inputs
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.indicator import _new_indicator
-from hestia_earth.models.utils.lookup import factor_value
+from hestia_earth.models.utils.lookup import _node_value
 from . import MODEL
 
 REQUIREMENTS = {
@@ -18,7 +18,7 @@ REQUIREMENTS = {
                 "ionisingCompoundsToWaterInputsProduction",
                 "ionisingCompoundsToSaltwaterInputsProduction"
             ],
-            "inputs": [{"@type": "Input", "term.termType": "waste"}]
+            "inputs": {"@type": "Term", "term.termType": "waste", "term.units": "kg"}
         }]
     }
 }
@@ -30,15 +30,23 @@ LOOKUPS = {
     ]
 }
 RETURNS = {
-    "Indicator": {
+    "Indicator": [{
         "value": "",
         "inputs": ""
-    }
+    }]
 }
 
 TERM_ID = 'ionisingRadiationKbqU235Eq'
 
 
+def _valid_waste(input: dict) -> bool:
+    return input.get('units', '').startswith("kg") and input.get('termType', '') == TermTermType.WASTE.value
+
+
+def _valid_emission(emission: dict) -> bool:
+    return len(emission.get('inputs', [])) == 1 and isinstance(_node_value(emission), (int, float))
+
+
 def _indicator(value: float, input: dict):
     indicator = _new_indicator(TERM_ID, MODEL)
     indicator['value'] = value
@@ -46,45 +54,69 @@ def _indicator(value: float, input: dict):
     return indicator
 
 
-def _run(grouped_emissions_inputs: list):
-    input = grouped_emissions_inputs[0].get('input')
-    values = [
-        factor_value(
-            model=MODEL,
-            term_id=TERM_ID,
-            lookup_name=f"{TermTermType.WASTE.value}.csv",
-            lookup_col=i.get('emission').get('term', {}).get('@id')
-        )(data=i.get('emission') | {'term': i.get('input')})
-        for i in grouped_emissions_inputs
+def _run(emissions: list):
+    indicators = [
+        _indicator(value=emission['value'] * emission['coefficient'], input=emission['input'])
+        for emission in emissions
     ]
-    value = list_sum(values)
-    return _indicator(value, input) if value else None
+    return indicators
 
 
 def _should_run(impact_assessment: dict):
-    emissions = flatten([
-        ([
-            {'emission': emission, 'input': input}
-            for input in filter_emission_inputs(emission, TermTermType.WASTE)
+    emissions = [emission for emission in filter_list_term_type(impact_assessment.get('emissionsResourceUse', []),
+                                                                TermTermType.EMISSION)
+                 if emission.get('term', {}).get('@id', '') in LOOKUPS[TermTermType.WASTE.value]]
+
+    has_emissions = bool(emissions)
+
+    emissions_unpacked = flatten(
+        [
+            [
+                {
+                    "input-term-id": input.get('@id'),
+                    "input-term-type": input.get('termType'),
+                    "indicator-term-id": emission['term']['@id'],
+                    "indicator-is-valid": _valid_emission(emission),
+                    "input": input,
+                    "indicator-input-is-valid": _valid_waste(input),
+                    "value": _node_value(emission),
+                    "coefficient": get_table_value(array=download_lookup(filename="waste.csv"),
+                                                   col_match='termid',
+                                                   col_match_with=input.get('@id'),
+                                                   col_val=column_name(emission['term']['@id'])) if input else None
+                } for input in emission['inputs'] or [{}]]
+            for emission in emissions
+        ]
+    )
+
+    valid_emission_with_cf = [em for em in emissions_unpacked if em['coefficient'] is not None
+                              and em['indicator-is-valid'] is True
+                              and em['indicator-input-is-valid'] is True]
+
+    valid_input_requirements = all([
+        all([
+            em['indicator-is-valid'],
+            em['indicator-input-is-valid']
         ])
-        for emission in impact_assessment.get('emissionsResourceUse', [])
-        if emission.get('term', {}).get('@id') in LOOKUPS[TermTermType.WASTE.value]
+        for em in emissions_unpacked
     ])
-    emissions_per_input = reduce(
-        lambda p, c: p | {c.get('input').get('@id'): p.get(c.get('input').get('@id'), []) + [c]},
-        emissions,
-        {}
-    )
 
-    logRequirements(impact_assessment, model=MODEL,
-                    has_emissions=bool(emissions_per_input))
+    all_emissions_have_known_cf = all([em['coefficient'] is not None for em in emissions_unpacked]) and bool(
+        emissions_unpacked)
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_emissions=has_emissions,
+                    valid_input_requirements=valid_input_requirements,
+                    all_emissions_have_known_CF=all_emissions_have_known_cf,
+                    emissions=log_as_table(emissions_unpacked)
+                    )
 
-    should_run = all([emissions_per_input])
+    should_run = valid_input_requirements
 
     logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
-    return should_run, emissions_per_input
+    return should_run, valid_emission_with_cf
 
 
 def run(impact_assessment: dict):
-    should_run, emissions_per_input = _should_run(impact_assessment)
-    return non_empty_list(map(_run, emissions_per_input.values())) if should_run else []
+    should_run, emissions = _should_run(impact_assessment)
+    return _run(emissions) if should_run else []

hestia_earth/models/hyde32/utils.py

@@ -45,6 +45,8 @@ def _run(impact_assessment: dict, term_id: str, land_occupation_m2: float, facto
 
 
 def _should_run(impact_assessment: dict, term_id: str, from_site_type: SiteSiteType, years: int):
+    site = get_site(impact_assessment)
+    has_site = bool(site)
     cycle = impact_assessment.get('cycle', {})
     product = get_product(impact_assessment)
     site = get_site(impact_assessment)
@@ -52,10 +54,12 @@ def _should_run(impact_assessment: dict, term_id: str, from_site_type: SiteSiteT
     land_transformation_factor = _get_emission_factor(term_id, impact_assessment, years, from_site_type)
 
     logRequirements(impact_assessment, model=MODEL, term=term_id,
+                    has_site=has_site,
                     land_occupation_m2_kg=land_occupation_m2_kg,
                     land_transformation_factor=land_transformation_factor)
 
     should_run = all([
+        has_site,
         land_occupation_m2_kg is not None,
         land_occupation_m2_kg == 0 or land_transformation_factor is not None
     ])

hestia_earth/models/ipcc2019/animal/fatContent.py

@@ -0,0 +1,38 @@
+from .utils import should_run_by_productivity_lookup, run_animal_by_productivity
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "practices": {
+                "@type": "Practice",
+                "term.termType": "animalManagement"
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-liveAnimal-milkFatContent": "fat content",
+    "liveAnimal": "milkYieldPracticeTermIds"
+}
+RETURNS = {
+    "Animal": [{
+        "practices": [{
+            "@type": "Practice",
+            "value": ""
+        }]
+    }]
+}
+TERM_ID = 'fatContent'
+
+
+def run(cycle: dict):
+    animals = should_run_by_productivity_lookup(
+        TERM_ID, cycle, list(LOOKUPS.keys())[0], practice_id=LOOKUPS['liveAnimal']
+    )
+    return list(map(run_animal_by_productivity(TERM_ID, include_practice=True), animals))

hestia_earth/models/ipcc2019/animal/liveweightGain.py

@@ -1,11 +1,4 @@
-from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import filter_list_term_type
-
-from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.blank_node import merge_blank_nodes
-from hestia_earth.models.utils.property import _new_property, node_has_no_property
-from .utils import productivity_lookup_value
-from .. import MODEL
+from .utils import should_run_by_productivity_lookup, run_animal_by_productivity
 
 REQUIREMENTS = {
     "Cycle": {
@@ -40,50 +33,6 @@ RETURNS = {
 TERM_ID = 'liveweightGain'
 
 
-def _property(value: float):
-    prop = _new_property(TERM_ID, MODEL)
-    prop['value'] = value
-    return prop
-
-
-def _run_animal(data: dict):
-    animal = data.get('animal')
-    value = data.get('value')
-    return animal | {
-        'properties': merge_blank_nodes(animal.get('properties', []), [_property(value)])
-    }
-
-
-def _should_run(cycle: dict):
-    country = cycle.get('site', {}).get('country', {})
-    country_id = country.get('@id')
-    live_animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
-    live_animals = list(filter(node_has_no_property(TERM_ID), live_animals))
-    live_animals_with_value = [{
-        'animal': animal,
-        'value': productivity_lookup_value(TERM_ID, list(LOOKUPS.keys())[0], country, animal)
-    } for animal in live_animals]
-
-    def _should_run_animal(value: dict):
-        animal = value.get('animal')
-        lookup_value = value.get('value')
-        term_id = animal.get('term').get('@id')
-
-        logRequirements(cycle, model=MODEL, term=term_id, property=TERM_ID,
-                        country_id=country_id,
-                        liveweightGain=lookup_value)
-
-        should_run = all([
-            country_id,
-            lookup_value is not None
-        ])
-        logShouldRun(cycle, MODEL, term_id, should_run, property=TERM_ID)
-
-        return should_run
-
-    return list(filter(_should_run_animal, live_animals_with_value))
-
-
 def run(cycle: dict):
-    animals = _should_run(cycle)
-    return list(map(_run_animal, animals))
+    animals = should_run_by_productivity_lookup(TERM_ID, cycle, list(LOOKUPS.keys())[0])
+    return list(map(run_animal_by_productivity(TERM_ID), animals))

hestia_earth/models/ipcc2019/animal/liveweightPerHead.py

@@ -1,11 +1,4 @@
-from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import filter_list_term_type
-
-from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.blank_node import merge_blank_nodes
-from hestia_earth.models.utils.property import _new_property, node_has_no_property
-from .utils import productivity_lookup_value
-from .. import MODEL
+from .utils import should_run_by_productivity_lookup, run_animal_by_productivity
 
 REQUIREMENTS = {
     "Cycle": {
@@ -40,50 +33,6 @@ RETURNS = {
 TERM_ID = 'liveweightPerHead'
 
 
-def _property(value: float):
-    prop = _new_property(TERM_ID, MODEL)
-    prop['value'] = value
-    return prop
-
-
-def _run_animal(data: dict):
-    animal = data.get('animal')
-    value = data.get('value')
-    return animal | {
-        'properties': merge_blank_nodes(animal.get('properties', []), [_property(value)])
-    }
-
-
-def _should_run(cycle: dict):
-    country = cycle.get('site', {}).get('country', {})
-    country_id = country.get('@id')
-    live_animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
-    live_animals = list(filter(node_has_no_property(TERM_ID), live_animals))
-    live_animals_with_value = [{
-        'animal': animal,
-        'value': productivity_lookup_value(TERM_ID, list(LOOKUPS.keys())[0], country, animal)
-    } for animal in live_animals]
-
-    def _should_run_animal(value: dict):
-        animal = value.get('animal')
-        lookup_value = value.get('value')
-        term_id = animal.get('term').get('@id')
-
-        logRequirements(cycle, model=MODEL, term=term_id, property=TERM_ID,
-                        country_id=country_id,
-                        liveweightPerHead=lookup_value)
-
-        should_run = all([
-            country_id,
-            lookup_value is not None
-        ])
-        logShouldRun(cycle, MODEL, term_id, should_run, property=TERM_ID)
-
-        return should_run
-
-    return list(filter(_should_run_animal, live_animals_with_value))
-
-
 def run(cycle: dict):
-    animals = _should_run(cycle)
-    return list(map(_run_animal, animals))
+    animals = should_run_by_productivity_lookup(TERM_ID, cycle, list(LOOKUPS.keys())[0])
+    return list(map(run_animal_by_productivity(TERM_ID), animals))

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -137,10 +137,12 @@ LOOKUPS = {
         "isWoolProducingAnimal"
     ],
     "system-liveAnimal-activityCoefficient-ipcc2019": "using animal term @id",
+    "landCover": "grazedPastureGrassInputId",
     "crop-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"],
     "crop": "grazedPastureGrassInputId",
     "forage-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"],
-    "landCover": "grazedPastureGrassInputId"
+    "feedFoodAdditive": "hasEnergyContent",
+    "feedFoodAdditive-property": ["energyDigestibilityRuminants", "energyContentHigherHeatingValue"]
 }
 RETURNS = {
     "Animal": [{

hestia_earth/models/ipcc2019/animal/pregnancyRateTotal.py

@@ -0,0 +1,38 @@
+from .utils import should_run_by_productivity_lookup, run_animal_by_productivity
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "none": {
+                "properties": [{
+                    "@type": "Property",
+                    "value": "",
+                    "term.@id": "pregnancyRateTotal"
+                }]
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-liveAnimal-pregnancyRateTotal": "pregnancy rate"
+}
+RETURNS = {
+    "Animal": [{
+        "properties": [{
+            "@type": "Property",
+            "value": ""
+        }]
+    }]
+}
+TERM_ID = 'pregnancyRateTotal'
+
+
+def run(cycle: dict):
+    animals = should_run_by_productivity_lookup(TERM_ID, cycle, list(LOOKUPS.keys())[0])
+    return list(map(run_animal_by_productivity(TERM_ID), animals))

hestia_earth/models/ipcc2019/animal/trueProteinContent.py

@@ -0,0 +1,38 @@
+from .utils import should_run_by_productivity_lookup, run_animal_by_productivity
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "practices": {
+                "@type": "Practice",
+                "term.termType": "animalManagement"
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-liveAnimal-milkTrueProteinContent": "protein content",
+    "liveAnimal": "milkYieldPracticeTermIds"
+}
+RETURNS = {
+    "Animal": [{
+        "practices": [{
+            "@type": "Practice",
+            "value": ""
+        }]
+    }]
+}
+TERM_ID = 'trueProteinContent'
+
+
+def run(cycle: dict):
+    animals = should_run_by_productivity_lookup(
+        TERM_ID, cycle, list(LOOKUPS.keys())[0], practice_id=LOOKUPS['liveAnimal']
+    )
+    return list(map(run_animal_by_productivity(TERM_ID, include_practice=True), animals))

hestia_earth/models/ipcc2019/animal/utils.py

@@ -1,11 +1,26 @@
+from hestia_earth.schema import TermTermType
 from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name, extract_grouped_data
-from hestia_earth.utils.tools import safe_parse_float
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import safe_parse_float, non_empty_list
 
-from hestia_earth.models.log import debugMissingLookup
+from hestia_earth.models.log import logRequirements, logShouldRun, debugMissingLookup
+from hestia_earth.models.utils.blank_node import merge_blank_nodes
+from hestia_earth.models.utils.property import _new_property, node_has_no_property
 from hestia_earth.models.utils.productivity import PRODUCTIVITY, get_productivity
+from hestia_earth.models.utils.term import get_lookup_value
 from .. import MODEL
 
 
+def _get_practice(term_id: str, animal: dict, practice_id: str):
+    term = animal.get('term', {})
+    value = get_lookup_value(term, practice_id, model=MODEL, term=term_id)
+    practice_ids = non_empty_list((value or '').split(';'))
+    return next(
+        (p for p in animal.get('practices', []) if p.get('term', {}).get('@id') in practice_ids),
+        {}
+    )
+
+
 def productivity_lookup_value(term_id: str, lookup: str, country: dict, animal: dict):
     country_id = country.get('@id')
     productivity_key = get_productivity(country)
@@ -16,5 +31,74 @@ def productivity_lookup_value(term_id: str, lookup: str, country: dict, animal:
     debugMissingLookup(lookup_name, 'termid', country_id, column, value, model=MODEL, term=term_id)
     return safe_parse_float(
         extract_grouped_data(value, productivity_key.value) or
-        extract_grouped_data(value, PRODUCTIVITY.HIGH.value)  # defaults to high if low is not found
+        extract_grouped_data(value, PRODUCTIVITY.HIGH.value),  # defaults to high if low is not found
+        None
     )
+
+
+def map_live_animals_by_productivity_lookup(term_id: str, cycle: dict, lookup_col: str, practice_id: str = None):
+    country = cycle.get('site', {}).get('country', {})
+    live_animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
+    live_animals = list(filter(node_has_no_property(term_id), live_animals))
+    return [{
+        'animal': animal,
+        'value': productivity_lookup_value(term_id, lookup_col, country, animal)
+    } | ({
+        'practice': _get_practice(term_id, animal, practice_id)
+    } if practice_id else {}) for animal in live_animals]
+
+
+def should_run_by_productivity_lookup(term_id: str, cycle: dict, lookup_col: str, practice_id: str = None):
+    country = cycle.get('site', {}).get('country', {})
+    country_id = country.get('@id')
+    live_animals_with_value = map_live_animals_by_productivity_lookup(term_id, cycle, lookup_col, practice_id)
+
+    def _should_run_animal(value: dict):
+        animal = value.get('animal')
+        lookup_value = value.get('value')
+        practice = value.get('practice')
+        term_id = animal.get('term').get('@id')
+
+        logRequirements(cycle, model=MODEL, term=term_id, property=term_id,
+                        country_id=country_id,
+                        **({
+                            lookup_col.replace('-', '_'): lookup_value
+                        } | ({
+                            'practice': practice.get('term', {}).get('@id')
+                        } if practice_id else {})))
+
+        should_run = all([
+            country_id,
+            not practice_id or bool(practice),
+            lookup_value is not None
+        ])
+        logShouldRun(cycle, MODEL, term_id, should_run, property=term_id)
+
+        return should_run
+
+    return list(filter(_should_run_animal, live_animals_with_value))
+
+
+def _property(term_id: str, value: float):
+    prop = _new_property(term_id, MODEL)
+    prop['value'] = value
+    return prop
+
+
+def run_animal_by_productivity(term_id: str, include_practice: bool = False):
+    def run(data: dict):
+        animal = data.get('animal')
+        value = data.get('value')
+        practice = data.get('practice')
+        return animal | ({
+            'practices': [
+                (
+                    p | ({
+                        'properties': merge_blank_nodes(p.get('properties', []), [_property(term_id, value)])
+                    } if p.get('term', {}).get('@id') == practice.get('term', {}).get('@id') else {})
+                ) for p in animal.get('practices', [])
+            ]
+        } if include_practice else {
+            'properties': merge_blank_nodes(animal.get('properties', []), [_property(term_id, value)])
+        })
+    return run

hestia_earth/models/ipcc2019/animal/weightAtMaturity.py

@@ -2,13 +2,12 @@
 Note: when the `liveweightPerHead` property is provided, this model will only work if the returned value is
 greater than or equal to `liveweightPerHead` value.
 """
-from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import filter_list_term_type, find_term_match
+from hestia_earth.utils.model import find_term_match
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import merge_blank_nodes
-from hestia_earth.models.utils.property import _new_property, node_has_no_property
-from .utils import productivity_lookup_value
+from hestia_earth.models.utils.property import _new_property
+from .utils import map_live_animals_by_productivity_lookup
 from .. import MODEL
 
 REQUIREMENTS = {
@@ -68,12 +67,7 @@ def _run_animal(data: dict):
 def _should_run(cycle: dict):
     country = cycle.get('site', {}).get('country', {})
     country_id = country.get('@id')
-    live_animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
-    live_animals = list(filter(node_has_no_property(TERM_ID), live_animals))
-    live_animals_with_value = [{
-        'animal': animal,
-        'value': productivity_lookup_value(TERM_ID, list(LOOKUPS.keys())[0], country, animal)
-    } for animal in live_animals]
+    live_animals_with_value = map_live_animals_by_productivity_lookup(TERM_ID, cycle, list(LOOKUPS.keys())[0])
 
     def _should_run_animal(value: dict):
         animal = value.get('animal')