hestia-earth-models 0.75.2__py3-none-any.whl → 0.75.3__py3-none-any.whl

hestia_earth/models/config/Cycle.json

@@ -755,22 +755,24 @@
       "mergeStrategy": "list",
       "stage": 2
     },
-    {
-      "key": "inputs",
-      "model": "ipcc2019",
-      "value": "pastureGrass",
-      "runStrategy": "always",
-      "mergeStrategy": "list",
-      "stage": 2
-    },
-    {
-      "key": "animals",
-      "model": "ipcc2019",
-      "value": "animal.pastureGrass",
-      "runStrategy": "always",
-      "mergeStrategy": "list",
-      "stage": 2
-    },
+    [
+      {
+        "key": "inputs",
+        "model": "ipcc2019",
+        "value": "pastureGrass",
+        "runStrategy": "always",
+        "mergeStrategy": "list",
+        "stage": 2
+      },
+      {
+        "key": "animals",
+        "model": "ipcc2019",
+        "value": "animal.pastureGrass",
+        "runStrategy": "always",
+        "mergeStrategy": "list",
+        "stage": 2
+      }
+    ],
     [
       {
         "key": "products",
@@ -1368,6 +1370,51 @@
           "replaceThreshold": ["value", 0.01]
         },
         "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "pefcrGuidanceDocument2017",
+        "value": "pesticideToAirPesticideApplication",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "pefcrGuidanceDocument2017",
+        "value": "pesticideToSoilPesticideApplication",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "pefcrGuidanceDocument2017",
+        "value": "pesticideToWaterPesticideApplication",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
       }
     ],
     [
@@ -1846,6 +1893,111 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "coToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "blackCarbonToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "nmvocToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "pm10ToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "pm25ToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "tspToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
+      {
+        "key": "emissions",
+        "model": "emepEea2019",
+        "value": "ch4ToAirFuelCombustion",
+        "runStrategy": "add_blank_node_if_missing",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
       {
         "key": "emissions",
         "model": "ipcc2019",

hestia_earth/models/emepEea2019/blackCarbonToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "blackCarbonToAirFuelCombustionEmepEea2019",
+    "operation": "blackCarbonToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'blackCarbonToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/ch4ToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "ch4ToAirFuelCombustionEmepEea2019",
+    "operation": "ch4ToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'ch4ToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/coToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "coToAirFuelCombustionEmepEea2019",
+    "operation": "coToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'coToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/nmvocToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "nmvocToAirFuelCombustionEmepEea2019",
+    "operation": "nmvocToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'nmvocToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/pm10ToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "pm10ToAirFuelCombustionEmepEea2019",
+    "operation": "pm10ToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'pm10ToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/pm25ToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "pm25ToAirFuelCombustionEmepEea2019",
+    "operation": "pm25ToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'pm25ToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/emepEea2019/tspToAirFuelCombustion.py

@@ -0,0 +1,33 @@
+from hestia_earth.schema import EmissionMethodTier
+
+from .fuelCombustion_utils import run as run_fuelCombustion
+
+REQUIREMENTS = {
+    "Cycle": {
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "", "term.termType": "fuel", "optional": {
+                    "operation": ""
+                }}
+            ],
+            "completeness.electricityFuel": "True"
+        }
+    }
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "inputs": "",
+        "operation": "",
+        "methodTier": "tier 1"
+    }]
+}
+LOOKUPS = {
+    "fuel": "tspToAirFuelCombustionEmepEea2019",
+    "operation": "tspToAirFuelCombustionEmepEea2019"
+}
+TERM_ID = 'tspToAirFuelCombustion'
+TIER = EmissionMethodTier.TIER_1.value
+
+
+def run(cycle: dict): return run_fuelCombustion(cycle, term_id=TERM_ID)

hestia_earth/models/faostat2018/seed.py

@@ -15,7 +15,7 @@ REQUIREMENTS = {
             "term.termType": "crop",
             "value": "> 0"
         }],
