hestia-earth-models 0.65.9__py3-none-any.whl → 0.65.11__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

hestia_earth/models/hestia/landCover.py

@@ -82,7 +82,8 @@ LOOKUPS = {
         "Permanent meadows and pastures"
     ],
     "crop": ["cropGroupingFaostatArea", "IPCC_LAND_USE_CATEGORY"],
-    "landCover": ["cropGroupingFaostatProduction", "FAOSTAT_LAND_AREA_CATEGORY"]
+    "landCover": ["cropGroupingFaostatProduction", "FAOSTAT_LAND_AREA_CATEGORY"],
+    "property": "CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY"
 }
 MODEL_KEY = 'landCover'
 
@@ -120,6 +121,13 @@ def site_area_sum_to_100(dict_of_percentages: dict):
          math.isclose(sum(dict_of_percentages.values()), 0.0, rel_tol=0.01))
 
 
+def _should_group_landCover(term: dict):
+    return any(
+        bool(get_lookup_value(lookup_term=prop.get("term", {}), column="CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY"))
+        for prop in term.get("properties", [])
+    )
+
+
 def get_changes(country_id: str, end_year: int) -> dict:
     """
     For each entry in ALL_LAND_USE_TERMS, creates a key: value in output dictionary, also TOTAL
@@ -714,8 +722,7 @@ def _no_prior_land_cover_data(nodes: list, end_date: str) -> bool:
     return len(previous_nodes) == 0
 
 
-def _should_run(site: dict) -> tuple[bool, dict]:
-    management_nodes = filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+def _should_run(site: dict, management_nodes: list) -> tuple[bool, dict]:
     summarised_nodes = _collect_land_use_types(management_nodes)
     allowed_land_use_types = [ANNUAL_CROPLAND, PERMANENT_CROPLAND, PERMANENT_PASTURE]
     relevant_nodes = sorted(
@@ -751,8 +758,11 @@ def _should_run(site: dict) -> tuple[bool, dict]:
 
 
 def run(site: dict) -> list:
-    should_run, site_area = _should_run(site)
-    management_nodes = filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+    management_nodes = [
+        node for node in filter_list_term_type(site.get("management", []), TermTermType.LANDCOVER)
+        if not _should_group_landCover(node)
+    ]
+    should_run, site_area = _should_run(site=site, management_nodes=management_nodes)
     return _run_make_management_nodes(
         existing_nodes=management_nodes,
         percentage_transformed_from=site_area,

hestia_earth/models/hestia/resourceUse_utils.py

@@ -8,7 +8,7 @@ from dateutil.relativedelta import relativedelta
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.tools import to_precision
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.blank_node import _gapfill_datestr, DatestrGapfillMode, DatestrFormat, _str_dates_match
 from hestia_earth.models.utils.impact_assessment import get_site
 from hestia_earth.models.utils.indicator import _new_indicator
@@ -78,11 +78,15 @@ def should_run(
         node for node in impact_assessment.get("emissionsResourceUse", [])
         if node.get("term", {}).get("@id", "") == _RESOURCE_USE_TERM_ID and node.get("value", -1) >= 0
     ]
-
     filtered_management_nodes = [
         node for node in site.get("management", [])
         if node.get("value", -1) >= 0 and node.get("term", {}).get("termType", "") == TermTermType.LANDCOVER.value
     ]
+    land_occupation_during_cycle_found = any(
+        node.get("term", {}).get("@id") in
+        {node.get("landCover", {}).get("@id") for node in relevant_emission_resource_use}
+        for node in filtered_management_nodes
+    )
     current_node_index = next(
         (i for i, node in enumerate(filtered_management_nodes)
          if _str_dates_match(node.get("endDate", ""), impact_assessment.get("endDate", ""))),
@@ -96,19 +100,18 @@ def should_run(
         historic_date_offset=historic_date_offset
     )
 
-    logRequirements(
-        log_node=impact_assessment,
-        model=MODEL,
-        term_id=term_id,
-        site=site
-    )
+    logRequirements(impact_assessment, model=MODEL, term=term_id,
+                    closest_date=closest_date_str,
+                    land_occupation_during_cycle_found=land_occupation_during_cycle_found,
+                    land_cover_term_id=(current_node or {}).get('term', {}).get('@id'))
 
     should_run_result = all([
-        relevant_emission_resource_use != [],
+        relevant_emission_resource_use,
+        land_occupation_during_cycle_found,
         current_node,
         close_date_found
     ])
-    logShouldRun(site, MODEL, term=term_id, should_run=should_run_result)
+    logShouldRun(impact_assessment, MODEL, term=term_id, should_run=should_run_result)
 
     return should_run_result, current_node, closest_date_str
 
@@ -126,6 +129,7 @@ def _get_land_occupation_for_land_use_type(impact_assessment: dict, ipcc_land_us
 
 def _calculate_indicator_value(
     impact_assessment: dict,
+    term_id: str,
     management_nodes: list,
     ipcc_land_use_category: str,
     previous_land_cover_id: str,
@@ -143,6 +147,13 @@ def _calculate_indicator_value(
         node.get("value", 0) for node in management_nodes
         if node.get("term", {}).get("@id", "") == previous_land_cover_id
     )
+
+    debugValues(impact_assessment, model=MODEL, term=term_id,
+                ipcc_land_use_category=ipcc_land_use_category,
+                land_occupation_for_cycle=land_occupation_for_cycle,
+                historical_land_use=historical_land_use,
+                historic_date_offset=historic_date_offset)
+
     return ((land_occupation_for_cycle * historical_land_use) / 100) / historic_date_offset
 
 
@@ -164,6 +175,7 @@ def _run_calculate_transformation(
             previous_land_cover_id=previous_land_cover_id,
             value=_calculate_indicator_value(
                 impact_assessment=impact_assessment,
+                term_id=term_id,
                 management_nodes=[
                     node for node in site.get("management", [])
                     if _str_dates_match(node.get("endDate", ""), closest_date_str)
@@ -191,10 +203,10 @@ def run_resource_use(
         historic_date_offset=historic_date_offset
     )
     return _run_calculate_transformation(
+        impact_assessment=impact_assessment,
+        site=site,
         term_id=term_id,
         current_node=current_node,
         closest_date_str=closest_date_str,
-        site=site,
-        impact_assessment=impact_assessment,
         historic_date_offset=historic_date_offset
     ) if _should_run else []

hestia_earth/models/hestia/utils.py

@@ -43,6 +43,5 @@ def crop_ipcc_land_use_category(
     return get_lookup_value(
         lookup_term={"@id": crop_term_id, "type": "Term", "termType": lookup_term_type},
         column='IPCC_LAND_USE_CATEGORY',
-        model=MODEL,
-        term={"@id": crop_term_id, "type": "Term", "termType": lookup_term_type}
+        model=MODEL
     )

hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -233,7 +233,7 @@ def _run_practice(animal: dict, values: dict, meanDE: float, meanECHHV: float, R
             'weightAtOneYear',
             'weightAtSlaughter'
         ])
-        has_positive_feed_values = all([NEm_feed > 0, NEg_feed > 0])
+        has_positive_feed_values = all([NEm_feed >= 0, NEg_feed >= 0])
 
         logRequirements(animal, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
                         feed_logs=log_as_table(log_feed),

hestia_earth/models/ipcc2019/pastureGrass.py

@@ -212,7 +212,7 @@ def _run_practice(cycle: dict, meanDE: float, meanECHHV: float, REM: float, REG:
             'weightAtOneYear',
             'weightAtSlaughter'
         ])
-        has_positive_feed_values = all([NEm_feed > 0, NEg_feed > 0])
+        has_positive_feed_values = all([NEm_feed >= 0, NEg_feed >= 0])
 
         logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
                         feed_logs=log_as_table(log_feed),