hestia-earth-models 0.62.5__tar.gz → 0.63.0__tar.gz

{hestia-earth-models-0.62.5/hestia_earth_models.egg-info → hestia-earth-models-0.63.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.62.5
+Version: 0.63.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

hestia-earth-models-0.63.0/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-0.63.0/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-0.63.0/hestia_earth/models/cycle/siteDuration.py

@@ -0,0 +1,60 @@
+"""
+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
+
+REQUIREMENTS = {
+    "Cycle": {
+        "cycleDuration": "> 0",
+        "none": {
+            "otherSites": ""
+        },
+        "optional": {
+            "products": {
+                "@type": "Product",
+                "primary": "True",
+                "term.termType": "crop"
+            },
+            "startDateDefinition": ""
+        }
+    }
+}
+RETURNS = {
+    "the duration as a `number`": ""
+}
+MODEL_KEY = 'siteDuration'
+
+
+def _run(cycle: dict): return cycle.get('cycleDuration')
+
+
+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,
+                    is_primary_crop_product=is_primary_crop_product,
+                    is_harvest_previous_crop=is_harvest_previous_crop)
+
+    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
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else None

hestia-earth-models-0.63.0/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-0.62.5 → hestia-earth-models-0.63.0}/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-0.63.0/hestia_earth/models/geospatialDatabase/longFallowRatio.py

@@ -0,0 +1,79 @@
+from hestia_earth.schema import TermTermType
+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, 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": {
+        "site": {
+            "@type": "Site",
+            "or": [
+                {"region": {"@type": "Term"}},
+                {"country": {"@type": "Term"}}
+            ]
+        },
+        "optional": {
+            "otherSites": [
+                {
+                    "@type": "Site",
+                    "or": [
+                        {"region": {"@type": "Term"}},
+                        {"country": {"@type": "Term"}}
+                    ]
+                }
+            ]
+        }
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "value": "",
+        "site": ""
+    }]
+}
+LOOKUPS = {
+    "crop": "isPlantation",
+    "region-landUseManagement": "longFallowRatio"
+}
+TERM_ID = 'longFallowRatio'
+
+
+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 _should_run(cycle: dict):
+    product = find_primary_product(cycle) or {}
+    not_plantation = not is_plantation(MODEL, TERM_ID, product.get('term', {}).get('@id'))
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    not_plantation=not_plantation)
+
+    should_run = all([not_plantation])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+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-0.62.5 → hestia-earth-models-0.63.0}/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-0.62.5 → hestia-earth-models-0.63.0}/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-0.62.5/hestia_earth/models/pooreNemecek2018/longFallowPeriod.py → hestia-earth-models-0.63.0/hestia_earth/models/pooreNemecek2018/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-0.62.5 → hestia-earth-models-0.63.0}/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-0.62.5 → hestia-earth-models-0.63.0}/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 = {