hestia-earth-models 0.73.2__tar.gz → 0.73.3__tar.gz

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia_earth_models
-Version: 0.73.2
+Version: 0.73.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.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/environmentalFootprintV3_1/soilQualityIndexLandOccupation.py

@@ -16,7 +16,7 @@ REQUIREMENTS = {
         "optional": {"country": {"@type": "Term", "termType": "region"}},
         "emissionsResourceUse": [{
             "@type": "Indicator",
-            "value": ">0",
+            "value": ">=0",
             "term.@id": ["landOccupationInputsProduction", "landOccupationDuringCycle"],
             "term.units": "m2*year",
             "landCover": {"@type": "Term", "term.termType": "landCover"}
@@ -60,12 +60,13 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     ]
 
     found_land_occupation_indicators = [{
+        'indicator-id': indicator.get('term', {}).get('@id', ''),
         'area-by-year': _node_value(indicator),
         'area-unit': indicator.get('term', {}).get("units"),
         'land-cover-id': indicator.get('landCover', {}).get("@id"),
         'country-id': get_country_id(impact_assessment, blank_node=indicator),
         'area-by-year-is-valid': _node_value(indicator) is not None and _node_value(
-            indicator) > 0,
+            indicator) >= 0,
         'area-unit-is-valid': indicator.get('term', {}).get("units") == "m2*year",
         'used-country': fallback_country(get_country_id(impact_assessment, blank_node=indicator), [LOOKUP]),
         'pef-grouping': get_pef_grouping(indicator.get('landCover', {}).get("@id"))

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/frischknechtEtAl2000/ionisingRadiationKbqU235Eq.py

@@ -1,9 +1,11 @@
+from functools import reduce
 from hestia_earth.schema import TermTermType
 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.utils.tools import flatten, list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.indicator import _new_indicator
 from hestia_earth.models.utils.lookup import _node_value
 from . import MODEL
@@ -47,22 +49,24 @@ 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):
+def _indicator(value: float, input: dict) -> dict:
     indicator = _new_indicator(TERM_ID, MODEL)
     indicator['value'] = value
     indicator['inputs'] = [input]
     return indicator
 
 
-def _run(emissions: list):
+def _run(emissions: list) -> list[dict]:
     indicators = [
-        _indicator(value=emission['value'] * emission['coefficient'], input=emission['input'])
-        for emission in emissions
+        _indicator(value=list_sum([emission['value'] * emission['coefficient'] for emission in emission_group]),
+                   input=emission_group[0]['input'])
+        for emission_group in reduce(group_by_keys(['input']), emissions, {}).values()
     ]
+
     return indicators
 
 
-def _should_run(impact_assessment: dict):
+def _should_run(impact_assessment: dict) -> tuple[bool, list]:
     emissions = [
         emission
         for emission in filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.EMISSION)

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/geospatialDatabase/utils.py

@@ -1,6 +1,7 @@
 import os
+import json
 from area import area
-from functools import reduce
+from functools import reduce, lru_cache
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.tools import non_empty_list
 
@@ -10,6 +11,7 @@ from hestia_earth.models.utils.term import download_term
 from . import MODEL
 
 MAX_AREA_SIZE = int(os.getenv('MAX_AREA_SIZE', '5000'))
+_ENABLE_CACHE_BOUNDARY_AREA = os.getenv('CACHE_BOUNDARY_AREA', 'false') == 'true'
 CACHE_VALUE = MODEL
 CACHE_AREA_SIZE = 'areaSize'
 GEOPANDAS_COLLECTION_NAME = {
@@ -85,17 +87,28 @@ def geospatial_data(site: dict, only_coordinates=False):
     })
 
 
-def _get_boundary_area_size(boundary: dict):
+def _geojson_area_size(boundary: dict):
+    return (
+        _geojson_area_size(boundary.get('geometry')) if 'geometry' in boundary else
+        reduce(lambda p, c: p + _geojson_area_size(c), boundary.get('features'), 0) if 'features' in boundary
+        else area(boundary) / 1_000_000
+    )
+
+
+@lru_cache()
+def _cached_boundary_area_size(boundary: str):
     try:
-        return (
-            (area(boundary.get('geometry')) / 1_000_000) if 'geometry' in boundary else
-            reduce(lambda p, c: p + _get_boundary_area_size(c), boundary.get('features'), 0) if 'features' in boundary
-            else area(boundary) / 1_000_000
-        )
+        return _geojson_area_size(json.loads(boundary))
     except Exception:
         return None
 
 
+def _get_boundary_area_size(boundary: dict):
+    return _cached_boundary_area_size(
+        boundary=json.dumps(boundary)
+    ) if _ENABLE_CACHE_BOUNDARY_AREA else _geojson_area_size(boundary=boundary)
+
+
 def _get_region_area_size(site: dict):
     term = site.get('region', site.get('country'))
     return term.get('area', (download_term(term.get('@id'), TermTermType.REGION) or {}).get('area')) if term else None

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/hestia/default_emissions.py

@@ -31,6 +31,7 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
+    "emission": "inHestiaDefaultSystemBoundary",
     "organicFertiliser": "backgroundEmissionsResourceUseDefaultValue"
 }
 MODEL_KEY = 'default_emissions'

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/hestia/default_resourceUse.py

@@ -1,6 +1,6 @@
 from hestia_earth.schema import IndicatorMethodTier, TermTermType
 from hestia_earth.utils.tools import flatten, safe_parse_float