-        "completeness.other": "False"
+        "completeness.seed": "False"
     }
 }
 LOOKUPS = {
@@ -34,17 +34,18 @@ TERM_ID = 'seed'
 def _run_product(product: dict):
     term = product.get('term', {})
     product_value = list_sum(product.get('value', []))
-    value = safe_parse_float(
-        get_lookup_value(term, LOOKUPS['crop'][0], model=MODEL, term=TERM_ID), default=0) * product_value
-    sd = safe_parse_float(get_lookup_value(term, LOOKUPS['crop'][1], model=MODEL, term=TERM_ID), default=0)
-    return value, sd
+    value, sd = [
+        safe_parse_float(get_lookup_value(term, lookup, model=MODEL, term=TERM_ID), default=0)
+        for lookup in LOOKUPS['crop']
+    ]
+    return value * product_value, sd
 
 
 def _run(products: list):
     values = list(map(_run_product, products))
     total_value = list_sum([value for value, _ in values])
     # TODO: we only fill-in sd for single values as the total value is complicated to calculate
-    total_sd = values[0][1] if len(values) == 1 else 0
+    total_sd = values[0][1] if len(values) == 1 else None
     return [
         _new_input(term=TERM_ID, model=MODEL, value=total_value, sd=total_sd)
     ] if total_value > 0 else []
@@ -53,8 +54,8 @@ def _run(products: list):
 def _should_run_product(product: dict):
     term = product.get('term', {})
     product_value = list_sum(product.get('value', []))
-    has_all_lookups = all([get_lookup_value(term, col, model=MODEL, term=TERM_ID) for col in LOOKUPS['crop']])
-    return all([has_all_lookups, product_value > 0])
+    has_lookup = get_lookup_value(term, LOOKUPS['crop'][0], model=MODEL, term=TERM_ID)
+    return all([has_lookup, product_value > 0])
 
 
 def _should_run(cycle: dict):

hestia_earth/models/hestia/management.py

@@ -206,7 +206,7 @@ def _get_relevant_items(cycle: dict, item_name: str, term_types: List[TermTermTy
 
 
 def _input_gap_fill_term_id(input: dict):
-    return get_lookup_value(input.get('term'), 'inputGapFillManagementTermId')
+    return get_lookup_value(input.get('term'), 'inputGapFillManagementTermId', skip_debug=True)
 
 
 def _input_value_valid(input: dict):
@@ -242,9 +242,10 @@ def _cycle_has_existing_non_cover_land_cover_nodes(cycle: dict) -> bool:
     # blankNodesGroup = Cover crops lookup, return True, else False
     return any([
         practice for practice in cycle.get("practices", [])
-        if practice.get("term", {}).get("termType") == TermTermType.LANDCOVER.value
-        and not any(prop for prop in practice.get("properties", [])
-                    if _is_cover_crop(prop.get("term", {}).get("@id")))
+        if practice.get("term", {}).get("termType") == TermTermType.LANDCOVER.value and not any(
+            prop for prop in practice.get("properties", [])
+            if _is_cover_crop(prop.get("term", {}).get("@id"))
+        )
     ])
 
 

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -11,6 +11,7 @@ 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 (
+    has_cycle_inputs_feed,
     practice_input_id,
     should_run_practice,
     calculate_meanDE,
@@ -79,7 +80,11 @@ REQUIREMENTS = {
                         "properties": [{
                             "@type": "Property",
                             "value": "",
-                            "term.@id": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"]
+                            "term.@id": [
+                                "neutralDetergentFibreContent",
+                                "energyContentHigherHeatingValue",
+                                "energyDigestibilityRuminants"
+                            ]
                         }]
                     }
                 }],
@@ -274,10 +279,8 @@ def _should_run(cycle: dict, animals: list, practices: dict):
     freshForage_incomplete = _is_term_type_incomplete(cycle, 'freshForage')
     all_animals_have_value = all([a.get('value', 0) > 0 for a in animals])
 
-    no_cycle_inputs_feed = all([not input.get('isAnimalFeed', False) for input in cycle.get('inputs', [])])
-
-    meanDE = calculate_meanDE(practices)
-    meanECHHV = calculate_meanECHHV(practices)
+    meanDE = calculate_meanDE(cycle, practices)
+    meanECHHV = calculate_meanECHHV(cycle, practices)
     REM = calculate_REM(meanDE)
     REG = calculate_REG(meanDE)
 
@@ -288,7 +291,6 @@ def _should_run(cycle: dict, animals: list, practices: dict):
         animalFeed_complete,
         animalPopulation_complete,
         freshForage_incomplete,
-        no_cycle_inputs_feed,
         all_animals_have_value,
         has_practice_termType_system,
         has_practice_pastureGrass_with_landCover_key,
@@ -302,12 +304,11 @@ def _should_run(cycle: dict, animals: list, practices: dict):
                             term_type_animalFeed_complete=animalFeed_complete,
                             term_type_animalPopulation_complete=animalPopulation_complete,
                             term_type_freshForage_incomplete=freshForage_incomplete,
-                            no_cycle_inputs_feed=no_cycle_inputs_feed,
                             all_animals_have_value=all_animals_have_value,
                             has_practice_termType_system=has_practice_termType_system,
                             has_practice_pastureGrass_with_landCover_key=has_practice_pastureGrass_with_landCover_key,
-                            grass_MeanDE=calculate_meanDE(practices, term=term_id),
-                            grass_MeanECHHV=calculate_meanECHHV(practices, term=term_id),
+                            grass_MeanDE=calculate_meanDE(cycle, practices, term=term_id),
+                            grass_MeanECHHV=calculate_meanECHHV(cycle, practices, term=term_id),
                             grass_REM=REM,
                             grass_REG=REG)
 
@@ -316,8 +317,13 @@ def _should_run(cycle: dict, animals: list, practices: dict):
     return should_run, meanDE, meanECHHV, REM, REG, systems
 
 
-def run(cycle: dict):
+def _run(cycle: dict):
     animals = get_animals_by_period(cycle)
     practices = list(filter(should_run_practice(cycle), cycle.get('practices', [])))
     should_run, meanDE, meanECHHV, REM, REG, systems = _should_run(cycle, animals, practices)
     return list(map(_run_animal(cycle, meanDE, meanECHHV, REM, REG, systems, practices), animals)) if should_run else []
+
+
+def run(cycle: dict):
+    # determines if this model or animal model should run
+    return _run(cycle) if not has_cycle_inputs_feed(cycle) else []

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -10,6 +10,7 @@ from hestia_earth.models.utils.completeness import _is_term_type_complete, _is_t
 from hestia_earth.models.utils.cycle import get_animals_by_period
 from . import MODEL
 from .pastureGrass_utils import (
+    has_cycle_inputs_feed,
     practice_input_id,
     should_run_practice,
     calculate_meanDE,
@@ -56,7 +57,11 @@ REQUIREMENTS = {
                 "properties": [{
                     "@type": "Property",
                     "value": "",
-                    "term.@id": ["neutralDetergentFibreContent", "energyContentHigherHeatingValue"]
+                    "term.@id": [
+                        "neutralDetergentFibreContent",
+                        "energyContentHigherHeatingValue",
+                        "energyDigestibilityRuminants"
+                    ]
                 }]
             }
         }],
