hestia-earth-models 0.62.5__py3-none-any.whl → 0.63.0__py3-none-any.whl

hestia_earth/models/cycle/croppingIntensity.py

@@ -0,0 +1,57 @@
+from hestia_earth.schema import CycleStartDateDefinition
+from hestia_earth.utils.model import find_primary_product
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.practice import _new_practice
+from hestia_earth.models.utils.crop import is_plantation
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "cycleDuration": "> 0",
+        "startDateDefinition": "harvest of previous crop"
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "value": ""
+    }]
+}
+LOOKUPS = {
+    "crop": "isPlantation"
+}
+TERM_ID = 'croppingIntensity'
+
+
+def _practice(value: float):
+    practice = _new_practice(TERM_ID)
+    practice['value'] = [round(value, 7)]
+    return practice
+
+
+def _run(cycle: dict):
+    cycleDuration = cycle.get('cycleDuration')
+    return [_practice(cycleDuration / 365)]
+
+
+def _should_run(cycle: dict):
+    product = find_primary_product(cycle) or {}
+    not_plantation = not is_plantation(MODEL, TERM_ID, product.get('term', {}).get('@id'))
+
+    cycleDuration = cycle.get('cycleDuration', 0)
+    has_cycleDuration = cycleDuration > 0
+    startDateDefinition = cycle.get('startDateDefinition')
+    harvest_previous_crop = CycleStartDateDefinition.HARVEST_OF_PREVIOUS_CROP.value
+    is_harvest_previous_crop = startDateDefinition == harvest_previous_crop
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    not_plantation=not_plantation,
+                    cycleDuration=cycleDuration,
+                    is_harvest_previous_crop=is_harvest_previous_crop)
+
+    should_run = all([not_plantation, has_cycleDuration, is_harvest_previous_crop])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []

hestia_earth/models/cycle/longFallowRatio.py

@@ -0,0 +1,52 @@
+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.practice import _new_practice
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "practices": [
+            {"@type": "Practice", "value": "> 0", "term.@id": "longFallowDuration"},
+            {"@type": "Practice", "value": "> 0", "term.@id": "rotationDuration"}
+        ]
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "value": ""
+    }]
+}
+TERM_ID = 'longFallowRatio'
+
+
+def _practice(value: float):
+    practice = _new_practice(TERM_ID)
+    practice['value'] = [round(value, 7)]
+    return practice
+
+
+def _run(longFallowDuration: float, rotationDuration: float):
+    value = rotationDuration / (rotationDuration - longFallowDuration)
+    return [_practice(value)]
+
+
+def _should_run(cycle: dict):
+    practices = cycle.get('practices', [])
+
+    longFallowDuration = list_sum(find_term_match(practices, 'longFallowDuration', {}).get('value', 0), 0)
+    rotationDuration = list_sum(find_term_match(practices, 'rotationDuration', {}).get('value', 0), 0)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    longFallowDuration=longFallowDuration,
+                    rotationDuration=rotationDuration)
+
+    should_run = all([longFallowDuration > 0, rotationDuration > 0])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run, longFallowDuration, rotationDuration
+
+
+def run(cycle: dict):
+    should_run, longFallowDuration, rotationDuration = _should_run(cycle)
+    return _run(longFallowDuration, rotationDuration) if should_run else []

hestia_earth/models/cycle/siteDuration.py

@@ -3,7 +3,12 @@ Site duration
 
 This model calculates the `siteDuration` on the `Cycle` to the same value as `cycleDuration`
 when only a single `Site` is present.
