hestia-earth-models 0.65.8__py3-none-any.whl → 0.65.10__py3-none-any.whl

hestia_earth/models/config/Site.json

@@ -432,6 +432,24 @@
         "stage": 2
       }
     ],
+    [
+      {
+        "key": "defaultMethodClassification",
+        "model": "site",
+        "value": "defaultMethodClassification",
+        "runStrategy": "add_key_if_missing",
+        "mergeStrategy": "default",
+        "stage": 2
+      },
+      {
+        "key": "defaultMethodClassificationDescription",
+        "model": "site",
+        "value": "defaultMethodClassificationDescription",
+        "runStrategy": "add_key_if_missing",
+        "mergeStrategy": "default",
+        "stage": 2
+      }
+    ],
     [
       {
         "key": "measurements",

hestia_earth/models/config/__init__.py

@@ -69,3 +69,9 @@ def load_run_config(node_type: str, stage: int):
 
 def load_trigger_config(node_type: str, stage: int):
     return _load_stage_config('trigger-calculations', node_type, stage)
+
+
+def get_max_stage(node_type: str):
+    config = _load_config('run-calculations').get(node_type, {})
+    stages = list(map(lambda k: int(k.replace('stage-', '')), config.keys()))
+    return max(stages)

hestia_earth/models/config/run-calculations.json

@@ -15,11 +15,6 @@
         "key": "nested",
         "type": "Site",
         "stage": 1
-      },
-      {
-        "key": "nested",
-        "type": "ImpactAssessment",
-        "stage": 1
       }
     ],
     "stage-2": [
@@ -27,6 +22,11 @@
         "key": "nested",
         "type": "Site",
         "stage": 2
+      },
+      {
+        "key": "nested",
+        "type": "ImpactAssessment",
+        "stage": 1
       }
     ]
   },

hestia_earth/models/config/trigger-calculations.json

@@ -36,7 +36,7 @@
       {
         "key": "related",
         "type": "Cycle",
-        "stage": 1
+        "stage": 2
       }
     ]
   }

hestia_earth/models/cycle/materialAndSubstrate.py

@@ -106,7 +106,7 @@ def _has_depreciated_term(term: dict):
 def _should_run_input(cycle: dict, input_node: dict) -> bool:
     term = input_node.get('term', {})
     term_id = term.get('@id')
-    has_lifespan = input_node.get('lifespan', 0) > 0
+    has_lifespan = input_node.get('lifespan') or 0 > 0
     has_valid_value = _get_value(input_node, 'value') > 0
     has_depreciated_term = _has_depreciated_term(term)
 

hestia_earth/models/cycle/milkYield.py

@@ -39,12 +39,15 @@ REQUIREMENTS = {
     }
 }
 RETURNS = {
-    "Practice": [{
-        "value": "",
-        "min": "",
-        "max": "",
-        "sd": "",
-        "statsDefinition": "modelled"
+    "Animal": [{
+        "practices": [{
+            "@type": "Practice",
+            "value": "",
+            "min": "",
+            "max": "",
+            "sd": "",
+            "statsDefinition": "modelled"
+        }]
     }]
 }
 LOOKUPS = {

hestia_earth/models/cycle/product/economicValueShare.py

@@ -15,7 +15,7 @@ corresponding value, the `economicValueShare` will be proportionally distributed
 from hestia_earth.utils.model import find_term_match
 from hestia_earth.utils.tools import list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.blank_node import get_lookup_value
 from hestia_earth.models.utils.cycle import unique_currencies
 from .utils import lookup_share
@@ -55,7 +55,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: value}
 
 
 def _is_complete(cycle: dict): return cycle.get('completeness', {}).get('product', False)
@@ -69,7 +69,7 @@ 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 | {MODEL_KEY: value} if value is not None else product
 
 
 def _rescale_value(products: list, total: float):
@@ -87,7 +87,11 @@ def _should_run_by_default(cycle: dict, products: list):
     for p in products:
         term_id = p.get('term', {}).get('@id')
         logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
-                        all_with_economicValueShare=all_with_economicValueShare)
+                        all_with_economicValueShare=all_with_economicValueShare,
+                        products_with_share=log_as_table([{
+                            'id': p.get('term', {}).get('@id'),
+                            MODEL_KEY: p.get(MODEL_KEY)
+                        } for p in products]))
         logShouldRun(cycle, MODEL, term_id, should_run, key=MODEL_KEY, by=run_by)
 
     return should_run

hestia_earth/models/cycle/product/revenue.py

@@ -48,18 +48,22 @@ def _run(cycle: dict):
 def _should_run(cycle: dict):
     def should_run_product(product: dict):
         term_id = product.get('term', {}).get('@id')
-        has_yield = len(product.get('value', [])) > 0
-        has_price = product.get('price', 0) > 0
-        has_yield_and_price = has_yield and has_price
-        is_yield_0 = list_sum(product.get('value', []), -1) == 0
-        is_price_0 = product.get('price', -1) == 0
+
+        value = list_sum(product.get('value') or [], default=None)
+        has_yield = bool(value)
+        is_yield_0 = value == 0
+
+        price = product.get('price') or -1
+        has_price = price > 0
+        is_price_0 = price == 0
 
         logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY,
-                        has_yield_and_price=has_yield_and_price,
+                        has_yield=has_yield,
+                        has_price=has_price,
                         is_yield_0=is_yield_0,
                         is_price_0=is_price_0)
 
-        should_run = any([has_yield_and_price, is_yield_0, is_price_0])
+        should_run = any([has_yield and has_price, is_yield_0, is_price_0])
         logShouldRun(cycle, MODEL, term_id, should_run, key=MODEL_KEY)
         return should_run
     return should_run_product

hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -25,7 +25,8 @@ REQUIREMENTS = {
             {
                 "@type": "Indicator",
                 "term.termType": "resourceUse",
-                "term.name": "Land transformation",
+                "term.@id": ["landTransformation20YearAverageInputsProduction",
+                             "landTransformation20YearAverageDuringCycle"],
                 "value": "> 0",
                 "landCover": {"@type": "Term", "term.termType": "landCover"},
                 "previousLandCover": {"@type": "Term", "term.termType": "landCover"}
@@ -74,6 +75,10 @@ def _run(transformations: List[dict]):
     return _indicator(list_sum(values))
 
 
+def _is_valid_indicator(indicator: dict) -> bool:
+    return indicator['term']['@id'] in REQUIREMENTS['ImpactAssessment']['emissionsResourceUse'][0]['term.@id']
+
+
 def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     resource_uses = filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE)
     found_transformations = [
@@ -82,7 +87,9 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
             'land-cover-id-from': transformation_indicator.get('previousLandCover', {}).get("@id"),
             'land-cover-id-to': transformation_indicator.get('landCover', {}).get("@id"),
             'indicator-id': transformation_indicator.get('term', {}).get('@id', ''),
-            'good-land-cover-term': transformation_indicator.get('landCover', {}).get('termType') == 'landCover',
+            'indicator-is-valid': _is_valid_indicator(transformation_indicator),
+            'good-land-cover-term': all([bool(transformation_indicator.get('landCover')),
+                                         bool(transformation_indicator.get('previousLandCover'))]),
             'country-id': get_country_id(impact_assessment),
             'area-is-valid': _node_value(transformation_indicator) is not None and _node_value(
                 transformation_indicator) > 0,
@@ -112,19 +119,20 @@ def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
     valid_transformations_with_coef = [
         t for t in found_transformations_with_coefficient if all([
             t['area-is-valid'],
+            t['indicator-is-valid'],
             t['factor-from'] is not None,
             t['factor-to'] is not None
         ])
     ]
 
     has_land_transformation_indicators = any([
-        indicator.get('term', {}).get('@id').startswith('landTransformation')
+        _is_valid_indicator(indicator)
         for indicator in resource_uses
     ])
 
     all_transformations_are_valid = all(
         [
-            all([t['area-is-valid'], t['good-land-cover-term']])
+            all([t['area-is-valid'], t['indicator-is-valid'], t['good-land-cover-term']])
             for t in found_transformations_with_coefficient
         ]
     ) if found_transformations_with_coefficient else False

hestia_earth/models/faostat2018/product/price.py

@@ -129,7 +129,7 @@ def _run_by_country(cycle: dict, product: dict, country_id: str, year: int = Non
     term_type = product_term.get('termType')
     term_units = product_term.get('units')
 
-    has_yield = len(product.get('value', [])) > 0
+    has_yield = len(product.get('value') or []) > 0
     not_already_set = MODEL_KEY not in product.keys()
 
     # get the grouping used in region lookup

hestia_earth/models/geospatialDatabase/utils.py

@@ -29,6 +29,11 @@ def to_celcius(kelvin_value: int): return kelvin_value - KELVIN_0 if kelvin_valu
 def use_geopandas(): return os.getenv('HEE_USE_GEOPANDAS', 'false') == 'true'
 
 
+def _has_cache(site: dict):
+    cache = cached_value(site, key=CACHE_VALUE, default=None)
+    return bool(cache)
+
+
 def _cached_value(site: dict, key: str):
     return cached_value(site, key=CACHE_VALUE, default={}).get(key)
 
@@ -166,23 +171,23 @@ def download(term: str, site: dict, data: dict, only_coordinates=False) -> dict:
         Data returned from the API.
     """
     # check if we have cached the result already, else run and parse result
-    value = _get_cached_data(term, site, data)
-
-    # make sure to run only if value is None (not 0)
-    if value is None:
-        location_data = geospatial_data(site, only_coordinates=only_coordinates)
-        query = {
-            'ee_type': data.get('ee_type'),
-            **location_data,
-            'collections': [
-                {
-                    **data,
-                    'collection': _collection_name(data.get('collection'))
-                }
-            ]
-        }
-        value = _parse_run_query(term, query)
-
+    if _has_cache(site):
+        # even if the cached value is null, we do not want to run the query again
+        # TODO: we might want to store the date it was cached, and run again if more than 30 days
+        return _get_cached_data(term, site, data)
+
+    location_data = geospatial_data(site, only_coordinates=only_coordinates)
+    query = {
+        'ee_type': data.get('ee_type'),
+        **location_data,
+        'collections': [
+            {
+                **data,
+                'collection': _collection_name(data.get('collection'))
+            }
+        ]
+    }
+    value = _parse_run_query(term, query)
     if value is None:
         debugValues(site, model=MODEL, term=term, value_from_earth_engine=None)
     return value

hestia_earth/models/hestia/landCover.py

@@ -34,7 +34,7 @@ from .utils import (
     crop_ipcc_land_use_category,
 )
 from . import MODEL
-from ..utils.blank_node import _node_date, DatestrFormat
+from ..utils.blank_node import _node_date, DatestrFormat, _gapfill_datestr, DatestrGapfillMode
 from ..utils.constant import DAYS_IN_YEAR
 
 REQUIREMENTS = {
@@ -697,7 +697,7 @@ def _collect_land_use_types(nodes: list) -> list:
         {
             "id": node.get("term", {}).get("@id"),
             "land-use-type": _get_land_use_term_from_node(node),
-            "endDate": node.get("endDate")
+            "endDate": _gapfill_datestr(datestr=node.get("endDate"), mode=DatestrGapfillMode.END)[:10]
         } for node in nodes
     ]