@@ -227,10 +232,8 @@ def _should_run(cycle: dict, practices: dict):
     freshForage_incomplete = _is_term_type_incomplete(cycle, 'freshForage')
     all_animals_have_value = all([a.get('value', 0) > 0 for a in cycle.get('animals', [])])
 
-    has_cycle_inputs_feed = any([i.get('isAnimalFeed', False) for i in cycle.get('inputs', [])])
-
-    meanDE = calculate_meanDE(practices)
-    meanECHHV = calculate_meanECHHV(practices)
+    meanDE = calculate_meanDE(cycle, practices)
+    meanECHHV = calculate_meanECHHV(cycle, practices)
     REM = calculate_REM(meanDE)
     REG = calculate_REG(meanDE)
 
@@ -241,7 +244,6 @@ def _should_run(cycle: dict, practices: dict):
         animalFeed_complete,
         animalPopulation_complete,
         freshForage_incomplete,
-        has_cycle_inputs_feed,
         all_animals_have_value,
         has_practice_termType_system,
         has_practice_pastureGrass_with_landCover_key,
@@ -254,12 +256,11 @@ def _should_run(cycle: dict, practices: dict):
                         term_type_animalFeed_complete=animalFeed_complete,
                         term_type_animalPopulation_complete=animalPopulation_complete,
                         term_type_freshForage_incomplete=freshForage_incomplete,
-                        has_cycle_inputs_feed=has_cycle_inputs_feed,
                         all_animals_have_value=all_animals_have_value,
                         has_practice_termType_system=has_practice_termType_system,
                         has_practice_pastureGrass_with_landCover_key=has_practice_pastureGrass_with_landCover_key,
-                        grass_MeanDE=calculate_meanDE(practices, term=term_id),
-                        grass_MeanECHHV=calculate_meanECHHV(practices, term=term_id),
+                        grass_MeanDE=calculate_meanDE(cycle, practices, term=term_id),
+                        grass_MeanECHHV=calculate_meanECHHV(cycle, practices, term=term_id),
                         grass_REM=REM,
                         grass_REG=REG)
 
@@ -268,9 +269,14 @@ def _should_run(cycle: dict, practices: dict):
     return should_run, meanDE, meanECHHV, REM, REG, systems
 
 
-def run(cycle: dict):
+def _run(cycle: dict):
     practices = list(filter(should_run_practice(cycle), cycle.get('practices', [])))
     should_run, meanDE, meanECHHV, REM, REG, systems = _should_run(cycle, practices)
     return non_empty_list(
         map(_run_practice(cycle, meanDE, meanECHHV, REM, REG, systems), practices)
     ) if should_run else []
+
+
+def run(cycle: dict):
+    # determines if this model or animal model should run
+    return _run(cycle) if has_cycle_inputs_feed(cycle) else []