hestia-earth-models 0.61.8__tar.gz → 0.62.1__tar.gz

{hestia-earth-models-0.61.8/hestia_earth_models.egg-info → hestia-earth-models-0.62.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.61.8
+Version: 0.62.1
 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.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/blonkConsultants2016/utils.py

@@ -25,5 +25,6 @@ def get_emission_factor(term_id: str, cycle: dict, factor: str):
     data = safe_parse_float(value, None)
     # fallback to site.siteType data if possible
     return data if data is not None else safe_parse_float(
-        extract_grouped_data(
-            get_table_value(lookup, 'termid', country_id, column_name('NONE')), site.get('siteType')), None)
+        extract_grouped_data(get_table_value(lookup, 'termid', country_id, column_name('NONE')), site.get('siteType')),
+        None
+    )

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/cycle/completeness/electricityFuel.py

@@ -9,10 +9,12 @@ from hestia_earth.utils.model import filter_list_term_type
 
 from hestia_earth.models.log import logRequirements, log_as_table
 from hestia_earth.models.utils.blank_node import get_lookup_value
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "completeness.operation": "True",
         "completeness.electricityFuel": "False",
         "practices": [
             {"@type": "Practice", "value": "", "term.termType": "operation"}
@@ -42,6 +44,7 @@ def _practice_value(practice: dict):
 
 
 def run(cycle: dict):
+    operation_complete = _is_term_type_complete(cycle, TermTermType.OPERATION)
     practices = filter_list_term_type(cycle.get('practices', []), TermTermType.OPERATION)
     combustion_practices = [
         p for p in practices if _lookup_value(p, LOOKUPS['operation'][1]) in _VALID_COMBUSTION_TYPES
@@ -49,8 +52,9 @@ def run(cycle: dict):
     practices_values = list(map(_practice_value, combustion_practices))
 
     logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
+                    term_type_operation_complete=operation_complete,
                     values=log_as_table(practices_values))
 
-    is_complete = all([p.get('fuel_use') for p in practices_values])
+    is_complete = all([operation_complete] + [p.get('fuel_use') for p in practices_values])
 
     return is_complete

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/cycle/post_checks/__init__.py

@@ -2,14 +2,15 @@ from os.path import dirname, abspath
 import sys
 
 from hestia_earth.models.utils import _run_in_serie
-from . import cache, site
+from . import cache, site, otherSites
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
 
 MODELS = [
     cache.run,
-    site.run
+    site.run,
+    otherSites.run
 ]
 
 

hestia-earth-models-0.62.1/hestia_earth/models/cycle/post_checks/otherSites.py

@@ -0,0 +1,40 @@
+"""
+Post Checks Other Sites
+
+This model is run only if the [pre model](../pre_checks/cycle.md) has been run before.
+This model will restore the `cycle.otherSites` as a list of "linked node"
+(i.e. it will be set with only `@type`, `@id` and `name` keys).
+"""
+from hestia_earth.utils.model import linked_node
+
+REQUIREMENTS = {
+    "Cycle": {
+        "otherSites": [{
+            "@type": "Site",
+            "@id": ""
+        }]
+    }
+}
+RETURNS = {
+    "Cycle": {
+        "otherSites": [{"@type": "Site"}]
+    }
+}
+MODEL_KEY = 'otherSites'
+
+
+def _run_site(site: dict): return linked_node(site)
+
+
+def _should_run_site(site: dict): return site.get('@id') is not None
+
+
+def _should_run(cycle: dict): return len(cycle.get(MODEL_KEY, [])) > 0
+
+
+def run(cycle: dict):
+    return cycle | (
+        ({
+            MODEL_KEY: [_run_site(site) if _should_run_site(site) else site for site in cycle.get(MODEL_KEY, [])]
+        }) if _should_run(cycle) else {}
+    )

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/cycle/pre_checks/__init__.py

@@ -2,12 +2,13 @@ from os.path import dirname, abspath
 import sys
 
 from hestia_earth.models.utils import _run_in_serie
-from . import site, cache_sources
+from . import site, cache_sources, otherSites
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
 
 MODELS = [
+    otherSites.run,
     site.run,
     cache_sources.run
 ]

hestia-earth-models-0.62.1/hestia_earth/models/cycle/pre_checks/otherSites.py

@@ -0,0 +1,42 @@
+"""
+Pre Checks Other Sites
+
+Some Cycle models need a full version of the linked [Site](https://hestia.earth/schema/Site) to run.
+This model will fetch the complete version of the [Cycle Sites](https://hestia.earth/schema/Cycle#otherSites)
+and include them.
+"""
+from hestia_earth.schema import SchemaType
+
+from hestia_earth.models.utils import _load_calculated_node
+
+REQUIREMENTS = {
+    "Cycle": {
+        "otherSites": [{
+            "@type": "Site",
+            "@id": ""
+        }]
+    }
+}
+RETURNS = {
+    "Cycle": {
+        "otherSites": [{"@type": "Site"}]
+    }
+}
+MODEL_KEY = 'otherSites'
+
+
+def _run_site(site: dict): return _load_calculated_node(site, SchemaType.SITE)
+
+
+def _should_run_site(site: dict): return site.get('@id') is not None
+
+
+def _should_run(cycle: dict): return len(cycle.get(MODEL_KEY, [])) > 0
+
+
+def run(cycle: dict):
+    return cycle | (
+        ({
+            MODEL_KEY: [_run_site(site) if _should_run_site(site) else site for site in cycle.get(MODEL_KEY, [])]
+        }) if _should_run(cycle) else {}
+    )

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/cycle/pre_checks/site.py

@@ -2,7 +2,7 @@
 Pre Checks Site
 
 Some Cycle models need a full version of the linked [Site](https://hestia.earth/schema/Site) to run.
-This model will fetch the complete version of the [Site](https://hestia.earth/schema/Site) and include it.
+This model will fetch the complete version of the [Cycle Site](https://hestia.earth/schema/Cycle#site) and include it.
 """
 from hestia_earth.schema import SchemaType
 

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/cycle/product/economicValueShare.py

@@ -2,20 +2,21 @@
 Product Economic Value Share
 
 This model quantifies the relative economic value share of each marketable Product in a Cycle.
-Marketable Products are all Products in the Glossary with the exception of crop residue not sold.
+Marketable Products are all Products identified with the lookup "generateImpactAssessment = TRUE".
 
 It works in the following order:
-1. If revenue data are provided for all marketable products,
+1. For every product with no `value`, the `economicValueShare` is set to `0`.
+2. If revenue data are provided for all marketable products,
 the `economicValueShare` is directly calculated as the share of revenue of each Product;
-2. If the primary product is a crop and it is the only crop Product,
-`economicValueShare` is assigned based on a lookup table containing typical global average economic value shares
-drawn from [Poore & Nemecek (2018)](https://science.sciencemag.org/content/360/6392/987).
+3. Based on a lookup table containing typical global average economic value shares
+drawn from [Poore & Nemecek (2018)](https://science.sciencemag.org/content/360/6392/987), if all products have a
+corresponding value, the `economicValueShare` will be proportionally distributed among the products.
 """
-from hestia_earth.schema import TermTermType
 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.utils.blank_node import get_lookup_value
 from hestia_earth.models.utils.cycle import unique_currencies
 from .utils import lookup_share
 from .. import MODEL
@@ -25,9 +26,11 @@ REQUIREMENTS = {
         "products": [{
             "@type": "Product",
             "value": "",
-            "economicValueShare": "",
-            "revenue": "",
-            "currency": ""
+            "optional": {
+                "economicValueShare": "",
+                "revenue": "",
+                "currency": ""
+            }
         }],
         "optional": {
             "completeness.product": ""
@@ -42,7 +45,8 @@ RETURNS = {
 LOOKUPS = {
     "@doc": "Depending on the primary product [termType](https://hestia.earth/schema/Product#term)",
     "crop": "global_economic_value_share",
-    "excreta": "global_economic_value_share"
+    "excreta": "global_economic_value_share",
+    "animalProduct": "global_economic_value_share"
 }
 MODEL_KEY = 'economicValueShare'
 MAX_VALUE = 100.5
@@ -60,7 +64,7 @@ def _is_complete(cycle: dict): return cycle.get('completeness', {}).get('product
 def _no_yield(product): return list_sum(product.get('value', [-1]), -1) == 0
 
 
-def _total_revenue(products: list): return sum([p.get(MODEL_KEY, 0) for p in products])
+def _total_evs(products: list): return sum([p.get(MODEL_KEY, 0) for p in products])
 
 
 def _product_with_value(product: dict):
@@ -72,18 +76,33 @@ def _rescale_value(products: list, total: float):
     return list(map(lambda p: {**p, MODEL_KEY: p.get(MODEL_KEY) * 100 / total}, products))
 
 
+def _should_run_by_default(cycle: dict, products: list):
+    run_by = 'default'
+    # only run if all products have the lookup data or value will be incorrect
+    products = list(map(_product_with_value, products))
+    all_with_economicValueShare = all([p.get(MODEL_KEY) is not None for p in products])
+
+    should_run = all([all_with_economicValueShare])
+
+    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)
+        logShouldRun(cycle, MODEL, term_id, should_run, key=MODEL_KEY, by=run_by)
+
+    return should_run
+
+
 def _run_by_default(cycle: dict, products: list):
     run_by = 'default'
     is_complete = _is_complete(cycle)
     products = list(map(_product_with_value, products))
-    # remove results where lookup share was not found
-    results = list(filter(lambda p: p.get(MODEL_KEY) is not None, products))
     # only return list if the new total of evs is not above threshold
-    total_revenue = _total_revenue(results)
-    below_max_threshold = total_revenue <= MAX_VALUE
-    should_rescale = is_complete and MIN_COMPLETE_VALUE <= total_revenue <= MAX_VALUE
-    above_min_threshold = True if should_rescale else total_revenue >= MIN_VALUE if is_complete else True
-    results = _rescale_value(results, total_revenue) if should_rescale else results
+    total_economicValueShare = _total_evs(products)
+    below_max_threshold = total_economicValueShare <= MAX_VALUE
+    should_rescale = is_complete and MIN_COMPLETE_VALUE <= total_economicValueShare <= MAX_VALUE
+    above_min_threshold = True if should_rescale else total_economicValueShare >= MIN_VALUE if is_complete else True
+    results = _rescale_value(products, total_economicValueShare) if should_rescale else products
 
     should_run = all([below_max_threshold, above_min_threshold])
 
@@ -93,7 +112,7 @@ def _run_by_default(cycle: dict, products: list):
         logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
                         below_max_threshold=below_max_threshold,
                         above_min_threshold=above_min_threshold,
-                        total_revenue=total_revenue)
+                        total_economicValueShare=total_economicValueShare)
         logShouldRun(cycle, MODEL, term_id, p_should_run, key=MODEL_KEY, by=run_by)
 
     return results if should_run else []
@@ -109,8 +128,8 @@ def _run_by_revenue(products: list):
 def _should_run_by_revenue(cycle: dict, products: list):
     run_by = 'revenue'
     is_complete = _is_complete(cycle)
-    total_value = _total_revenue(products)
-    below_threshold = total_value < MAX_VALUE
+    total_economicValueShare = _total_evs(products)
+    below_threshold = total_economicValueShare < MAX_VALUE
     # ignore products with no yield
     products = list(filter(lambda p: not _no_yield(p), products))
     currencies = unique_currencies(cycle)
@@ -122,7 +141,7 @@ def _should_run_by_revenue(cycle: dict, products: list):
         term_id = p.get('term', {}).get('@id')
         logRequirements(cycle, model=MODEL, term=term_id, key=MODEL_KEY, by=run_by,
                         is_complete=is_complete,
-                        total_value=total_value,
+                        total_economicValueShare=total_economicValueShare,
                         below_threshold=below_threshold,
                         all_with_revenue=all_with_revenue,
                         currencies=';'.join(currencies),
@@ -133,14 +152,14 @@ def _should_run_by_revenue(cycle: dict, products: list):
 
 
 def _run_single_missing_evs(products: list):
-    total_value = _total_revenue(products)
+    total_value = _total_evs(products)
     return list(map(lambda p: _product(p, 100 - total_value) if p.get(MODEL_KEY) is None else p, products))
 
 
 def _should_run_single_missing_evs(cycle: dict, products: list):
     run_by = '1-missing-evs'
     is_complete = _is_complete(cycle)
-    total_value = _total_revenue(products)
+    total_value = _total_evs(products)
     # ignore products with no yield
     products = list(filter(lambda p: not _no_yield(p), products))
     missing_values = [p for p in products if p.get(MODEL_KEY) is None]
@@ -175,20 +194,17 @@ def _should_run_no_value(cycle: dict, product: dict):
 
 
 def _should_have_evs(product: dict):
-    term_type = product.get('term', {}).get('termType')
-    return term_type not in [
-        TermTermType.CROPRESIDUE.value,
-        TermTermType.EXCRETA.value
-    ]
+    should_generate_ia = get_lookup_value(product.get('term', {}), 'generateImpactAssessment')
+    return str(should_generate_ia).lower() != 'false'
 
 
 def run(cycle: dict):
     products = cycle.get('products', [])
-    # skip any product that will never has value
+    # skip any product that is not marketable
     products = list(filter(_should_have_evs, products))
     products = list(map(lambda p: _product(p, 0) if _should_run_no_value(cycle, p) else p, products))
     return (
         _run_single_missing_evs(products) if _should_run_single_missing_evs(cycle, products) else
         _run_by_revenue(products) if _should_run_by_revenue(cycle, products) else
-        _run_by_default(cycle, products)
+        _run_by_default(cycle, products) if _should_run_by_default(cycle, products) else []
     )

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/ecoinventV3AndEmberClimate/utils.py

@@ -33,7 +33,7 @@ def _extract_emission_value(value_iter: Any) -> Union[float, None]:
     value_list = list(value_iter)
     try:
         if len(list(value_list)) > 0 and len(list(value_list)[0]) > 1:
-            return safe_parse_float(list(value_list)[0][1])
+            return safe_parse_float(list(value_list)[0][1], None)
     except ValueError:
         return None
 

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/emepEea2019/utils.py

@@ -1,7 +1,7 @@
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.lookup import extract_grouped_data
-from hestia_earth.utils.tools import list_sum, safe_parse_float
+from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
 
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.term import get_lookup_value
@@ -19,14 +19,15 @@ def _get_fuel_input_value(term_id: str, lookup_col: str):
             get_lookup_value(operation_term, lookup_col, model=MODEL, term=term_id), input_term_id
         ) if operation_term else None
         input_factor = operation_factor or get_lookup_value(input_term, lookup_col, model=MODEL, term=term_id)
+        factor = safe_parse_float(input_factor, None)
 
-        return input_value * safe_parse_float(input_factor)
+        return input_value * factor if factor is not None else None
     return get_value
 
 
 def get_fuel_values(term_id: str, cycle: dict, lookup_col: str):
     inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
-    values = list(map(_get_fuel_input_value(term_id, lookup_col), inputs))
+    values = non_empty_list(map(_get_fuel_input_value(term_id, lookup_col), inputs))
 
     return [0] if all([
         len(values) == 0,

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/geospatialDatabase/heavyWinterPrecipitation.py

@@ -39,7 +39,7 @@ def _measurement(site: dict, value: float):
 
 def _download(site: dict):
     value = download(TERM_ID, site, EE_PARAMS)
-    return 1 if value == 1 else (0 if value == 0.1 else None)
+    return value == 1
 
 
 def _run(site: dict):

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/ipcc2019/animal/pastureGrass.py

@@ -1,9 +1,12 @@
 """
-Full Grass Consumption
+Animal Pasture Grass
 
 This model estimates the energetic requirements of ruminants and can be used to estimate the amount of grass they graze.
 Source:
 [IPCC 2019, Vol.4, Chapter 10](https://www.ipcc-nggip.iges.or.jp/public/2019rf/pdf/4_Volume4/19R_V4_Ch10_Livestock.pdf).
+
+This version of the model will run at the Animal Blank Node level, if none of the Cycle Input are given as feed
+(see https://www.hestia.earth/schema/Input#isAnimalFeed).
 """
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import filter_list_term_type
@@ -138,7 +141,7 @@ RETURNS = {
         }]
     }]
 }
-MODEL_KEY = 'animal/pastureGrass'
+MODEL_KEY = 'pastureGrass'
 
 
 def _input(term_id: str, value: float):
@@ -173,7 +176,7 @@ def calculate_NEwool(cycle: dict, animal: dict, products: list, total_weight: fl
     ])
     animal_weight = _sum_liveWeightPerHead([animal])
 
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
                 total_energy=total_energy,
                 animal_liveWeightPerHead=animal_weight,
                 total_liveWeightPerHead=total_weight)
@@ -186,29 +189,35 @@ def _calculate_GE(
 ) -> float:
     term_id = animal.get('term', {}).get('@id')
 
-    NEm, NEa, NEl, NEwork, NEp, NEg = get_animal_values(cycle, animal, system)
+    NEm, NEa, NEl, NEwork, NEp, NEg = get_animal_values(cycle, animal, system, log_node=animal)
 
     NEm_feed, NEg_feed = calculate_NEfeed(animal)
-    debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+    debugValues(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                NEm=NEm,
+                NEa=NEa,
+                NEl=NEl,
+                NEwork=NEwork,
+                NEp=NEp,
+                NEg=NEg,
                 NEm_feed=NEm_feed,
                 NEg_feed=NEg_feed)
 
     return (NEm + NEa + NEl + NEwork + NEp - NEm_feed)/REM + (NEg + NEwool - NEg_feed)/REG
 
 
-def _run_practice(cycle: dict, GE: float, meanECHHV: float):
+def _run_practice(animal: dict, GE: float, meanECHHV: float):
     def run(practice: dict):
         key = practice.get('key', {})
         key_id = key.get('@id')
         input_term_id = practice_input_id(practice)
         value = (GE / meanECHHV) * (list_sum(practice.get('value', [0])) / 100)
 
-        logRequirements(cycle, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
+        logRequirements(animal, model=MODEL, term=input_term_id, model_key=MODEL_KEY,
                         GE=GE,
                         meanECHHV=meanECHHV,
-                        key_id=key_id)
+                        practice_key_id=key_id)
 
-        logShouldRun(cycle, MODEL, input_term_id, True, model_key=MODEL_KEY)
+        logShouldRun(animal, MODEL, input_term_id, True, model_key=MODEL_KEY)
 
         return _input(input_term_id, value)
 
@@ -233,14 +242,14 @@ def _run_animal(cycle: dict, meanDE: float, meanECHHV: float, system: dict, prac
         ) else 0
         GE = (_calculate_GE(cycle, animal, REM, REG, NEwool, system) / (meanDE/100)) if all([REM, REG]) else 0
 
-        debugValues(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
+        debugValues(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
                     REM=REM,
                     REG=REG,
                     NEwool=NEwool,
                     GE=GE,
                     meanDE=meanDE)
 
-        inputs = list(map(_run_practice(cycle, GE, meanECHHV), practices))
+        inputs = list(map(_run_practice(animal, GE, meanECHHV), practices))
         return animal | {
             'inputs': animal.get('inputs', []) + inputs
         }
@@ -248,17 +257,12 @@ def _run_animal(cycle: dict, meanDE: float, meanECHHV: float, system: dict, prac
     return run
 
 
-def _run(cycle: dict, meanDE: float, meanECHHV: float, system: dict, practices: list):
-    animals = get_animals(cycle)
-    return list(map(_run_animal(cycle, meanDE, meanECHHV, system, practices), animals))
-
-
-def _should_run(cycle: dict, practices: dict):
+def _should_run(cycle: dict, animals: list, practices: dict):
     systems = filter_list_term_type(cycle.get('practices', []), TermTermType.SYSTEM)
     animalFeed_complete = _is_term_type_complete(cycle, 'animalFeed')
     animalPopulation_complete = _is_term_type_complete(cycle, 'animalPopulation')
     freshForage_incomplete = _is_term_type_incomplete(cycle, 'freshForage')
-    all_animals_have_value = all([a.get('value', 0) > 0 for a in cycle.get('animals', [])])
+    all_animals_have_value = all([a.get('value', 0) > 0 for a in animals])
 
     no_cycle_inputs_feed = all([not input.get('isAnimalFeed', False) for input in cycle.get('inputs', [])])
 
@@ -278,21 +282,23 @@ def _should_run(cycle: dict, practices: dict):
     ])
 
     for term_id in [MODEL_KEY] + [practice_input_id(p) for p in practices]:
-        logRequirements(cycle, model=MODEL, term=term_id, model_key=MODEL_KEY,
-                        term_type_animalFeed_complete=animalFeed_complete,
-                        term_type_animalPopulation_complete=animalPopulation_complete,
-                        term_type_freshForage_incomplete=freshForage_incomplete,
-                        no_cycle_inputs_feed=no_cycle_inputs_feed,
-                        all_animals_have_value=all_animals_have_value,
-                        meanDE=meanDE,
-                        meanECHHV=meanECHHV)
-
-        logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
+        for animal in animals:
+            logRequirements(animal, model=MODEL, term=term_id, model_key=MODEL_KEY,
+                            term_type_animalFeed_complete=animalFeed_complete,
+                            term_type_animalPopulation_complete=animalPopulation_complete,
+                            term_type_freshForage_incomplete=freshForage_incomplete,
+                            no_cycle_inputs_feed=no_cycle_inputs_feed,
+                            all_animals_have_value=all_animals_have_value,
+                            meanDE=meanDE,
+                            meanECHHV=meanECHHV)
+
+            logShouldRun(animal, MODEL, term_id, should_run, model_key=MODEL_KEY)
 
     return should_run, meanDE, meanECHHV, systems[0] if systems else None
 
 
 def run(cycle: dict):
+    animals = get_animals(cycle)
     practices = list(filter(should_run_practice(cycle), cycle.get('practices', [])))
-    should_run, meanDE, meanECHHV, system = _should_run(cycle, practices)
-    return _run(cycle, meanDE, meanECHHV, system, practices) if should_run else []
+    should_run, meanDE, meanECHHV, system = _should_run(cycle, animals, practices)
+    return list(map(_run_animal(cycle, meanDE, meanECHHV, system, practices), animals)) if should_run else []

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/ipcc2019/co2ToAirSoilOrganicCarbonStockChangeManagementChange.py

@@ -7,7 +7,7 @@ from pydash.objects import merge
 from typing import NamedTuple, Optional, Union
 
 from hestia_earth.schema import (
-    CycleFunctionalUnit, EmissionMethodTier, MeasurementMethodClassification
+    CycleFunctionalUnit, EmissionMethodTier, MeasurementMethodClassification, SiteSiteType
 )
 from hestia_earth.utils.date import diff_in_days
 from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_date
@@ -15,7 +15,8 @@ from hestia_earth.utils.tools import flatten, non_empty_list, safe_parse_date
 from hestia_earth.models.log import log_as_table, logRequirements, logShouldRun
 from hestia_earth.models.utils import pairwise
 from hestia_earth.models.utils.blank_node import (
-    _get_datestr_format, _gapfill_datestr, DatestrGapfillMode, DatestrFormat, group_nodes_by_year, node_term_match
+    _get_datestr_format, _gapfill_datestr, DatestrGapfillMode, DatestrFormat, group_nodes_by_year, node_term_match,
+    cumulative_nodes_term_match
 )
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
 from hestia_earth.models.utils.emission import _new_emission, min_emission_method_tier
@@ -82,6 +83,13 @@ The list of `MeasurementMethodClassification`s that can be used to calculate SOC
 order from strongest to weakest.
 """
 
+_SITE_TYPE_SYSTEMS_MAPPING = {
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value: [
+        "protectedCroppingSystemSoilBased",
+        "protectedCroppingSystemSoilAndSubstrateBased"
+    ]
+}
+
 
 class _InventoryKey(Enum):
     """
@@ -207,19 +215,37 @@ def _should_run(cycle: dict) -> tuple[bool, str, dict]:
     soc_measurements = [node for node in site.get("measurements", []) if _validate_soc_measurement(node)]
     cycles = related_cycles(site)
 
+    site_type = site.get("siteType")
+    has_soil = site_type not in _SITE_TYPE_SYSTEMS_MAPPING or all(
+        cumulative_nodes_term_match(
+            cycle.get("practices", []),
+            target_term_ids=_SITE_TYPE_SYSTEMS_MAPPING[site_type],
+            cumulative_threshold=0
+        ) for cycle in cycles
+    )
+
     has_soc_measurements = len(soc_measurements) > 0
     has_cycles = len(cycles) > 0
     has_functional_unit_1_ha = all(cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value for cycle in cycles)
 
-    should_compile_inventory = all([has_cycles, has_functional_unit_1_ha, has_soc_measurements])
+    should_compile_inventory = all([
+        has_soil,
+        has_cycles,
+        has_functional_unit_1_ha,
+        has_soc_measurements,
+    ])
 
-    inventory, logs = _compile_inventory(cycle_id, cycles, soc_measurements) if should_compile_inventory else ({}, {})
+    inventory, logs = (
+        _compile_inventory(cycle_id, cycles, soc_measurements) if should_compile_inventory else ({}, {})
+    )
 
     has_valid_inventory = len(inventory) > 0
     has_consecutive_years = check_consecutive(inventory.keys())
 
     logRequirements(
         cycle, model=MODEL, term=TERM_ID,
+        site_type=site_type,
+        has_soil=has_soil,
         has_soc_measurements=has_soc_measurements,
         has_cycles=has_cycles,
         has_functional_unit_1_ha=has_functional_unit_1_ha,

{hestia-earth-models-0.61.8 → hestia-earth-models-0.62.1}/hestia_earth/models/ipcc2019/n2OToAirExcretaDirect.py

@@ -1,7 +1,8 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, TermTermType
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.constant import Units, get_atomic_conversion
+from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.input import total_excreta
 from hestia_earth.models.utils.excretaManagement import get_lookup_factor
@@ -9,6 +10,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "completeness.excreta": "True",
         "practices": [
             {"@type": "Practice", "value": "", "term.termType": "excretaManagement"}
         ]
@@ -42,10 +44,12 @@ def _run(excretaKgN: float, N2O_N_EF: float):
 def _should_run(cycle: dict):
     excretaKgN = total_excreta(cycle.get('inputs', []))
     N2O_N_EF = get_lookup_factor(cycle.get('practices', []), LOOKUPS['excretaManagement'])
+    term_type_complete = _is_term_type_complete(cycle, TermTermType.EXCRETA)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     excretaKgN=excretaKgN,
-                    N2O_N_EF=N2O_N_EF)
+                    N2O_N_EF=N2O_N_EF,
+                    term_type_excreta_complete=term_type_complete)
 
     should_run = all([excretaKgN, N2O_N_EF])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)