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

hestia_earth/models/cycle/endDate.py

@@ -0,0 +1,47 @@
+"""
+End Date
+
+This model sets the [Cycle endDate](https://hestia.earth/schema/Cycle#endDate) based on:
+* if no `cycleDuration` is provided, and the `endDate` is set to month precision (e.g., `2000-01`),
+assumed it ended on the 14th of the month.
+"""
+from hestia_earth.utils.date import is_in_months
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "endDate": "month precision",
+        "none": {
+            "cycleDuration": ""
+        }
+    }
+}
+RETURNS = {
+    "The endDate as a string": ""
+}
+MODEL_KEY = 'endDate'
+
+
+def _run(cycle: dict):
+    endDate = cycle.get('endDate')
+    return f"{endDate}-14"
+
+
+def _should_run(cycle: dict):
+    has_endDate = cycle.get('endDate') is not None
+    has_month_precision = has_endDate and is_in_months(cycle.get('endDate'))
+    no_cycleDuration = cycle.get('cycleDuration') is None
+
+    logRequirements(cycle, model=MODEL, key=MODEL_KEY, by='endDate',
+                    has_endDate=has_endDate,
+                    has_month_precision=has_month_precision,
+                    no_cycleDuration=no_cycleDuration)
+
+    should_run = all([has_endDate, has_month_precision, no_cycleDuration])
+    logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY, by='endDate')
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else None

hestia_earth/models/cycle/otherSitesUnusedDuration.py

@@ -0,0 +1,91 @@
+"""
+Other Sites Unused Duration
+
+This model sets the [Cycle otherSitesUnusedDuration](https://hestia.earth/schema/Cycle#otherSitesUnusedDuration)
+based on the `otherSites`, `otherSitesDuration`, and the `longFallowRatio` practice associated with each.
+"""
+from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.site import valid_site_type
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "otherSites": [{
+            "@type": "Site",
+            "siteType": ["cropland", "glass and high accessible cover"]
+        }],
+        "otherSitesDuration": "",
+        "practices": [{
+            "@type": "Practice",
+            "value": "> 0",
+            "term.@id": "longFallowRatio",
+            "site": {"@type": "Site"}
+        }]
+    }
+}
+RETURNS = {
+    "The otherSitesUnusedDuration as an array of number": ""
+}
+MODEL_KEY = 'otherSitesUnusedDuration'
+VALID_SITE_TYPES = [
+    SiteSiteType.CROPLAND.value,
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value
+]
+_PRACTICE_TERM_ID = 'longFallowRatio'
+
+
+def _run(siteDuration: float, longFallowRatio: float):
+    return siteDuration * (longFallowRatio - 1)
+
+
+def _find_site_practice(practices: list, site_id: str):
+    return list_sum(next(
+        (p for p in practices if all([
+            p.get('term', {}).get('@id') == _PRACTICE_TERM_ID,
+            p.get('site') is None or p.get('site', {}).get('@id', p.get('site', {}).get('id')) == site_id
+        ])),
+        {}
+    ).get('value'), None)
+
+
+def _should_run(cycle: dict):
+    otherSitesDuration = cycle.get('otherSitesDuration', [])
+    practices = cycle.get('practices', [])
+
+    site_data = [
+        {
+            'site-id': site.get('@id', site.get('id')),
+            'siteType': site.get('siteType'),
+            'valid-site': valid_site_type(site, site_types=VALID_SITE_TYPES),
+            'site-duration': otherSitesDuration[index] if len(otherSitesDuration) > index else None,
+            _PRACTICE_TERM_ID: _find_site_practice(practices, site.get('@id'))
+        }
+        for index, site in enumerate(cycle.get('otherSites', []))
+    ]
+
+    has_valid_sites = any([
+        all([
+            data.get('valid-site'),
+            data.get(_PRACTICE_TERM_ID) is not None,
+            (data.get('site-duration') or 0) >= 0
+        ]) for data in site_data
+    ])
+
+    logRequirements(cycle, model=MODEL, key=MODEL_KEY,
+                    has_valid_sites=has_valid_sites,
+                    site_data=log_as_table(site_data))
+
+    should_run = all([has_valid_sites])
+    logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY)
+    return should_run, site_data
+
+
+def run(cycle: dict):
+    should_run, site_data = _should_run(cycle)
+    return [
+        _run(data.get('site-duration'), data.get(_PRACTICE_TERM_ID)) if data.get('valid-site') else None
+        for data in site_data
+    ] if should_run else []

