hestia-earth-models 0.75.1__tar.gz → 0.75.3__tar.gz

{hestia_earth_models-0.75.1/hestia_earth_models.egg-info → hestia_earth_models-0.75.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hestia_earth_models
-Version: 0.75.1
+Version: 0.75.3
 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.75.1 → hestia_earth_models-0.75.3}/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-0.75.1 → hestia_earth_models-0.75.3}/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-0.75.3/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-0.75.3/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-0.75.3/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-0.75.3/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-0.75.3/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-0.75.3/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-0.75.3/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-0.75.1 → hestia_earth_models-0.75.3}/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-0.75.1 → hestia_earth_models-0.75.3}/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-0.75.1 → hestia_earth_models-0.75.3}/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-0.75.1 → hestia_earth_models-0.75.3}/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"))
+        )
     ])