hestia-earth-models 0.57.2__py3-none-any.whl → 0.59.0__py3-none-any.whl

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/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/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/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/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/cycle/{irrigated.py → 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/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/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/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/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/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/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/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/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
 

hestia_earth/models/geospatialDatabase/siltContent.py

@@ -1,6 +1,6 @@
 from hestia_earth.schema import MeasurementMethodClassification
 
-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.measurement import _new_measurement, measurement_value
 from hestia_earth.models.utils.source import get_source
 from . import MODEL, clayContent, sandContent
@@ -53,7 +53,7 @@ def _should_run(site: dict):
 
     logRequirements(site, model=MODEL, term=TERM_ID,
                     has_all_measurements=has_all_measurements,
-                    measurements=';'.join([m.get('term', {}).get('@id') for m in measurements]))
+                    measurement_ids=log_blank_nodes_id(measurements))
 
     should_run = all([has_all_measurements])
     logShouldRun(site, MODEL, TERM_ID, should_run)

hestia_earth/models/impact_assessment/irrigated.py

@@ -18,9 +18,6 @@ REQUIREMENTS = {
 RETURNS = {
     "`true` if the `Cycle` was irrigated, `false` otherwise": ""
 }
-LOOKUPS = {
-    "waterRegime": "irrigated"
-}
 MODEL_KEY = 'irrigated'
 
 

hestia_earth/models/ipcc2006/co2ToAirOrganicSoilCultivation.py

@@ -67,7 +67,7 @@ def _should_run(cycle: dict):
     def _get_measurement_content(term_id: str):
         return most_relevant_measurement_value(measurements, term_id, end_date)
 
-    histosol = _get_measurement_content('histosol') or 0
+    histosol = _get_measurement_content('histosol')
     eco_climate_zone = _get_measurement_content('ecoClimateZone')
     organic_soil_factor = _get_CO2_factor(eco_climate_zone, site_type) if eco_climate_zone else 0
     land_occupation = land_occupation_per_ha(MODEL, TERM_ID, cycle)
@@ -77,7 +77,7 @@ def _should_run(cycle: dict):
                     land_occupation=land_occupation,
                     histosol=histosol)
 
-    should_run = all([organic_soil_factor, land_occupation])
+    should_run = all([organic_soil_factor, land_occupation, histosol is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, histosol, organic_soil_factor, land_occupation
 

hestia_earth/models/ipcc2006/n2OToAirCropResidueDecompositionIndirect.py

@@ -43,7 +43,7 @@ def _run(no3: float, nh3: float, nox: float):
 
 
 def _should_run(cycle: dict):
-    nh3_n, no3_n, nox_n = get_nh3_no3_nox_to_n(cycle, NH3_TERM_ID, NO3_TERM_ID, NOX_TERM_ID)
+    nh3_n, no3_n, nox_n = get_nh3_no3_nox_to_n(cycle, NH3_TERM_ID, NO3_TERM_ID, NOX_TERM_ID, allow_none=False)
     term_type_complete = _is_term_type_complete(cycle, TermTermType.CROPRESIDUE)
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
@@ -52,7 +52,7 @@ def _should_run(cycle: dict):
                     nox_n=nox_n,
                     term_type_cropResidue_complete=term_type_complete)
 
-    should_run = all([no3_n, nh3_n, nox_n, term_type_complete])
+    should_run = all([no3_n is not None, nh3_n is not None, nox_n is not None, term_type_complete])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, no3_n, nh3_n, nox_n