-from hestia_earth.utils.lookup import download_lookup, lookup_term_ids
+from hestia_earth.utils.emission import emissions_in_system_boundary
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils import _omit
@@ -34,6 +34,7 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
+    "resourceUse": "inHestiaDefaultSystemBoundary",
     "organicFertiliser": "backgroundEmissionsResourceUseDefaultValue"
 }
 MODEL_KEY = 'default_resourceUse'
@@ -54,7 +55,7 @@ def _default_value(input: dict):
 
 def _run_input(impact: dict):
     required_resourceUse_term_ids = [
-        id for id in lookup_term_ids(download_lookup(f"{TermTermType.RESOURCEUSE.value}.csv"))
+        id for id in emissions_in_system_boundary(TermTermType.RESOURCEUSE)
         if id.endswith('InputsProduction')
     ]
 

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/hestia/excretaKgMass.py

@@ -52,7 +52,7 @@ def _convert_by_product(cycle: dict, product: dict, term_id: str):
         conversion_to_kg_ratio
     ]) else None
 
-    debugValues(cycle, model=MODEL, term=term_id,
+    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 using_excreta_product=existing_product.get('term', {}).get('@id'),
                 conversion_to_kg_ratio=conversion_to_kg_ratio,
                 value=value)

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/hestia/excretaKgN.py

@@ -38,7 +38,7 @@ def _run_product(cycle: dict, term_id: str):
     existing_kg_product = find_term_match(cycle.get('products', []), get_kg_term_id(term_id))
     value = convert_product_to_unit(existing_kg_product, Units.KG_N)
 
-    debugValues(cycle, model=MODEL, term=term_id,
+    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 using_excreta_product=existing_kg_product.get('term', {}).get('@id'),
                 value=value)
 

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/hestia/excretaKgVs.py

@@ -38,7 +38,7 @@ def _run_product(cycle: dict, term_id: str):
     existing_kg_product = find_term_match(cycle.get('products', []), get_kg_term_id(term_id))
     value = convert_product_to_unit(existing_kg_product, Units.KG_VS)
 
-    debugValues(cycle, model=MODEL, term=term_id,
+    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 using_excreta_product=existing_kg_product.get('term', {}).get('@id'),
                 value=value)
 

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/hestia/landCover.py

@@ -818,7 +818,7 @@ def _should_run(site: dict) -> tuple[bool, list, dict]:
 
     has_no_prior_land_cover_data = _no_prior_land_cover_data(
         nodes=management_nodes,
-        target_node=relevant_nodes[-1:][0]
+        target_node=relevant_nodes[0]
     ) if relevant_nodes else None
 
     should_run_nodes, site_area = _should_run_historical_land_use_change(

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/hestia/waterSalinity.py

@@ -1,11 +1,13 @@
+from functools import reduce
 from hestia_earth.schema import MeasurementMethodClassification, TermTermType
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import safe_parse_float
+from hestia_earth.utils.tools import safe_parse_float, list_average, non_empty_list
 
 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.site import related_cycles
 from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.blank_node import group_by_keys
 from . import MODEL
 
 REQUIREMENTS = {
@@ -43,7 +45,7 @@ def _measurement(value: float, start_date: str = None, end_date: str = None):
     if start_date:
         data['startDate'] = start_date
     data['methodClassification'] = MeasurementMethodClassification.EXPERT_OPINION.value
-    return data
+    return data if value is not None else None
 
 
 def _should_run(site: dict):
@@ -73,7 +75,12 @@ def _should_run(site: dict):
 
 def run(site: dict):
     should_run, values = _should_run(site)
-    return [
-        _measurement(value.get('lookup-value'), value.get('start-date'), value.get('end-date'))
-        for value in values if value.get('lookup-value') is not None
-    ] if should_run else []
+    grouped_values = reduce(group_by_keys(['start-date', 'end-date']), values, {})
+    return non_empty_list([
+        _measurement(
+            list_average([v.get('lookup-value') for v in value if v.get('lookup-value')], default=0),
+            value[0].get('start-date'),
+            value[0].get('end-date')
+        )
+        for value in grouped_values.values()
+    ]) if should_run else []

{hestia_earth_models-0.73.2 → hestia_earth_models-0.73.3}/hestia_earth/models/ipcc2019/n2OToAirCropResidueBurningDirect.py

@@ -38,24 +38,25 @@ def _emission(value: float):
     return emission
 
 
-def _run(product_value: list):
+def _run(product_value: list, factor: float):
     value = sum(product_value)
-    factor = get_lookup_value({'termType': 'emission', '@id': TERM_ID}, LOOKUPS['emission'][0])
     return [_emission(value * factor)]
 
 
 def _should_run(cycle: dict):
     crop_residue_burnt_value = get_crop_residue_burnt_value(cycle)
     has_crop_residue_burnt = len(crop_residue_burnt_value) > 0
+    factor = get_lookup_value({'termType': 'emission', '@id': TERM_ID}, LOOKUPS['emission'][0])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_crop_residue_burnt=has_crop_residue_burnt)
+                    has_crop_residue_burnt=has_crop_residue_burnt,
+                    burning_factor=factor)
 
-    should_run = all([has_crop_residue_burnt])
+    should_run = all([has_crop_residue_burnt, factor is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, crop_residue_burnt_value
+    return should_run, crop_residue_burnt_value, factor
 
 
 def run(cycle: dict):
-    should_run, crop_residue_burnt_value = _should_run(cycle)
-    return _run(crop_residue_burnt_value) if should_run else []
+    should_run, crop_residue_burnt_value, factor = _should_run(cycle)
+    return _run(crop_residue_burnt_value, factor) if should_run else []