hestia_earth/models/cycle/siteUnusedDuration.py

@@ -37,6 +37,7 @@ def _run(cycle: dict, longFallowRatio: float):
 
 
 def _should_run(cycle: dict):
+    site_id = cycle.get('site', {}).get('@id', cycle.get('site', {}).get('id'))
     site_type_valid = valid_site_type(cycle.get('site'), site_types=VALID_SITE_TYPES)
 
     siteDuration = cycle.get('siteDuration', 0)
@@ -45,7 +46,7 @@ def _should_run(cycle: dict):
     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')
+            p.get('site') is None or p.get('site', {}).get('@id', p.get('site', {}).get('id')) == site_id
         ])
     ), {}).get('value'), None)
 

hestia_earth/models/cycle/startDate.py

@@ -1,11 +1,13 @@
 """
 Start Date
 
-This model sets the [Cycle startDate](https://hestia.earth/schema/Cycle#startDate) based on the `endDate` and the
-`cycleDuration`. This only works when the `endDate` has been provided to a day precision (`2000-01-01`).
+This model sets the [Cycle startDate](https://hestia.earth/schema/Cycle#startDate) based on:
+* the `cycleDuration` and the `endDate` if it has been provided to a day precision (e.g., `2000-01-01`);
+* if no `cycleDuration` is provided, and the `startDate` is set to month precision (e.g., `2000-01`),
+assumed it started on the 15th of the month.
 """
 from datetime import timedelta
-from hestia_earth.utils.date import is_in_days
+from hestia_earth.utils.date import is_in_days, is_in_months
 from hestia_earth.utils.tools import safe_parse_date
 
 from hestia_earth.models.log import logRequirements, logShouldRun
@@ -13,8 +15,11 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "endDate": "to day precision",
-        "cycleDuration": ""
+        "optional": {
+            "startDate": "month precision",
+            "endDate": "day precision",
+            "cycleDuration": ""
+        }
     }
 }
 RETURNS = {
@@ -23,25 +28,48 @@ RETURNS = {
 MODEL_KEY = 'startDate'
 
 
-def _run(cycle: dict):
+def _run_by_cycleDuration(cycle: dict):
     endDate = safe_parse_date(cycle.get('endDate'))
     cycleDuration = cycle.get('cycleDuration')
     return (endDate - timedelta(days=cycleDuration)).strftime('%Y-%m-%d')
 
 
-def _should_run(cycle: dict):
+def _should_run_by_cycleDuration(cycle: dict):
     has_endDate = cycle.get('endDate') is not None
     has_day_precision = has_endDate and is_in_days(cycle.get('endDate'))
     has_cycleDuration = cycle.get('cycleDuration') is not None
 
-    logRequirements(cycle, model=MODEL, key=MODEL_KEY,
+    logRequirements(cycle, model=MODEL, key=MODEL_KEY, by='cycleDuration',
                     has_endDate=has_endDate,
                     has_day_precision=has_day_precision,
                     has_cycleDuration=has_cycleDuration)
 
     should_run = all([has_endDate, has_day_precision, has_cycleDuration])
-    logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY)
+    logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY, by='cycleDuration')
     return should_run
 
 
-def run(cycle: dict): return _run(cycle) if _should_run(cycle) else None
+def _run_by_startDate(cycle: dict):
+    startDate = cycle.get('startDate')
+    return f"{startDate}-15"
+
+
+def _should_run_by_startDate(cycle: dict):
+    has_startDate = cycle.get('startDate') is not None
+    has_month_precision = has_startDate and is_in_months(cycle.get('startDate'))
+    no_cycleDuration = cycle.get('cycleDuration') is None
+
+    logRequirements(cycle, model=MODEL, key=MODEL_KEY, by='startDate',
+                    has_startDate=has_startDate,
+                    has_month_precision=has_month_precision,
+                    no_cycleDuration=no_cycleDuration)
+
+    should_run = all([has_startDate, has_month_precision, no_cycleDuration])
+    logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY, by='startDate')
+    return should_run
+
+
+def run(cycle: dict):
+    return _run_by_cycleDuration(cycle) if _should_run_by_cycleDuration(cycle) else (
+        _run_by_startDate(cycle) if _should_run_by_startDate(cycle) else None
+    )

