hestia-earth-models 0.73.2__py3-none-any.whl → 0.73.3__py3-none-any.whl

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/environmentalFootprintV3_1/soilQualityIndexLandTransformation.py

@@ -92,10 +92,10 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
 
     found_transformations = [
         {
+            'indicator-id': indicator.get('term', {}).get('@id', ''),
             'value': _node_value(indicator),
             'land-cover-id-from': indicator.get('previousLandCover', {}).get("@id"),
             'land-cover-id-to': indicator.get('landCover', {}).get("@id"),
-            'indicator-id': indicator.get('term', {}).get('@id', ''),
             'good-land-cover-term': all([
                 bool(indicator.get('landCover')),
                 bool(indicator.get('previousLandCover'))

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/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/hestia/default_emissions.py

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

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/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/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/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/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/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/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 []