+
+Note: on `crop` production cycles, the model will only run if `startDateDefinition` = `harvest of previous crop`.
 """
+from hestia_earth.schema import TermTermType, CycleStartDateDefinition
+from hestia_earth.utils.model import find_primary_product
+
 from hestia_earth.models.log import logRequirements, logShouldRun
 from . import MODEL
 
@@ -12,11 +17,19 @@ REQUIREMENTS = {
         "cycleDuration": "> 0",
         "none": {
             "otherSites": ""
+        },
+        "optional": {
+            "products": {
+                "@type": "Product",
+                "primary": "True",
+                "term.termType": "crop"
+            },
+            "startDateDefinition": ""
         }
     }
 }
 RETURNS = {
-    "a `number` or `None` if the `Cycle` has multiple `Sites`": ""
+    "the duration as a `number`": ""
 }
 MODEL_KEY = 'siteDuration'
 
@@ -28,11 +41,18 @@ def _should_run(cycle: dict):
     cycleDuration = cycle.get('cycleDuration', 0)
     has_other_sites = len(cycle.get('otherSites', [])) == 0
 
+    product = find_primary_product(cycle)
+    is_primary_crop_product = (product or {}).get('term', {}).get('termType') == TermTermType.CROP.value
+    harvest_previous_crop = CycleStartDateDefinition.HARVEST_OF_PREVIOUS_CROP.value
+    is_harvest_previous_crop = cycle.get('startDateDefinition') == harvest_previous_crop
+
     logRequirements(cycle, model=MODEL, key=MODEL_KEY,
                     cycleDuration=cycleDuration,
-                    has_other_sites=has_other_sites)
+                    has_other_sites=has_other_sites,
+                    is_primary_crop_product=is_primary_crop_product,
+                    is_harvest_previous_crop=is_harvest_previous_crop)
 
-    should_run = all([cycleDuration > 0, has_other_sites])
+    should_run = all([cycleDuration > 0, has_other_sites, not is_primary_crop_product or is_harvest_previous_crop])
     logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY)
     return should_run
 

hestia_earth/models/cycle/siteUnusedDuration.py

@@ -0,0 +1,64 @@
+"""
+Site Unused Duration
+
+This model sets the [Cycle siteUnusedDuration](https://hestia.earth/schema/Cycle#siteUnusedDuration) based on
+the `siteDuration` and the `longFallowRatio` practice.
+"""
+from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.site import valid_site_type
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "siteType": ["cropland", "glass and high accessible cover"]
+        },
+        "siteDuration": "> 0",
+        "practices": [{"@type": "Practice", "value": "> 0", "term.@id": "longFallowRatio"}]
+    }
+}
+RETURNS = {
+    "The siteUnusedDuration as a number": ""
+}
+MODEL_KEY = 'siteUnusedDuration'
+VALID_SITE_TYPES = [
+    SiteSiteType.CROPLAND.value,
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value
+]
+
+
+def _run(cycle: dict, longFallowRatio: float):
+    siteDuration = cycle.get('siteDuration')
+    return siteDuration * (longFallowRatio - 1)
+
+
+def _should_run(cycle: dict):
+    site_type_valid = valid_site_type(cycle.get('site'), site_types=VALID_SITE_TYPES)
+
+    siteDuration = cycle.get('siteDuration', 0)
+
+    practices = cycle.get('practices', [])
+    longFallowRatio = list_sum(next((
+        p for p in practices if all([
+            p.get('term', {}).get('@id') == 'longFallowRatio',
+            p.get('site') is None or p.get('site', {}).get('@id') == cycle.get('site', {}).get('@id')
+        ])
+    ), {}).get('value'), None)
+
+    logRequirements(cycle, model=MODEL, key=MODEL_KEY,
+                    site_type_valid=site_type_valid,
+                    siteDuration=siteDuration,
+                    longFallowRatio=longFallowRatio)
+
+    should_run = all([site_type_valid, siteDuration > 0, longFallowRatio is not None])
+    logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY)
+    return should_run, longFallowRatio
+
+
+def run(cycle: dict):
+    should_run, longFallowRatio = _should_run(cycle)
+    return _run(cycle, longFallowRatio) if should_run else None

hestia_earth/models/geospatialDatabase/croppingIntensity.py

@@ -1,31 +1,40 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import find_primary_product
+from hestia_earth.utils.model import find_primary_product, linked_node
+from hestia_earth.utils.tools import non_empty_list
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.crop import is_plantation
+from hestia_earth.models.utils.cycle import get_allowed_sites
 from .utils import get_region_factor
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{
-            "@type": "Product",
-            "primary": "True",
-            "term.termType": "crop"
-        }],
         "site": {
             "@type": "Site",
             "or": [
                 {"region": {"@type": "Term"}},
                 {"country": {"@type": "Term"}}
             ]
+        },
+        "optional": {
+            "otherSites": [
+                {
+                    "@type": "Site",
+                    "or": [
+                        {"region": {"@type": "Term"}},
+                        {"country": {"@type": "Term"}}
+                    ]
+                }
+            ]
         }
     }
 }
 RETURNS = {
     "Practice": [{
-        "value": ""
+        "value": "",
+        "site": ""
     }]
 }
 LOOKUPS = {
@@ -35,25 +44,14 @@ LOOKUPS = {
 TERM_ID = 'croppingIntensity'
 
 
-def _practice(value: float):
+def _practice(site: dict, value: float):
     practice = _new_practice(TERM_ID)
+    practice['site'] = linked_node(site)
     # force conversion to float from numpy, avoiding errors when reading it in other models
     practice['value'] = [float(round(value, 7))]
     return practice
 
 
-def _run(cycle: dict):
-    site = cycle.get('site')
-    region_factor = get_region_factor(TERM_ID, site, TermTermType.LANDUSEMANAGEMENT)
-
-    logRequirements(site, model=MODEL, term=TERM_ID,
-                    region_factor=region_factor)
-
-    should_run = all([region_factor])
-    logShouldRun(site, MODEL, TERM_ID, should_run)
-    return [_practice(region_factor)] if should_run else []
-
-
 def _should_run(cycle: dict):
     product = find_primary_product(cycle) or {}
     not_plantation = not is_plantation(MODEL, TERM_ID, product.get('term', {}).get('@id'))
@@ -66,4 +64,16 @@ def _should_run(cycle: dict):
     return should_run
 
 
-def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []
+def run(cycle: dict):
+    sites = get_allowed_sites(MODEL, TERM_ID, TermTermType.LANDUSEMANAGEMENT, cycle) if _should_run(cycle) else []
+    sites = [
+        (site, get_region_factor(TERM_ID, site, TermTermType.LANDUSEMANAGEMENT)) for site in sites
+    ]
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                site_factors=log_as_table([{
+                    'site-id': site.get('@id', site.get('id')),
+                    'factor': factor
+                } for site, factor in sites]))
+
+    return non_empty_list([_practice(site, factor) for site, factor in sites if bool(factor)])

hestia_earth/models/geospatialDatabase/longFallowRatio.py

@@ -1,31 +1,40 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import find_primary_product
+from hestia_earth.utils.model import find_primary_product, linked_node
+from hestia_earth.utils.tools import non_empty_list
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, debugValues, log_as_table
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.crop import is_plantation
+from hestia_earth.models.utils.cycle import get_allowed_sites
 from .utils import get_region_factor
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{
-            "@type": "Product",
-            "primary": "True",
-            "term.termType": "crop"
-        }],
         "site": {
             "@type": "Site",
             "or": [
                 {"region": {"@type": "Term"}},
                 {"country": {"@type": "Term"}}
             ]
+        },
+        "optional": {
+            "otherSites": [
+                {
+                    "@type": "Site",
+                    "or": [
+                        {"region": {"@type": "Term"}},
+                        {"country": {"@type": "Term"}}
+                    ]
+                }
+            ]
         }
     }
 }
 RETURNS = {
     "Practice": [{
-        "value": ""
+        "value": "",
+        "site": ""
     }]
 }
 LOOKUPS = {
@@ -35,24 +44,14 @@ LOOKUPS = {
 TERM_ID = 'longFallowRatio'
 
 
-def _practice(value: float):
+def _practice(site: dict, value: float):
     practice = _new_practice(TERM_ID)
-    practice['value'] = [round(value, 7)]
+    practice['site'] = linked_node(site)
+    # force conversion to float from numpy, avoiding errors when reading it in other models
+    practice['value'] = [float(round(value, 7))]
     return practice
 
 
-def _run(cycle: dict):
-    site = cycle.get('site')
-    region_factor = get_region_factor(TERM_ID, site, TermTermType.LANDUSEMANAGEMENT)
-
-    logRequirements(site, model=MODEL, term=TERM_ID,
-                    region_factor=region_factor)
-
-    should_run = all([region_factor])
-    logShouldRun(site, MODEL, TERM_ID, should_run)
-    return [_practice(region_factor)] if should_run else []
-
-
 def _should_run(cycle: dict):
     product = find_primary_product(cycle) or {}
     not_plantation = not is_plantation(MODEL, TERM_ID, product.get('term', {}).get('@id'))
@@ -65,4 +64,16 @@ def _should_run(cycle: dict):
     return should_run
 
 
-def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []
+def run(cycle: dict):
+    sites = get_allowed_sites(MODEL, TERM_ID, TermTermType.LANDUSEMANAGEMENT, cycle) if _should_run(cycle) else []
+    sites = [
+        (site, get_region_factor(TERM_ID, site, TermTermType.LANDUSEMANAGEMENT)) for site in sites
+    ]
+
+    debugValues(cycle, model=MODEL, term=TERM_ID,
+                site_factors=log_as_table([{
+                    'site-id': site.get('@id', site.get('id')),
+                    'factor': factor
+                } for site, factor in sites]))
+
+    return non_empty_list([_practice(site, factor) for site, factor in sites if bool(factor)])

hestia_earth/models/mocking/mock_search.py

@@ -52,20 +52,26 @@ def _load_results(filepath: str):
 
 def _find_search_result(filepath: str, query: dict):
     search_results = _load_results(filepath)
-    res = next((n for n in search_results if n['query'] == query), {})
-    return res.get('results', [])
+    res = next((n for n in search_results if n['query'] == query), None)
+    return None if res is None else res.get('results', [])
 
 
-def _fake_search(filepath: str):
-    def mock(query: dict, *_a, **_b): return _find_search_result(filepath, query)
+def _mocked_search(original_func, filepath: str):
+    def mock(query: dict, **kwargs):
+        result = _find_search_result(filepath, query)
+        return original_func(query, **kwargs) if result is None else result
     return mock
 
 
-def _fake_find_node(filepath: str):
-    def mock(_n, query: dict, *_a, **_b): return _find_search_result(filepath, query)
+def _mocked_find_node(original_func, filepath: str):
+    def mock(node_type: str, query: dict, **kwargs):
+        result = _find_search_result(filepath, query)
+        return original_func(node_type, query, **kwargs) if result is None else result
     return mock
 
 
 def mock(filepath: str):
-    term.search = _fake_search(filepath)
-    term.find_node = _fake_find_node(filepath)
+    original_search = term.search
+    term.search = _mocked_search(original_search, filepath)
+    original_find_node = term.find_node
+    term.find_node = _mocked_find_node(original_find_node, filepath)

hestia_earth/models/mocking/search-results.json

@@ -1054,11 +1054,11 @@
     "results": [
       {
         "@type": "Term",
-        "@id": "residueIncorporatedLessThan30DaysBeforeCultivation"
+        "@id": "residueIncorporated"
       },
       {
         "@type": "Term",
-        "@id": "residueIncorporated"
+        "@id": "residueIncorporatedMoreThan30DaysBeforeCultivation"
       },
       {
         "@type": "Term",
@@ -1066,7 +1066,7 @@
       },
       {
         "@type": "Term",
-        "@id": "residueIncorporatedMoreThan30DaysBeforeCultivation"
+        "@id": "residueIncorporatedLessThan30DaysBeforeCultivation"
       },
       {
         "@type": "Term",
@@ -1110,27 +1110,27 @@
       },
       {
         "@type": "Term",
-        "@id": "aboveGroundCropResidueBurnt"
+        "@id": "discardedCropRemoved"
       },
       {
         "@type": "Term",
-        "@id": "belowGroundCropResidue"
+        "@id": "aboveGroundCropResidueTotal"
       },
       {
         "@type": "Term",
-        "@id": "aboveGroundCropResidueLeftOnField"
+        "@id": "aboveGroundCropResidueIncorporated"
       },
       {
         "@type": "Term",
-        "@id": "discardedCropRemoved"
+        "@id": "aboveGroundCropResidueBurnt"
       },
       {
         "@type": "Term",
-        "@id": "aboveGroundCropResidueTotal"
+        "@id": "belowGroundCropResidue"
       },
       {
         "@type": "Term",
-        "@id": "aboveGroundCropResidueIncorporated"
+        "@id": "aboveGroundCropResidueLeftOnField"
       }
     ]
   },
@@ -1486,7 +1486,7 @@
         "@type": "Term",
         "name": "Generic crop, seed",
         "@id": "genericCropSeed",
-        "_score": 26.312824
+        "_score": 26.36456
       }
     ]
   },
@@ -1534,10 +1534,6 @@
         "@type": "Term",
         "@id": "rainfedDeepWaterWaterDepth100Cm"
       },
-      {
-        "@type": "Term",
-        "@id": "irrigatedTypeUnspecified"
-      },
       {
         "@type": "Term",
         "@id": "irrigatedLocalizedIrrigation"
@@ -1550,6 +1546,10 @@
         "@type": "Term",
         "@id": "irrigatedSubIrrigation"
       },
+      {
+        "@type": "Term",
+        "@id": "irrigatedTypeUnspecified"
+      },
       {
         "@type": "Term",
         "@id": "irrigatedDripIrrigation"
@@ -1722,61 +1722,61 @@
         "@type": "Term",
         "name": "Glass or high accessible cover",
         "@id": "glassOrHighAccessibleCover",
-        "_score": 59.49422
+        "_score": 59.78251
       },
       {
         "@type": "Term",
         "name": "River or stream",
         "@id": "riverOrStream",
-        "_score": 50.673336
+        "_score": 51.118263
       },
       {
         "@type": "Term",
         "name": "Other natural vegetation",
         "@id": "otherNaturalVegetation",
-        "_score": 40.97334
+        "_score": 41.25843
       },
       {
         "@type": "Term",
         "name": "Natural forest",
         "@id": "naturalForest",
-        "_score": 31.583748
+        "_score": 31.747753
       },
       {
         "@type": "Term",
         "name": "Permanent pasture",
         "@id": "permanentPasture",
-        "_score": 28.25857
+        "_score": 28.454437
       },
       {
         "@type": "Term",
         "name": "Animal housing",
         "@id": "animalHousing",
-        "_score": 27.218006
+        "_score": 27.424242
       },
       {
         "@type": "Term",
         "name": "Root or tuber crop plant",
         "@id": "rootOrTuberCropPlant",
-        "_score": 25.098145
+        "_score": 25.260658
       },
       {
         "@type": "Term",
         "name": "High intensity grazing pasture",
         "@id": "highIntensityGrazingPasture",
-        "_score": 23.833916
+        "_score": 24.038225
       },
       {
         "@type": "Term",
         "name": "Permanent cropland",
         "@id": "permanentCropland",
-        "_score": 20.639563
+        "_score": 20.689457
       },
       {
         "@type": "Term",
         "name": "Forest",
         "@id": "forest",
-        "_score": 20.246805
+        "_score": 20.366226
       }
     ]
   },
@@ -2024,15 +2024,15 @@
     "results": [
       {
         "@type": "Term",
-        "@id": "verticalTillage"
+        "@id": "noTillage"
       },
       {
         "@type": "Term",
-        "@id": "noTillage"
+        "@id": "ridgeTillage"
       },
       {
         "@type": "Term",
-        "@id": "ridgeTillage"
+        "@id": "verticalTillage"
       },
       {
         "@type": "Term",

hestia_earth/models/pooreNemecek2018/{longFallowPeriod.py → longFallowDuration.py}

@@ -7,19 +7,18 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{"@type": "Product", "value": "", "term.termType": "crop"}],
-        "site": {"@type": "Site", "siteType": "cropland"}
+        "products": [{"@type": "Product", "value": "", "term.termType": "crop"}]
     }
 }
 LOOKUPS = {
-    "crop": "Plantation_longFallowPeriod"
+    "crop": "Plantation_longFallowDuration"
 }
 RETURNS = {
     "Practice": [{
         "value": ""
     }]
 }
-TERM_ID = 'longFallowPeriod'
+TERM_ID = 'longFallowDuration'
 
 
 def _practice(value: float):

hestia_earth/models/pooreNemecek2018/nurseryDensity.py

@@ -7,8 +7,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{"@type": "Product", "value": "", "term.termType": "crop"}],
-        "site": {"@type": "Site", "siteType": "cropland"}
+        "products": [{"@type": "Product", "value": "", "term.termType": "crop"}]
     }
 }
 LOOKUPS = {

hestia_earth/models/pooreNemecek2018/nurseryDuration.py

@@ -7,8 +7,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{"@type": "Product", "value": "", "term.termType": "crop"}],
-        "site": {"@type": "Site", "siteType": "cropland"}
+        "products": [{"@type": "Product", "value": "", "term.termType": "crop"}]
     }
 }
 LOOKUPS = {