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

hestia_earth/models/cml2001Baseline/abioticResourceDepletionFossilFuels.py

@@ -100,8 +100,8 @@ def download_all_non_renewable_terms(lookup_file_name: str) -> list:
 
 def _valid_resource_indicator(resource: dict) -> bool:
     return len(resource.get('inputs', [])) == 1 and \
-           isinstance(_node_value(resource), (int, float)) and \
-           _node_value(resource) > 0
+        isinstance(_node_value(resource), (int, float)) and \
+        _node_value(resource) > 0
 
 
 def _valid_input(input: dict) -> bool:
@@ -166,9 +166,7 @@ def _should_run(impact_assessment: dict) -> tuple[bool, list]:
                     all_inputs_have_valid_mj_value=all_inputs_have_valid_mj_value,
                     energy_resources_used=log_as_table(resource_uses_unpacked))
 
-    should_run = has_resource_use_entries is False or all([has_resource_use_entries,
-                                                           has_valid_input_requirements,
-                                                           all_inputs_have_valid_mj_value])
+    should_run = all([has_resource_use_entries, has_valid_input_requirements, all_inputs_have_valid_mj_value])
 
     logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
     return should_run, valid_energy_resources_in_mj

hestia_earth/models/cml2001Baseline/abioticResourceDepletionMineralsAndMetals.py

@@ -125,7 +125,7 @@ def _should_run(impact_assessment: dict) -> tuple[bool, list]:
                     resource_uses=log_as_table(resource_uses_unpacked)
                     )
 
-    should_run = has_valid_input_requirements
+    should_run = all([has_valid_input_requirements, has_resource_use_entries])
 
     logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
     return should_run, valid_resources_with_cf

hestia_earth/models/config/Cycle.json

@@ -609,15 +609,7 @@
         "stage": 2
       },
       {
-        "key": "inputs",
-        "model": "cycle",
-        "value": "energyContentLowerHeatingValue",
-        "runStrategy": "always",
-        "mergeStrategy": "list",
-        "stage": 2
-      },
-      {
-        "key": "products",
+        "key": "animals",
         "model": "cycle",
         "value": "milkYield",
         "runStrategy": "always",
@@ -625,6 +617,14 @@
         "stage": 2
       }
     ],
+    {
+      "key": "inputs",
+      "model": "cycle",
+      "value": "energyContentLowerHeatingValue",
+      "runStrategy": "always",
+      "mergeStrategy": "list",
+      "stage": 2
+    },
     {
       "key": "products",
       "model": "cycle",

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