hestia-earth-models 0.75.1__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",
@@ -1294,6 +1296,21 @@
         },
         "stage": 2
       },
+      {
+        "key": "emissions",
+        "model": "ipcc2019",
+        "value": "emissionsToAirOrganicSoilBurning",
+        "runStrategy": "always",
+        "runArgs": {
+          "runNonMeasured": true,
+          "runNonAddedTerm": true
+        },
+        "mergeStrategy": "list",
+        "mergeArgs": {
+          "replaceThreshold": ["value", 0.01]
+        },
+        "stage": 2
+      },
       {
         "key": "emissions",
         "model": "schmidt2007",
@@ -1353,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
       }
     ],
     [
@@ -1831,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/cycle/product/economicValueShare.py

@@ -1,5 +1,5 @@
 from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import list_sum
+from hestia_earth.utils.tools import list_sum, to_precision
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.term import get_lookup_value
@@ -43,7 +43,7 @@ MIN_COMPLETE_VALUE = 80  # when the products are complete lower the min threshol
 
 
 def _product(product: dict, value: float):
-    return product | {MODEL_KEY: value}
+    return product | {MODEL_KEY: to_precision(value, 2 if value < 1 else 3 if value < 10 else 4)}
 
 
 def _is_complete(cycle: dict): return cycle.get('completeness', {}).get('product', False)
@@ -57,11 +57,11 @@ def _total_evs(products: list): return sum([p.get(MODEL_KEY, 0) for p in product
 
 def _product_with_value(product: dict):
     value = product.get(MODEL_KEY, lookup_share(MODEL_KEY, product))
-    return product | {MODEL_KEY: value} if value is not None else product
+    return _product(product, value) if value is not None else product
 
 
 def _rescale_value(products: list, total: float):
-    return list(map(lambda p: {**p, MODEL_KEY: p.get(MODEL_KEY) * 100 / total}, products))
+    return list(map(lambda p: _product(p, p.get(MODEL_KEY) * 100 / total), products))
 
 
 def _should_run_by_default(cycle: dict, products: list):

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/geospatialDatabase/histosol.py

@@ -1,7 +1,10 @@
-from hestia_earth.schema import MeasurementMethodClassification
+from hestia_earth.schema import MeasurementMethodClassification, TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.blank_node import get_node_value
+from hestia_earth.utils.tools import pick
 
-from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.measurement import _new_measurement, total_other_soilType_value
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.measurement import _new_measurement
 from hestia_earth.models.utils.source import get_source
 from .utils import download, has_geospatial_data, should_download
 from . import MODEL
@@ -16,10 +19,10 @@ REQUIREMENTS = {
         "none": {
             "measurements": [{
                 "@type": "Measurement",
-                "value": "100",
+                "value": "> 0",
                 "depthUpper": "0",
                 "depthLower": "30",
-                "term.termType": "soilType"
+                "term.termType": ["soilType", "usdaSoilType"]
             }]
         }
     }
@@ -39,12 +42,14 @@ EE_PARAMS = {
     'reducer': 'mean'
 }
 BIBLIO_TITLE = 'Harmonized World Soil Database Version 1.2. Food and Agriculture Organization of the United Nations (FAO).'  # noqa: E501
+_DEPTH_UPPER = 0
+_DEPTH_LOWER = 30
 
 
 def _measurement(site: dict, value: float):
     measurement = _new_measurement(term=TERM_ID, value=value)
-    measurement['depthUpper'] = 0
-    measurement['depthLower'] = 30
+    measurement['depthUpper'] = _DEPTH_UPPER
+    measurement['depthLower'] = _DEPTH_LOWER
     measurement['methodClassification'] = MeasurementMethodClassification.GEOSPATIAL_DATASET.value
     return measurement | get_source(site, BIBLIO_TITLE)
 
@@ -58,15 +63,30 @@ def _should_run(site: dict):
     contains_geospatial_data = has_geospatial_data(site)
     below_max_area_size = should_download(TERM_ID, site)
 
-    total_measurements_value = total_other_soilType_value(site.get('measurements', []), TERM_ID)
+    measurements = filter_list_term_type(site.get('measurements', []), [
+        TermTermType.SOILTYPE,
+        TermTermType.USDASOILTYPE
+    ])
+    measurements = [m for m in measurements if all([
+        m.get('depthUpper', -1) == _DEPTH_UPPER,
+        m.get('depthLower', 0) == _DEPTH_LOWER,
+        get_node_value(m) > 0
+    ])]
+    has_soil_type_measurements = len(measurements) > 0
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,
                     below_max_area_size=below_max_area_size,
-                    total_soilType_measurements_value=total_measurements_value,
-                    total_soilType_measurements_value_is_0=total_measurements_value == 0)
+                    has_soil_type_measurements=has_soil_type_measurements,
+                    soil_type_measurements=log_as_table([
+                        {
+                            'id': m.get('term', {}).get('@id'),
+                            'termType': m.get('term', {}).get('termType'),
+                            'value': get_node_value(m)
+                        } | pick(m, ['depthUpper', 'depthLower']) for m in measurements
+                    ]))
 
-    should_run = all([contains_geospatial_data, below_max_area_size, total_measurements_value == 0])
+    should_run = all([contains_geospatial_data, below_max_area_size, not has_soil_type_measurements])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

hestia_earth/models/hestia/aboveGroundCropResidueTotal.py

@@ -9,8 +9,8 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "practices": [{"@type": "Practice", "value": "", "term.termType": "cropResidue"}],
-        "products": [{"@type": "Product", "value": "", "term.termType": "cropResidueManagement"}]
+        "practices": [{"@type": "Practice", "value": "", "term.termType": "cropResidueManagement"}],
+        "products": [{"@type": "Product", "value": "", "term.termType": "cropResidue"}]
     }
 }
 RETURNS = {

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"))
+        )
     ])