hestia_earth/models/cycle/startDateDefinition.py

@@ -14,11 +14,11 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "cycleDuration": "",
-        "products": {
+        "products": [{
             "@type": "Product",
             "primary": "True",
             "term.termType": "crop"
-        },
+        }],
         "optional": {
             "endDate": ""
         }

hestia_earth/models/cycle/unknownPreSeasonWaterRegime.py

@@ -0,0 +1,51 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.term import get_flooded_pre_season_terms
+from hestia_earth.models.utils.practice import _new_practice
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "none": {
+            "practices": [{
+                "@type": "Practice",
+                "term.termType": "landUseManagement",
+                "term.@id": [
+                    "nonFloodedPreSeasonLessThan180Days",
+                    "nonFloodedPreSeasonMoreThan180Days",
+                    "nonFloodedPreSeasonMoreThan365Days",
+                    "floodedPreSeasonMoreThan30Days"
+                ]
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Practice": [{
+        "value": "100"
+    }]
+}
+TERM_ID = 'unknownPreSeasonWaterRegime'
+
+
+def _practice():
+    practice = _new_practice(TERM_ID)
+    practice['value'] = [100]
+    return practice
+
+
+def _should_run(cycle: dict):
+    practices = cycle.get('practices', [])
+    flooded_terms = get_flooded_pre_season_terms()
+    print(flooded_terms)
+    existing_practice = next((p for p in practices if p.get('term', {}).get('@id') in flooded_terms), None)
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    existing_practice=existing_practice)
+
+    should_run = all([not existing_practice])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(cycle: dict):
+    return [_practice()] if _should_run(cycle) else []

hestia_earth/models/ecoinventV3/__init__.py

@@ -19,6 +19,7 @@ from hestia_earth.utils.tools import flatten, list_sum
 
 from hestia_earth.models.log import debugValues, logShouldRun, logRequirements
 from hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
+from hestia_earth.models.utils import is_from_model
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.pesticideAI import get_pesticides_from_inputs
@@ -109,18 +110,33 @@ def _add_emission(cycle: dict, input: dict):
 
 
 def _run_input(cycle: dict):
+    emissions = cycle.get('emissions', [])
+
     def run(inputs: list):
         input = inputs[0]
         input_term_id = input.get('term', {}).get('@id')
+        operation_term_id = input.get('operation', {}).get('@id')
+        animal_term_id = input.get('animal', {}).get('@id')
         input_value = list_sum(flatten(input.get('value', []) for input in inputs))
         mappings = get_input_mappings(MODEL, cycle, input)
         has_mappings = len(mappings) > 0
+        # skip input that has background emissions we have already gap-filled (model run before)
+        has_no_gap_filled_background_emissions = not any([
+            is_from_model(e)
+            for e in emissions
+            if all([
+                any([i.get('@id') == input_term_id for i in e.get('inputs', [])]),
+                e.get('operation', {}).get('@id') == operation_term_id,
+                e.get('animal', {}).get('@id') == animal_term_id
+            ])
+        ])
 
         logRequirements(cycle, model=MODEL, term=input_term_id,
                         has_ecoinvent_mappings=has_mappings,
-                        ecoinvent_mappings=';'.join([v[0] for v in mappings]))
+                        ecoinvent_mappings=';'.join([v[0] for v in mappings]),
+                        has_no_gap_filled_background_emissions=has_no_gap_filled_background_emissions)
 
-        should_run = all([has_mappings])
+        should_run = all([has_mappings, has_no_gap_filled_background_emissions])
         logShouldRun(cycle, MODEL, input_term_id, should_run, methodTier=TIER)
         grouped_emissions = reduce(_add_emission(cycle, input), mappings, {}) if should_run else {}
         return [

hestia_earth/models/edip2003/__init__.py

@@ -0,0 +1,13 @@
+from os.path import dirname, abspath
+import sys
+from importlib import import_module
+
+from hestia_earth.models.utils.blank_node import run_if_required
+
+CURRENT_DIR = dirname(abspath(__file__)) + '/'
+sys.path.append(CURRENT_DIR)
+MODEL = 'edip2003'
+PKG = '.'.join(['hestia_earth', 'models', MODEL])
+
+
+def run(model: str, data): return run_if_required(MODEL, model, data, import_module(f".{model}", package=PKG))

hestia_earth/models/edip2003/ozoneDepletionPotential.py

@@ -0,0 +1,34 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.impact_assessment import impact_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator", "value": "", "term.termType": "emission"}]
+    }
+}
+LOOKUPS = {
+    "emission": "ozoneDepletionPotential"
+}
+RETURNS = {
+    "Indicator": [{
+        "value": ""
+    }]
+}
+
+TERM_ID = 'ozoneDepletionPotential'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_lookup_value(MODEL, TERM_ID, impact_assessment, LOOKUPS['emission'])
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    value=value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, True)
+    return _indicator(value)

