hestia-earth-models 0.57.2__tar.gz → 0.59.0__tar.gz

{hestia-earth-models-0.57.2/hestia_earth_models.egg-info → hestia-earth-models-0.59.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.57.2
+Version: 0.59.0
 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
@@ -48,19 +48,15 @@ run('no3ToGroundwaterSoilFlux', cycle_data)
 
 ### Using Spatial Models
 
-We have models that can gap-fill geographical information on a `Site`.
-If you want to use thse models:
+We have models that can gap-fill geographical information on a `Site`. If you want to use these models:
 1. Install the library: `pip install hestia_earth.earth_engine`
 2. Follow the [Getting Started instructions](https://gitlab.com/hestia-earth/hestia-earth-engine#getting-started).
 
-### Using Ecoinvent Model
+### Using the ecoinventV3 model
 
 ecoinvent is a consistent, transparent, and well validated life cycle inventory database.
 We use ecoinvent data to ascertain the environmental impacts of activities that occur outside of our system boundary, for example data on the environmental impacts of extracting oil and producing diesel, or the impacts of manufacturing plastics.
-To include these data in your environmental impact assessments using Hestia, you must own a suitable [ecoinvent license](https://ecoinvent.org/offerings/licences/).
 
-Please contact us at community@hestia.earth for instructions to download the required file to run the model.
-Once downloaded, copy the file in the _hestia_earth/models/data/ecoinventV3_ folder.
-Thank you!
+The `ecoinventV3` model requires a valid [license](https://ecoinvent.org/offerings/licences/) to run. We are currently working on a way to enable users of this code with a valid ecoinvent licence to run these models themselves, but for now, these models are only available on the public platform.
 
 

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/README.md

@@ -33,17 +33,13 @@ run('no3ToGroundwaterSoilFlux', cycle_data)
 
 ### Using Spatial Models
 
-We have models that can gap-fill geographical information on a `Site`.
-If you want to use thse models:
+We have models that can gap-fill geographical information on a `Site`. If you want to use these models:
 1. Install the library: `pip install hestia_earth.earth_engine`
 2. Follow the [Getting Started instructions](https://gitlab.com/hestia-earth/hestia-earth-engine#getting-started).
 
-### Using Ecoinvent Model
+### Using the ecoinventV3 model
 
 ecoinvent is a consistent, transparent, and well validated life cycle inventory database.
 We use ecoinvent data to ascertain the environmental impacts of activities that occur outside of our system boundary, for example data on the environmental impacts of extracting oil and producing diesel, or the impacts of manufacturing plastics.
-To include these data in your environmental impact assessments using Hestia, you must own a suitable [ecoinvent license](https://ecoinvent.org/offerings/licences/).
 
-Please contact us at community@hestia.earth for instructions to download the required file to run the model.
-Once downloaded, copy the file in the _hestia_earth/models/data/ecoinventV3_ folder.
-Thank you!
+The `ecoinventV3` model requires a valid [license](https://ecoinvent.org/offerings/licences/) to run. We are currently working on a way to enable users of this code with a valid ecoinvent licence to run these models themselves, but for now, these models are only available on the public platform.

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/cycle/aboveGroundCropResidueTotal.py

@@ -5,10 +5,11 @@ and crop residue products are provided. Examples:
 - if `residueLeftOnField` = `100%` and `aboveGroundCropResidueLeftOnField` = `1000kg`, the total is `1000kg`.
 """
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.model import filter_list_term_type, find_term_match
 from hestia_earth.utils.tools import list_sum, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.cropResidue import PRODUCT_ID_TO_PRACTICES_ID
 from hestia_earth.models.utils.product import _new_product
 from . import MODEL
 
@@ -34,24 +35,28 @@ def _product(value: float):
 def _run(practice: dict, product: dict):
     practice_value = list_sum(practice.get('value', []))
     product_value = list_sum(product.get('value', []))
-    value = 0 if any([practice_value == 0 or product_value == 0]) else product_value / (practice_value / 100)
-    return [_product(value)]
+    value = product_value / (practice_value / 100)
+    return [_product(round(value, 2))]
+
+
+def _matching_product_by_practice(term_id: str):
+    return next((v.get('product') for v in PRODUCT_ID_TO_PRACTICES_ID if term_id in v.get('practices')), None)
 
 
 def _should_run(cycle: dict):
-    # run if any practice equals 100% with a product value
+    # run if any practice with a value matches a product with a value
     practices = filter_list_term_type(cycle.get('practices', []), TermTermType.CROPRESIDUEMANAGEMENT)
     products = filter_list_term_type(cycle.get('products', []), TermTermType.CROPRESIDUE)
 
     def _matching_product(practice: dict):
-        term_id = practice.get('term', {}).get('@id')
-        product = next((
-            p for p in products if all([
-                p.get('value', []),
-                p.get('term', {}).get('@id').lower().endswith(term_id.lower())
-            ])
-        ), None)
-        return (practice, product) if product else None
+        practice_term_id = practice.get('term', {}).get('@id')
+        product_term_id = _matching_product_by_practice(practice_term_id)
+        product = find_term_match(products, product_term_id)
+
+        practice_value = list_sum(practice.get('value', []))
+        product_value = list_sum(product.get('value', []))
+
+        return (practice, product) if all([practice_value, product_value]) else None
 
     matching_practices = non_empty_list(map(_matching_product, practices))
     practice, matching_product = (matching_practices or [(None, None)])[0]

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/cycle/excretaKgMass.py

@@ -33,7 +33,6 @@ RETURNS = {
     }]
 }
 MODEL_KEY = 'excretaKgMass'
-MODEL_LOG = '/'.join([MODEL, MODEL_KEY])
 
 UNITS = [
     Units.KG_N.value,
@@ -53,7 +52,7 @@ def _convert_by_product(cycle: dict, product: dict, term_id: str):
         if existing_product else None
     value = list_sum(existing_product.get('value', [])) / conversion_to_kg_ratio if conversion_to_kg_ratio else None
 
-    debugValues(cycle, model=MODEL_LOG, term=term_id,
+    debugValues(cycle, model=MODEL, term=term_id,
                 using_excreta_product=existing_product.get('term', {}).get('@id'),
                 conversion_to_kg_ratio=conversion_to_kg_ratio,
                 value=value)
@@ -98,7 +97,7 @@ def _should_run(cycle: dict):
     ]
     has_gap_fill_term_ids = len(gap_fill_term_ids) > 0
 
-    logRequirements(cycle, model=MODEL_LOG,
+    logRequirements(cycle, model=MODEL, model_key=MODEL_KEY,
                     node_type=node_type,
                     has_gap_fill_term_ids=has_gap_fill_term_ids,
                     gap_fill_term_ids=';'.join(gap_fill_term_ids))
@@ -106,9 +105,9 @@ def _should_run(cycle: dict):
     should_run = all([node_type == NodeType.CYCLE.value, has_gap_fill_term_ids])
 
     for term_id in gap_fill_term_ids:
-        logShouldRun(cycle, MODEL_LOG, term_id, should_run)
+        logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
 
-    logShouldRun(cycle, MODEL_LOG, None, should_run)
+    logShouldRun(cycle, MODEL, None, should_run)
     return should_run, gap_fill_term_ids
 
 

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/cycle/excretaKgN.py

@@ -32,7 +32,6 @@ RETURNS = {
     }]
 }
 MODEL_KEY = 'excretaKgN'
-MODEL_LOG = '/'.join([MODEL, MODEL_KEY])
 
 
 def _product(value: float, term_id: str):
@@ -44,7 +43,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_LOG, term=term_id,
+    debugValues(cycle, model=MODEL, term=term_id,
                 using_excreta_product=existing_kg_product.get('term', {}).get('@id'),
                 value=value)
 
@@ -66,7 +65,7 @@ def _should_run(cycle: dict):
     ]
     has_gap_fill_term_ids = len(gap_fill_term_ids) > 0
 
-    logRequirements(cycle, model=MODEL_LOG,
+    logRequirements(cycle, model=MODEL, model_key=MODEL_KEY,
                     node_type=node_type,
                     has_gap_fill_term_ids=has_gap_fill_term_ids,
                     gap_fill_term_ids=';'.join(gap_fill_term_ids))
@@ -74,9 +73,9 @@ def _should_run(cycle: dict):
     should_run = all([node_type == NodeType.CYCLE.value, has_gap_fill_term_ids])
 
     for term_id in gap_fill_term_ids:
-        logShouldRun(cycle, MODEL_LOG, term_id, should_run)
+        logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
 
-    logShouldRun(cycle, MODEL_LOG, None, should_run)
+    logShouldRun(cycle, MODEL, None, should_run)
     return should_run, gap_fill_term_ids
 
 

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/cycle/excretaKgVs.py

@@ -32,7 +32,6 @@ RETURNS = {
     }]
 }
 MODEL_KEY = 'excretaKgVs'
-MODEL_LOG = '/'.join([MODEL, MODEL_KEY])
 
 
 def _product(value: float, term_id: str):
@@ -44,7 +43,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_LOG, term=term_id,
+    debugValues(cycle, model=MODEL, term=term_id,
                 using_excreta_product=existing_kg_product.get('term', {}).get('@id'),
                 value=value)
 
@@ -66,7 +65,7 @@ def _should_run(cycle: dict):
     ]
     has_gap_fill_term_ids = len(gap_fill_term_ids) > 0
 
-    logRequirements(cycle, model=MODEL_LOG,
+    logRequirements(cycle, model=MODEL, model_key=MODEL_KEY,
                     node_type=node_type,
                     has_gap_fill_term_ids=has_gap_fill_term_ids,
                     gap_fill_term_ids=';'.join(gap_fill_term_ids))
@@ -74,9 +73,9 @@ def _should_run(cycle: dict):
     should_run = all([node_type == NodeType.CYCLE.value, gap_fill_term_ids])
 
     for term_id in gap_fill_term_ids:
-        logShouldRun(cycle, MODEL_LOG, term_id, should_run)
+        logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
 
-    logShouldRun(cycle, MODEL_LOG, None, should_run)
+    logShouldRun(cycle, MODEL, None, should_run)
     return should_run, gap_fill_term_ids
 
 

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/cycle/inorganicFertiliser.py

@@ -138,12 +138,12 @@ def _should_run_input(cycle: dict, input: dict):
     ])
 
     for term_id in include_term_ids:
-        logRequirements(cycle, model=MODEL_LOG, term=term_id,
+        logRequirements(cycle, model=MODEL_LOG, term=term_id, model_key=MODEL_KEY,
                         nitrogenContent=nitrogenContent,
                         phosphateContentAsP2O5=phosphateContentAsP2O5,
                         potassiumContentAsK2O=potassiumContentAsK2O)
 
-        logShouldRun(cycle, MODEL_LOG, term_id, should_run)
+        logShouldRun(cycle, MODEL_LOG, term_id, should_run, model_key=MODEL_KEY)
     return should_run
 
 

hestia-earth-models-0.57.2/hestia_earth/models/cycle/irrigated.py → hestia-earth-models-0.59.0/hestia_earth/models/cycle/irrigatedTypeUnspecified.py

@@ -24,7 +24,7 @@ RETURNS = {
         "value": ""
     }]
 }
-TERM_ID = 'irrigated'
+TERM_ID = 'irrigatedTypeUnspecified'
 MIN_IRRIGATION_M3 = 250
 
 
@@ -34,6 +34,9 @@ def _practice(value: float):
     return practice
 
 
+def _is_irrigation_practice(practice: dict): return practice.get('term', {}).get('units', '') in ['%', '% area']
+
+
 def _run(irrigation_m3: float):
     value = 100 if irrigation_m3 > MIN_IRRIGATION_M3 else 0
     return [_practice(value)]
@@ -61,9 +64,6 @@ def _should_run(cycle: dict):
     return should_run, irrigation_value_m3
 
 
-def _is_irrigation_practice(practice: dict): return practice.get('term', {}).get('units', '') in ['%', '% area']
-
-
 def run(cycle: dict):
     should_run, irrigation_m3 = _should_run(cycle)
     return _run(irrigation_m3) if should_run else []

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/cycle/liveAnimal.py

@@ -9,8 +9,8 @@ from hestia_earth.utils.tools import list_sum, safe_parse_float
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.product import _new_product
-from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.site import valid_site_type
+from .utils import _get_liveAnimal_term_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -57,25 +57,21 @@ def _run(term_id: str, product_value: dict, propertyPerHead: float):
     return [_product(term_id, value)] if value else []
 
 
-def _get_liveAnimal_term_id(product: dict):
-    return get_lookup_value(product.get('term', {}), MODEL_KEY, model=MODEL, model_key=MODEL_KEY)
-
-
 def _should_run(cycle: dict):
     site_type_valid = valid_site_type(cycle.get('site'), site_types=VALID_SITE_TYPES)
     product = find_primary_product(cycle) or {}
     product_value = list_sum(product.get('value', []))
     is_animalProduct = product.get('term', {}).get('termType') == TermTermType.ANIMALPRODUCT.value
     units = f"{product.get('term', {}).get('units')} / head"
-    property = next(
+    propertyPerHead = next(
         (p for p in product.get('properties', []) if p.get('term', {}).get('units') == units), {}
     ) or next(
         (p for p in product.get('properties', []) if p.get('term', {}).get('@id').endswith('PerHead')), {}
     )
-    propertyPerHead = safe_parse_float(property.get('value'), 0)
+    propertyPerHead_value = safe_parse_float(propertyPerHead.get('value'), None)
 
     # make sure the `liveAnimal` Term is not already present as a Product or Input
-    term_id = _get_liveAnimal_term_id(product)
+    term_id = _get_liveAnimal_term_id(product, model_key=MODEL_KEY)
     has_liveAnimal_product = find_term_match(cycle.get('products', []), term_id, None) is not None
     has_liveAnimal_input = find_term_match(cycle.get('products', []), term_id, None) is not None
 
@@ -85,7 +81,8 @@ def _should_run(cycle: dict):
         is_animalProduct,
         not has_liveAnimal_product,
         not has_liveAnimal_input,
-        product_value, propertyPerHead
+        product_value,
+        propertyPerHead_value
     ])
 
     # if the Term is added as Input, do not shows logs for it
@@ -95,10 +92,11 @@ def _should_run(cycle: dict):
                         is_animalProduct=is_animalProduct,
                         has_liveAnimal_product=has_liveAnimal_product,
                         product_value=product_value,
-                        propertyPerHead=propertyPerHead)
+                        propertyPerHead_term_id=propertyPerHead.get('term', {}).get('@id'),
+                        propertyPerHead_value=propertyPerHead_value)
 
         logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
-    return should_run, term_id, product_value, propertyPerHead
+    return should_run, term_id, product_value, propertyPerHead_value
 
 
 def run(cycle: dict):

hestia-earth-models-0.59.0/hestia_earth/models/cycle/milkYield.py

@@ -0,0 +1,154 @@
+"""
+Milk Yield
+
+This model gap-fills the practice "Milk yield per animal X (raw/FPCM)" (e.g. `Milk yield per cow (raw)`) when:
+
+1. The corresponding milk term in the animalProduct glossary (e.g. Milk, cow, raw) is added as a Product of the Cycle;
+2. The number of lactating animals is known.
+
+It also adds the properties of the Product to the gap-filled Practice.
+"""
+from hestia_earth.schema import TermTermType, SiteSiteType, PracticeStatsDefinition
+from hestia_earth.utils.model import filter_list_term_type, find_term_match
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_blank_nodes_id
+from hestia_earth.models.utils.practice import _new_practice
+from hestia_earth.models.utils.site import valid_site_type
+from hestia_earth.models.utils.term import get_lookup_value
+from .utils import _get_liveAnimal_term_id
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "cycleDuration": "",
+        "site": {
+            "@type": "Site",
+            "siteType": ["cropland", "permanent pasture", "animal housing"]
+        },
+        "products": [{
+            "@type": "Product",
+            "value": "> 0",
+            "termType": "animalProduct"
+        }],
+        "animals": [{
+            "@type": "Animal",
+            "value": "> 0",
+            "termType": "liveAnimal"
+        }]
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "value": "",
+        "min": "",
+        "max": "",
+        "sd": "",
+        "statsDefinition": "modelled"
+    }]
+}
+LOOKUPS = {
+    "animalProduct": ["liveAnimal", "milkYieldPracticeId"]
+}
+
+MODEL_KEY = 'milkYield'
+VALID_SITE_TYPES = [
+    SiteSiteType.CROPLAND.value, SiteSiteType.ANIMAL_HOUSING.value, SiteSiteType.PERMANENT_PASTURE.value
+]
+
+
+def practice(term_id: str, value: float, properties: list, sd: float = None, min: float = None, max: float = None):
+    data = _new_practice(term_id)
+    data['value'] = [round(value, 2)]
+    if properties:
+        data['properties'] = properties
+    if sd is not None:
+        data['sd'] = [round(sd, 2)]
+        data['statsDefinition'] = PracticeStatsDefinition.MODELLED.value
+    if min is not None:
+        data['min'] = [round(min, 2)]
+        data['statsDefinition'] = PracticeStatsDefinition.MODELLED.value
+    if max is not None:
+        data['max'] = [round(max, 2)]
+        data['statsDefinition'] = PracticeStatsDefinition.MODELLED.value
+    return data
+
+
+def _run(cycle: dict, product: dict):
+    cycleDuration = cycle.get('cycleDuration')
+
+    term = product.get('term', {})
+    practice_id = get_lookup_value(term, 'milkYieldPracticeId')
+
+    live_animal_term_id = _get_liveAnimal_term_id(product, model_key=MODEL_KEY)
+    live_animal_node = find_term_match(cycle.get('animals', []), live_animal_term_id)
+
+    value = list_sum(product.get('value')) / cycleDuration / live_animal_node.get('value')
+    sd = list_sum(product.get('sd')) / cycleDuration / live_animal_node.get('value') if all([
+        list_sum(product.get('sd', [])) > 0
+    ]) else None
+    min = list_sum(product.get('min')) / cycleDuration / live_animal_node.get('value') if all([
+        list_sum(product.get('min', [])) > 0
+    ]) else None
+    max = list_sum(product.get('max')) / cycleDuration / live_animal_node.get('value') if all([
+        list_sum(product.get('max', [])) > 0
+    ]) else None
+
+    return live_animal_node | {
+        'practices': live_animal_node.get('practices', []) + [
+            practice(practice_id, value, product.get('properties', []), sd=sd, min=min, max=max)
+        ]
+    }
+
+
+def _should_run_product(cycle: dict, product: dict):
+    cycleDuration = cycle.get('cycleDuration')
+    site_type_valid = valid_site_type(cycle.get('site'), site_types=VALID_SITE_TYPES)
+
+    term = product.get('term', {})
+    term_id = term.get('@id')
+
+    has_product_value = list_sum(product.get('value', [])) > 0
+
+    live_animal_term_id = _get_liveAnimal_term_id(product, model_key=MODEL_KEY)
+    live_animal_node = find_term_match(cycle.get('animals', []), live_animal_term_id)
+    has_live_animal_node_value = live_animal_node.get('value', 0) > 0
+
+    practice_id = get_lookup_value(term, 'milkYieldPracticeId', model=MODEL, model_key=MODEL_KEY)
+    has_practice_id = any([
+        find_term_match(cycle.get('practices', []), practice_id),
+        find_term_match((live_animal_node or {}).get('practices', []), practice_id)
+    ])
+    missing_milkYield_practice = not has_practice_id
+
+    logRequirements(cycle, model=MODEL, term=term_id,
+                    cycleDuration=cycleDuration,
+                    site_type_valid=site_type_valid,
+                    has_product_value=has_product_value,
+                    live_animal_term_id=live_animal_term_id,
+                    has_live_animal_node_value=has_live_animal_node_value,
+                    practice_id=practice_id,
+                    missing_milkYield_practice=missing_milkYield_practice)
+
+    should_run = all([
+        has_product_value, has_live_animal_node_value, practice_id, missing_milkYield_practice
+    ])
+    logShouldRun(cycle, MODEL, term_id, should_run, model_key=MODEL_KEY)
+    return should_run
+
+
+def _should_run(cycle: dict):
+    products = filter_list_term_type(cycle.get('products', []), TermTermType.ANIMALPRODUCT)
+    products = [p for p in products if _should_run_product(cycle, p)]
+
+    logRequirements(cycle, model=MODEL, term=None,
+                    animal_product_ids=log_blank_nodes_id(products))
+
+    should_run = all([products])
+    logShouldRun(cycle, MODEL, None, should_run, model_key=MODEL_KEY)
+    return should_run, products
+
+
+def run(cycle: dict):
+    should_run, products = _should_run(cycle)
+    return [_run(cycle, p) for p in products] if should_run else []

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/cycle/residueIncorporated.py

@@ -15,7 +15,7 @@ REQUIREMENTS = {
             {"@type": "Product", "term.@id": "aboveGroundCropResidueTotal", "value": "> 0"},
             {"@type": "Product", "term.@id": "aboveGroundCropResidueIncorporated", "value": "> 0"}
         ],
-        "not": {
+        "none": {
             "practices": [{
                 "@type": "Practice",
                 "term.@id": [

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/cycle/utils.py

@@ -1,9 +1,15 @@
 from hestia_earth.utils.tools import list_average
 
 from hestia_earth.models.log import logShouldRun
+from hestia_earth.models.utils.term import get_lookup_value
 from . import MODEL
 
 
+def _get_liveAnimal_term_id(product: dict, **log_ars):
+    term_id = get_lookup_value(product.get('term', {}), 'liveAnimal', model=MODEL, **log_ars)
+    return term_id.split(';')[0] if term_id else None
+
+
 def _should_run_property_by_min_max(property: dict):
     return all([
         property.get('min') is not None,

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/emepEea2019/nh3ToAirInorganicFertiliser.py

@@ -42,11 +42,11 @@ LOOKUPS = {
 RETURNS = {
     "Emission": [{
         "value": "",
-        "methodTier": "tier 1"
+        "methodTier": "tier 2"
     }]
 }
 TERM_ID = 'nh3ToAirInorganicFertiliser'
-TIER = EmissionMethodTier.TIER_1.value
+TIER = EmissionMethodTier.TIER_2.value
 UNSPECIFIED_TERM_ID = 'inorganicNitrogenFertiliserUnspecifiedKgN'
 
 
@@ -127,7 +127,7 @@ def _should_run(cycle: dict):
     run_with_unspecified = (has_country_data and has_unspecifiedKgN) or fertiliser_complete
     unspecifiedKgN = (
         0 if len(unspecifiedKgN) == 0 and fertiliser_complete else list_sum(unspecifiedKgN, None)
-    ) if run_with_unspecified else []
+    ) if run_with_unspecified else None
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     temperature=temperature,

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/faostat2018/seed.py

@@ -2,7 +2,7 @@ from hestia_earth.schema import InputStatsDefinition, TermTermType
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import list_sum, safe_parse_float
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_blank_nodes_id
 from hestia_earth.models.utils.term import get_lookup_value
 from hestia_earth.models.utils.input import _new_input
 from hestia_earth.models.utils.completeness import _is_term_type_incomplete
@@ -67,12 +67,11 @@ def _should_run(cycle: dict):
     products = cycle.get('products', [])
     crop_products = list(filter(_should_run_product, filter_list_term_type(products, TermTermType.CROP)))
     has_crop_products = len(crop_products) > 0
-    product_ids = ';'.join([p.get('term', {}).get('@id') for p in crop_products])
     term_type_incomplete = _is_term_type_incomplete(cycle, TermTermType.SEED.value)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
                     term_type_seed_incomplete=term_type_incomplete,
-                    crop_product_ids=product_ids or 'None')
+                    crop_product_ids=log_blank_nodes_id(crop_products))
 
     should_run = all([term_type_incomplete, has_crop_products])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/geospatialDatabase/clayContent.py

@@ -1,7 +1,8 @@
 from hestia_earth.schema import MeasurementMethodClassification
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.measurement import _new_measurement
+from hestia_earth.models.utils.blank_node import has_original_by_ids
+from hestia_earth.models.utils.measurement import SOIL_TEXTURE_IDS, _new_measurement
 from hestia_earth.models.utils.source import get_source
 from .utils import download, has_geospatial_data, should_download
 from . import MODEL
@@ -12,7 +13,17 @@ REQUIREMENTS = {
             {"latitude": "", "longitude": ""},
             {"boundary": {}},
             {"region": {"@type": "Term", "termType": "region"}}
-        ]
+        ],
+        "none": {
+            "measurements": [{
+                "@type": "Measurement",
+                "term.@id": [
+                    "clayContent",
+                    "sandContent",
+                    "siltContent"
+                ]
+            }]
+        }
     }
 }
 RETURNS = {
@@ -54,12 +65,14 @@ def _run(site: dict):
 def _should_run(site: dict):
     contains_geospatial_data = has_geospatial_data(site)
     below_max_area_size = should_download(TERM_ID, site)
+    has_original_texture_measurements = has_original_by_ids(site.get('measurements', []), SOIL_TEXTURE_IDS)
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,
-                    below_max_area_size=below_max_area_size)
+                    below_max_area_size=below_max_area_size,
+                    has_original_texture_measurements=has_original_texture_measurements)
 
-    should_run = all([contains_geospatial_data, below_max_area_size])
+    should_run = all([contains_geospatial_data, below_max_area_size, not has_original_texture_measurements])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run
 

{hestia-earth-models-0.57.2 → hestia-earth-models-0.59.0}/hestia_earth/models/geospatialDatabase/sandContent.py

@@ -1,7 +1,8 @@
 from hestia_earth.schema import MeasurementMethodClassification
 
 from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.measurement import _new_measurement
+from hestia_earth.models.utils.blank_node import has_original_by_ids
+from hestia_earth.models.utils.measurement import SOIL_TEXTURE_IDS, _new_measurement
 from hestia_earth.models.utils.source import get_source
 from .utils import download, has_geospatial_data, should_download
 from . import MODEL
@@ -12,7 +13,17 @@ REQUIREMENTS = {
             {"latitude": "", "longitude": ""},
             {"boundary": {}},
             {"region": {"@type": "Term", "termType": "region"}}
-        ]
+        ],
+        "none": {
+            "measurements": [{
+                "@type": "Measurement",
+                "term.@id": [
+                    "clayContent",
+                    "sandContent",
+                    "siltContent"
+                ]
+            }]
+        }
     }
 }
 RETURNS = {
@@ -54,12 +65,14 @@ def _run(site: dict):
 def _should_run(site: dict):
     contains_geospatial_data = has_geospatial_data(site)
     below_max_area_size = should_download(TERM_ID, site)
+    has_original_texture_measurements = has_original_by_ids(site.get('measurements', []), SOIL_TEXTURE_IDS)
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     contains_geospatial_data=contains_geospatial_data,
-                    below_max_area_size=below_max_area_size)
+                    below_max_area_size=below_max_area_size,
+                    has_original_texture_measurements=has_original_texture_measurements)
 
-    should_run = all([contains_geospatial_data, below_max_area_size])
+    should_run = all([contains_geospatial_data, below_max_area_size, not has_original_texture_measurements])
     logShouldRun(site, MODEL, TERM_ID, should_run)
     return should_run