hestia-earth-models 0.64.0__py3-none-any.whl → 0.64.2__py3-none-any.whl

hestia_earth/models/cycle/concentrateFeed.py

@@ -15,7 +15,9 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "inputs": [{"@type": "Practice", "value": "", "term.termType": ["crop", "animalProduct"]}],
+        "inputs": [{
+            "@type": "Practice", "value": "", "term.termType": ["crop", "forage", "processedFood", "animalProduct"]
+        }],
         "products": [
             {
                 "@type": "Product",
@@ -34,10 +36,17 @@ RETURNS = {
 }
 LOOKUPS = {
     "crop-property": "crudeProteinContent",
+    "forage-property": "crudeProteinContent",
+    "processedFood-property": "crudeProteinContent",
     "property": "commonToSupplementInAnimalFeed"
 }
 TERM_ID = 'concentrateFeedBlend,concentrateFeedUnspecified,feedMix'
-INPUT_TERM_TYPES = [TermTermType.CROP.value, TermTermType.ANIMALPRODUCT.value]
+INPUT_TERM_TYPES = [
+    TermTermType.CROP.value,
+    TermTermType.FORAGE.value,
+    TermTermType.PROCESSEDFOOD.value,
+    TermTermType.ANIMALPRODUCT.value
+]
 
 
 def _property(term_id: str, value: float):
@@ -60,7 +69,7 @@ def _weighted_value(values: list):
 
 def _calculate_value(cycle: dict, product: dict, inputs: list, property_id: str, values: list):
     values = [(prop_value, value) for id, prop_value, value in values if value and prop_value]
-    ratio_inputs_with_props = len(inputs) / len(values) if len(inputs) and len(values) else 0
+    ratio_inputs_with_props = len(values) / len(inputs) if len(inputs) and len(values) else 0
     min_ratio = _min_ratio(property_id)
 
     term_id = product.get('term', {}).get('@id')

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/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/ipcc2019/ch4ToAirAquacultureSystems.py

@@ -0,0 +1,96 @@
+from hestia_earth.schema import EmissionMethodTier, EmissionStatsDefinition, CycleFunctionalUnit
+from hestia_earth.utils.model import find_term_match
+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.blank_node import get_lookup_value
+from hestia_earth.models.utils.emission import _new_emission
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "cycleDuration": "",
+        "functionalUnit": "relative",
+        "site": {
+            "@type": "Site",
+            "area": "",
+            "measurements": [{
+                "@type": "Measurement",
+                "term.@id": [
+                    "salineWater",
+                    "brackishWater",
+                    "freshWater"
+                ]
+            }]
+        }
+    }
+}
+LOOKUPS = {
+    "measurement": "IPCC_2019_CH4_aquaculture_EF"
+}
+RETURNS = {
+    "Emission": [{
+        "value": "",
+        "min": "",
+        "max": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }]
+}
+TERM_ID = 'ch4ToAirAquacultureSystems'
+TIER = EmissionMethodTier.TIER_1.value
+_WATER_TERM_IDS = [
+    'salineWater',
+    'brackishWater',
+    'freshWater'
+]
+
+
+def _emission(value: float, min: float, max: float):
+    emission = _new_emission(TERM_ID, MODEL)
+    emission['value'] = [value]
+    emission['min'] = [min]
+    emission['max'] = [max]
+    emission['statsDefinition'] = EmissionStatsDefinition.MODELLED.value
+    emission['methodTier'] = TIER
+    return emission
+
+
+def _find_measurement(site: dict):
+    measurements = non_empty_list([
+        find_term_match(site.get('measurements', []), term_id, None) for term_id in _WATER_TERM_IDS
+    ])
+    return measurements[0] if measurements else None
+
+
+def _run(cycle: dict):
+    cycle_duration = cycle.get('cycleDuration')
+    site = cycle.get('site', {})
+    site_area = site.get('area')
+    water_term = _find_measurement(site).get('term', {})
+    factor_value = safe_parse_float(get_lookup_value(water_term, LOOKUPS.get('measurement')))
+    factor_min = safe_parse_float(get_lookup_value(water_term, f"{LOOKUPS.get('measurement')}-min"))
+    factor_max = safe_parse_float(get_lookup_value(water_term, f"{LOOKUPS.get('measurement')}-max"))
+    ratio = site_area * cycle_duration / 365
+    return [_emission(ratio * factor_value, ratio * factor_min, ratio * factor_max)]
+
+
+def _should_run(cycle: dict):
+    cycle_duration = cycle.get('cycleDuration')
+    is_relative = cycle.get('functionalUnit') == CycleFunctionalUnit.RELATIVE.value
+    site = cycle.get('site', {})
+    site_area = site.get('area')
+    has_water_type = _find_measurement(site) is not None
+
+    logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    cycle_duration=cycle_duration,
+                    is_relative=is_relative,
+                    site_area=site_area,
+                    has_water_type=has_water_type)
+
+    should_run = all([cycle_duration, is_relative, site_area, has_water_type])
+    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
+    return should_run
+
+
+def run(cycle: dict): return _run(cycle) if _should_run(cycle) else []