hestia_earth/models/faostat2018/landTransformationFromCropland100YearAverage.py

@@ -16,7 +16,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-faostatCroplandArea": ""
+    "region-faostatArea": ""
 }
 RETURNS = {
     "Indicator": [{

hestia_earth/models/faostat2018/landTransformationFromCropland20YearAverage.py

@@ -16,7 +16,7 @@ REQUIREMENTS = {
     }
 }
 LOOKUPS = {
-    "region-faostatCroplandArea": ""
+    "region-faostatArea": ""
 }
 RETURNS = {
     "Indicator": [{

hestia_earth/models/faostat2018/utils.py

@@ -62,14 +62,14 @@ def _cropland_split_delta(table_value: str, start_year: int, end_year: int):
 
 
 def get_cropland_ratio(country: str, start_year: int, end_year: int):
-    lookup = download_lookup('region-faostatCroplandArea.csv')
+    lookup = download_lookup('region-faostatArea.csv')
     total_delta = _cropland_split_delta(
         get_table_value(lookup, 'termid', country, column_name('Cropland')), start_year, end_year
     )
 
     # get both values and only return result if we have both
     permanent_delta = _cropland_split_delta(
-        get_table_value(lookup, 'termid', country, column_name('Land under permanent crops')), start_year, end_year
+        get_table_value(lookup, 'termid', country, column_name('Permanent crops')), start_year, end_year
     )
     temporary_delta = _cropland_split_delta(
         get_table_value(lookup, 'termid', country, column_name('Arable land')), start_year, end_year

hestia_earth/models/geospatialDatabase/clayContent.py

@@ -1,4 +1,5 @@
 from hestia_earth.schema import MeasurementMethodClassification
+from hestia_earth.utils.tools import non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.blank_node import has_original_by_ids
@@ -29,37 +30,63 @@ REQUIREMENTS = {
 RETURNS = {
     "Measurement": [{
         "value": "",
-        "depthUpper": "0",
-        "depthLower": "30",
+        "depthUpper": "",
+        "depthLower": "",
         "methodClassification": "geospatial dataset"
     }]
 }
 TERM_ID = 'clayContent'
-EE_PARAMS = {
-    'collection': 'T_CLAY',
-    'ee_type': 'raster',
-    'reducer': 'mean'
-}
-BIBLIO_TITLE = 'Harmonized World Soil Database Version 1.2. Food and Agriculture Organization of the United Nations (FAO).'  # noqa: E501
+EE_PARAMS = [
+    {
+        'collection': 'T_CLAY_v2_depth_1',
+        'ee_type': 'raster',
+        'reducer': 'mean',
+        'depthUpper': 0,
+        'depthLower': 20
+    },
+    {
+        'collection': 'T_CLAY_v2_depth_2',
+        'ee_type': 'raster',
+        'reducer': 'mean',
+        'depthUpper': 20,
+        'depthLower': 40
+    },
+    {
+        'collection': 'T_CLAY_v2_depth_3',
+        'ee_type': 'raster',
+        'reducer': 'mean',
+        'depthUpper': 40,
+        'depthLower': 60
+    },
+    {
+        'collection': 'T_CLAY_v2_depth_4',
+        'ee_type': 'raster',
+        'reducer': 'mean',
+        'depthUpper': 60,
+        'depthLower': 80
+    }
+]
+BIBLIO_TITLE = 'Harmonized World Soil Database Version 2.0.'
 
 
-def _measurement(site: dict, value: int):
-    measurement = _new_measurement(TERM_ID, None)
+def _measurement(site: dict, value: int, depthUpper: int, depthLower: int):
+    measurement = _new_measurement(TERM_ID)
     measurement['value'] = [value]
-    measurement['depthUpper'] = 0
-    measurement['depthLower'] = 30
+    measurement['depthUpper'] = depthUpper
+    measurement['depthLower'] = depthLower
     measurement['methodClassification'] = MeasurementMethodClassification.GEOSPATIAL_DATASET.value
     return measurement | get_source(site, BIBLIO_TITLE)
 
 
-def _download(site: dict):
-    value = download(TERM_ID, site, EE_PARAMS)
-    return None if value is None else round(value, 2)
+def _run_depths(site: dict, params: dict):
+    value = download(TERM_ID, site, params)
+    return None if value is None else (
+        _measurement(site, round(value, 2), params.get('depthUpper'), params.get('depthLower'))
+    )
 
 
 def _run(site: dict):
-    value = _download(site)
-    return [_measurement(site, value)] if value is not None else []
+    return non_empty_list([_run_depths(site, params) for params in EE_PARAMS])
 
 
 def _should_run(site: dict):

hestia_earth/models/geospatialDatabase/organicCarbonPerKgSoil.py

@@ -1,5 +1,5 @@
 from hestia_earth.schema import MeasurementMethodClassification
-from hestia_earth.utils.tools import safe_parse_float
+from hestia_earth.utils.tools import safe_parse_float, non_empty_list
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.measurement import _new_measurement
@@ -19,37 +19,63 @@ REQUIREMENTS = {
 RETURNS = {
     "Measurement": [{
         "value": "",
-        "depthUpper": "0",
-        "depthLower": "30",
+        "depthUpper": "",
+        "depthLower": "",
         "methodClassification": "geospatial dataset"
     }]
 }
 TERM_ID = 'organicCarbonPerKgSoil'
-EE_PARAMS = {
-    'collection': 'T_OC',
-    'ee_type': 'raster',
-    'reducer': 'mean'
-}
-BIBLIO_TITLE = 'Harmonized World Soil Database Version 1.2. Food and Agriculture Organization of the United Nations (FAO).'  # noqa: E501
+EE_PARAMS = [
+    {
+        'collection': 'T_OC_v2_depth_1',
+        'ee_type': 'raster',
+        'reducer': 'mean',
+        'depthUpper': 0,
+        'depthLower': 20
+    },
+    {
+        'collection': 'T_OC_v2_depth_2',
+        'ee_type': 'raster',
+        'reducer': 'mean',
+        'depthUpper': 20,
+        'depthLower': 40
+    },
+    {
+        'collection': 'T_OC_v2_depth_3',
+        'ee_type': 'raster',
+        'reducer': 'mean',
+        'depthUpper': 40,
+        'depthLower': 60
+    },
+    {
+        'collection': 'T_OC_v2_depth_4',
+        'ee_type': 'raster',
+        'reducer': 'mean',
+        'depthUpper': 60,
+        'depthLower': 80
+    }
+]
+BIBLIO_TITLE = 'Harmonized World Soil Database Version 2.0.'
 
 
-def _measurement(site: dict, value: float):
+def _measurement(site: dict, value: int, depthUpper: int, depthLower: int):
     measurement = _new_measurement(TERM_ID)
     measurement['value'] = [value]
-    measurement['depthUpper'] = 0
-    measurement['depthLower'] = 30
+    measurement['depthUpper'] = depthUpper
+    measurement['depthLower'] = depthLower
     measurement['methodClassification'] = MeasurementMethodClassification.GEOSPATIAL_DATASET.value
     return measurement | get_source(site, BIBLIO_TITLE)
 
 
-def _download(site: dict):
-    value = download(TERM_ID, site, EE_PARAMS)
-    return safe_parse_float(value) * 10 if value is not None else None
+def _run_depths(site: dict, params: dict):
+    value = download(TERM_ID, site, params)
+    return None if value is None else (
+        _measurement(site, safe_parse_float(value) * 10, params.get('depthUpper'), params.get('depthLower'))
+    )
 
 
 def _run(site: dict):
-    value = _download(site)
-    return [_measurement(site, value)] if value is not None else []
+    return non_empty_list([_run_depths(site, params) for params in EE_PARAMS])
 
 
 def _should_run(site: dict):