hestia-earth-models 0.64.12__tar.gz → 0.64.14__tar.gz

hestia_earth_models-0.64.14/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.1
+Name: hestia_earth_models
+Version: 0.64.14
+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
+Author-email: guillaumeroyer.mail@gmail.com
+License: GPL
+Platform: UNKNOWN
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3.6
+Description-Content-Type: text/markdown
+Provides-Extra: spatial
+License-File: LICENSE
+
+# HESTIA Engine Models
+
+[![Pipeline Status](https://gitlab.com/hestia-earth/hestia-engine-models/badges/master/pipeline.svg)](https://gitlab.com/hestia-earth/hestia-engine-models/commits/master)
+[![Coverage Report](https://gitlab.com/hestia-earth/hestia-engine-models/badges/master/coverage.svg)](https://gitlab.com/hestia-earth/hestia-engine-models/commits/master)
+
+HESTIA's set of models for running calculations or retrieving data using external datasets and internal lookups.
+
+## Documentation
+
+Documentation for every model can be found in the [HESTIA API Documentation](https://hestia.earth/docs/#hestia-calculation-models).
+
+## Install
+
+1. Install python `3` (we recommend using python `3.6` minimum)
+2. Install the module:
+```bash
+pip install hestia_earth.models
+```
+3. Set the following environment variables:
+```
+API_URL=https://api.hestia.earth
+WEB_URL=https://hestia.earth
+```
+
+### Usage
+
+```python
+from hestia_earth.models.pooreNemecek2018 import run
+
+# cycle is a JSONLD node Cycle
+run('no3ToGroundwaterSoilFlux', cycle_data)
+```
+
+Additionally, to reduce the number of queries to the HESTIA API and run the models faster, prefetching can be enabled:
+```python
+from hestia_earth.models.preload_requests import enable_preload
+
+enable_preload()
+```
+
+### Using Spatial Models
+
+We have models that can gap-fill geographical information on a `Site`. If you want to use these models:
+1. Install the library: `pip install hestia_earth.earth_engine`
+2. Follow the [Getting Started instructions](https://gitlab.com/hestia-earth/hestia-earth-engine#getting-started).
+
+### Using the ecoinventV3 model
+
+ecoinvent is a consistent, transparent, and well validated life cycle inventory database.
+We use ecoinvent data to ascertain the environmental impacts of activities that occur outside of our system boundary, for example data on the environmental impacts of extracting oil and producing diesel, or the impacts of manufacturing plastics.
+
+The `ecoinventV3` model requires a valid [license](https://ecoinvent.org/offerings/licences/) to run. We are currently working on a way to enable users of this code with a valid ecoinvent licence to run these models themselves, but for now, these models are only available on the public platform.
+
+

hestia_earth_models-0.64.14/hestia_earth/models/aware/scarcityWeightedWaterUse.py

@@ -0,0 +1,117 @@
+"""
+This model calculates the scarcity weighted water use based on the geospatial AWARE model
+(see UNEP (2016); Boulay et al (2016); Boulay et al (2020); EC-JRC (2017)).
+"""
+from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.lookup import download_lookup, _get_single_table_value, column_name, get_table_value
+from hestia_earth.utils.tools import safe_parse_float
+
+from hestia_earth.models.log import logRequirements, debugMissingLookup, logShouldRun
+from hestia_earth.models.utils import sum_values, multiply_values
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.impact_assessment import (
+    convert_value_from_cycle, emission_value, get_product, get_site, get_region_id
+)
+from hestia_earth.models.utils.input import sum_input_impacts
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "site": {
+            "@type": "Site",
+            "or": {
+                "awareWaterBasinId": "",
+                "country": {"@type": "Term", "termType": "region"}
+            }
+        },
+        "optional": {
+            "emissionsResourceUse": [{
+                "@type": "Indicator",
+                "term.@id": "freshwaterWithdrawalsDuringCycle",
+                "value": ""
+            }]
+        }
+    }
+}
+RETURNS = {
+    "Indicator": [{
+        "value": ""
+    }]
+}
+LOOKUPS = {
+    "@doc": "Different lookup files are used depending on the situation",
+    "awareWaterBasinId": "using `awareWaterBasinId` and `YR_IRRI` (for `cropland`, `glass or high accessible cover`, or `permanent pasture`) or `YR_NONIRRI`",  # noqa: E501
+    "region-aware-factors": "using `region` and `YR_IRRI` (for `cropland`, `glass or high accessible cover` or `permanent pasture`) or `YR_NONIRRI`"  # noqa: E501
+}
+TERM_ID = 'scarcityWeightedWaterUse'
+AWARE_KEY = 'awareWaterBasinId'
+IRRIGATED_SITE_TYPES = [
+    SiteSiteType.CROPLAND.value,
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value,
+    SiteSiteType.PERMANENT_PASTURE.value
+]
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _get_factor_from_basinId(site: dict, aware_id: str):
+    lookup_col = 'YR_IRRI' if site.get('siteType') in IRRIGATED_SITE_TYPES else 'YR_NONIRRI'
+    value = _get_single_table_value(
+        download_lookup(f"{AWARE_KEY}.csv"), column_name(AWARE_KEY), int(aware_id), column_name(lookup_col)
+    )
+    debugMissingLookup(f"{AWARE_KEY}.csv", AWARE_KEY, aware_id, lookup_col, value, model=MODEL, term=TERM_ID)
+    return safe_parse_float(value, None)
+
+
+def _get_factor_from_region(impact_assessment: dict, site: dict):
+    region_id = get_region_id(impact_assessment)
+    site_type = site.get('siteType')
+    lookup_name = 'region-aware-factors.csv'
+    lookup = download_lookup(lookup_name)
+    lookup_suffix = 'unspecified' if not site_type else ('irri' if site_type in IRRIGATED_SITE_TYPES else 'non_irri')
+    column = f"Agg_CF_{lookup_suffix}"
+    value = get_table_value(lookup, 'termid', region_id, column_name(column))
+    debugMissingLookup(lookup_name, 'termid', region_id, column, value, model=MODEL, term=TERM_ID)
+    return safe_parse_float(value, None)
+
+
+def _run(impact_assessment: dict):
+    cycle = impact_assessment.get('cycle', {})
+    product = get_product(impact_assessment)
+    fresh_water = emission_value(impact_assessment, 'freshwaterWithdrawalsDuringCycle')
+    site = get_site(impact_assessment)
+    aware_id = site.get(AWARE_KEY)
+    factor = (
+        _get_factor_from_basinId(site, aware_id) if aware_id else None
+    ) or _get_factor_from_region(impact_assessment, site)
+    inputs_value = convert_value_from_cycle(
+        product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
+    )
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    fresh_water=fresh_water,
+                    aware_id=aware_id,
+                    factor=factor,
+                    inputs_value=inputs_value)
+
+    value = sum_values([
+        multiply_values([fresh_water, factor]),
+        inputs_value
+    ])
+    return _indicator(value) if value is not None else None
+
+
+def _should_run(impact_assessment: dict):
+    site = get_site(impact_assessment)
+    # does not run without a site as data is geospatial
+    should_run = all([site])
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(impact_assessment: dict):
+    return _run(impact_assessment) if _should_run(impact_assessment) else None

hestia_earth_models-0.64.14/hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandOccupation.py

@@ -0,0 +1,98 @@
+from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils import sum_values, multiply_values
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.impact_assessment import convert_value_from_cycle, get_product, get_site
+from hestia_earth.models.utils.cycle import land_occupation_per_kg
+from hestia_earth.models.utils.input import sum_input_impacts
+from .utils import get_region_factor
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "site": {
+            "@type": "Site",
+            "siteType": "",
+            "or": {
+                "ecoregion": "",
+                "country": {"@type": "Term", "termType": "region"}
+            }
+        },
+        "cycle": {
+            "@type": "Cycle",
+            "products": [{
+                "@type": "Product",
+                "primary": "True",
+                "value": "> 0",
+                "economicValueShare": "> 0"
+            }],
+            "or": [
+                {
+                    "@doc": "if the [cycle.functionalUnit](https://hestia.earth/schema/Cycle#functionalUnit) = 1 ha, additional properties are required",  # noqa: E501
+                    "cycleDuration": "",
+                    "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
+                },
+                {
+                    "@doc": "for plantations, additional properties are required",
+                    "practices": [
+                        {"@type": "Practice", "value": "", "term.@id": "nurseryDensity"},
+                        {"@type": "Practice", "value": "", "term.@id": "nurseryDuration"},
+                        {"@type": "Practice", "value": "", "term.@id": "plantationProductiveLifespan"},
+                        {"@type": "Practice", "value": "", "term.@id": "plantationDensity"},
+                        {"@type": "Practice", "value": "", "term.@id": "plantationLifespan"},
+                        {"@type": "Practice", "value": "", "term.@id": "rotationDuration"}
+                    ]
+                }
+            ]
+        }
+    }
+}
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+LOOKUPS = {
+    "@doc": "Different lookup files are used depending on the situation",
+    "ecoregion-siteType-LandOccupationChaudaryBrooks2018CF": "using `ecoregion`",
+    "region-siteType-LandOccupationChaudaryBrooks2018CF": "using `country`"
+}
+TERM_ID = 'damageToTerrestrialEcosystemsLandOccupation'
+LOOKUP_SUFFIX = 'LandOccupationChaudaryBrooks2018CF'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(impact_assessment: dict):
+    cycle = impact_assessment.get('cycle', {})
+    product = get_product(impact_assessment)
+    site = get_site(impact_assessment)
+    land_occupation_m2_kg = land_occupation_per_kg(MODEL, TERM_ID, cycle, site, product)
+    factor = get_region_factor(TERM_ID, impact_assessment, LOOKUP_SUFFIX, 'medium_intensity')
+    inputs_value = convert_value_from_cycle(
+        product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
+    )
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    landOccupation=land_occupation_m2_kg,
+                    factor=factor,
+                    inputs_value=inputs_value)
+    value = sum_values([
+        multiply_values([land_occupation_m2_kg, factor]),
+        inputs_value
+    ])
+    return _indicator(value) if value is not None else None
+
+
+def _should_run(impact_assessment: dict):
+    site = get_site(impact_assessment)
+    # does not run without a site as data is geospatial
+    should_run = all([site])
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(impact_assessment: dict):
+    return _run(impact_assessment) if _should_run(impact_assessment) else None

hestia_earth_models-0.64.14/hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsLandTransformation.py

@@ -0,0 +1,96 @@
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.utils import sum_values, multiply_values
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.impact_assessment import (
+    convert_value_from_cycle, emission_value, get_product, get_site
+)
+from hestia_earth.models.utils.input import sum_input_impacts
+from .utils import get_region_factor
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "site": {
+            "@type": "Site",
+            "siteType": "",
+            "or": {
+                "ecoregion": "",
+                "country": {"@type": "Term", "termType": "region"}
+            }
+        },
+        "cycle": {
+            "@type": "Cycle",
+            "products": [{
+                "@type": "Product",
+                "primary": "True",
+                "value": "> 0",
+                "economicValueShare": "> 0"
+            }]
+        },
+        "optional": {
+            "emissionsResourceUse": [
+                {"@type": "Indicator", "value": "", "term.@id": "landTransformationFromForest20YearAverageDuringCycle"},
+                {"@type": "Indicator", "value": "", "term.@id": "landTransformationFromOtherNaturalVegetation20YearAverageDuringCycle"}  # noqa: E501
+            ]
+        }
+    }
+}
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+LOOKUPS = {
+    "@doc": "Different lookup files are used depending on the situation",
+    "ecoregion-siteType-LandTransformationChaudaryBrooks2018CF": "using `ecoregion`",
+    "region-siteType-LandTransformationChaudaryBrooks2018CF": "using `country`"
+}
+TERM_ID = 'damageToTerrestrialEcosystemsLandTransformation'
+LOOKUP_SUFFIX = 'LandTransformationChaudaryBrooks2018CF'
+TRANSFORMATION_TERM_IDS = [
+    'landTransformationFromForest20YearAverageDuringCycle',
+    'landTransformationFromOtherNaturalVegetation20YearAverageDuringCycle'
+]
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _value(impact_assessment: dict, term_id: str):
+    value = emission_value(impact_assessment, term_id)
+    debugValues(impact_assessment, model=MODEL, term=TERM_ID, node=term_id, value=value, coefficient=1)
+    return value
+
+
+def _run(impact_assessment: dict):
+    cycle = impact_assessment.get('cycle', {})
+    product = get_product(impact_assessment)
+    landTransformation = sum_values([_value(impact_assessment, term_id) for term_id in TRANSFORMATION_TERM_IDS])
+    region_factor = get_region_factor(TERM_ID, impact_assessment, LOOKUP_SUFFIX, 'medium_intensity')
+    inputs_value = convert_value_from_cycle(
+        product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
+    )
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    landTransformation=landTransformation,
+                    region_factor=region_factor,
+                    inputs_value=inputs_value)
+    value = sum_values([
+        multiply_values([landTransformation, region_factor]),
+        inputs_value
+    ])
+    return _indicator(value) if value is not None else None
+
+
+def _should_run(impact_assessment: dict):
+    site = get_site(impact_assessment)
+    # does not run without a site as data is geospatial
+    should_run = all([site])
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run
+
+
+def run(impact_assessment: dict):
+    return _run(impact_assessment) if _should_run(impact_assessment) else None

hestia_earth_models-0.64.14/hestia_earth/models/chaudharyBrooks2018/damageToTerrestrialEcosystemsTotalLandUseEffects.py

@@ -0,0 +1,67 @@
+from hestia_earth.utils.tools import list_sum, safe_parse_float, non_empty_list
+from hestia_earth.utils.model import find_term_match
+
+from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
+from hestia_earth.models.utils import sum_values
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.impact_assessment import convert_value_from_cycle, get_product
+from hestia_earth.models.utils.input import sum_input_impacts
+from .damageToTerrestrialEcosystemsLandOccupation import TERM_ID as TERM_ID_1
+from .damageToTerrestrialEcosystemsLandTransformation import TERM_ID as TERM_ID_2
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "cycle": {
+            "@type": "Cycle",
+            "products": [{
+                "@type": "Product",
+                "primary": "True",
+                "value": "> 0",
+                "economicValueShare": "> 0"
+            }]
+        },
+        "impacts": [
+            {"@type": "Indicator", "value": "", "term.@id": "damageToTerrestrialEcosystemsLandOccupation"},
+            {"@type": "Indicator", "value": "", "term.@id": "damageToTerrestrialEcosystemsLandTransformation"}
+        ]
+    }
+}
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+TERM_ID = 'damageToTerrestrialEcosystemsTotalLandUseEffects'
+BIODIVERSITY_TERM_IDS = [TERM_ID_1, TERM_ID_2]
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def impact_value(impact_assessment: dict, term_id: str):
+    impact = find_term_match(impact_assessment.get('impacts', []), term_id)
+    value = impact.get('value')
+    value = safe_parse_float(value, None)
+    debugValues(impact, model=MODEL, term=TERM_ID, node=term_id, value=value, coefficient=1)
+    return value
+
+
+def run(impact_assessment: dict):
+    landUseEffects = list_sum(non_empty_list(
+        [impact_value(impact_assessment, term_id) for term_id in BIODIVERSITY_TERM_IDS]
+    ), None)
+    cycle = impact_assessment.get('cycle', {})
+    product = get_product(impact_assessment)
+    inputs_value = convert_value_from_cycle(
+        product, sum_input_impacts(cycle.get('inputs', []), TERM_ID), model=MODEL, term_id=TERM_ID
+    )
+    value = sum_values([landUseEffects, inputs_value])
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    landUseEffects=landUseEffects,
+                    inputs_value=inputs_value)
+    logShouldRun(impact_assessment, MODEL, TERM_ID, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth_models-0.64.14/hestia_earth/models/cml2001Baseline/eutrophicationPotentialExcludingFate.py

@@ -0,0 +1,33 @@
+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_emission_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator", "value": "", "term.termType": "emission"}]
+    }
+}
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+LOOKUPS = {
+    "emission": "po4-EqEutrophicationExcludingFateCml2001Baseline"
+}
+TERM_ID = 'eutrophicationPotentialExcludingFate'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_emission_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, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth_models-0.64.14/hestia_earth/models/cml2001Baseline/terrestrialAcidificationPotentialIncludingFateAverageEurope.py

@@ -0,0 +1,33 @@
+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_emission_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator", "value": "", "term.termType": "emission"}]
+    }
+}
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+LOOKUPS = {
+    "emission": "so2EqTerrestrialAcidificationIncludingFateAverageEuropeCml2001Baseline"
+}
+TERM_ID = 'terrestrialAcidificationPotentialIncludingFateAverageEurope'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_emission_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, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth_models-0.64.14/hestia_earth/models/cml2001NonBaseline/eutrophicationPotentialIncludingFateAverageEurope.py

@@ -0,0 +1,33 @@
+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_emission_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator", "value": "", "term.termType": "emission"}]
+    }
+}
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+LOOKUPS = {
+    "emission": "noxeqEutrophicationIncludingFateAverageEuropeCml2001Non-Baseline"
+}
+TERM_ID = 'eutrophicationPotentialIncludingFateAverageEurope'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_emission_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, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth_models-0.64.14/hestia_earth/models/cml2001NonBaseline/terrestrialAcidificationPotentialExcludingFate.py

@@ -0,0 +1,33 @@
+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_emission_lookup_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{"@type": "Indicator", "value": "", "term.termType": "emission"}]
+    }
+}
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+LOOKUPS = {
+    "emission": "so2EqTerrestrialAcidificationExcludingFateCml2001Non-Baseline"
+}
+TERM_ID = 'terrestrialAcidificationPotentialExcludingFate'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def run(impact_assessment: dict):
+    value = impact_emission_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, value is not None)
+    return _indicator(value) if value is not None else None

hestia_earth_models-0.64.14/hestia_earth/models/cycle/completeness/seed.py

@@ -0,0 +1,58 @@
+"""
+Completeness Seed
+
+This model checks if we have the requirements below and updates the
+[Data Completeness](https://hestia.earth/schema/Completeness#seed) value.
+"""
+from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.model import find_term_match, find_primary_product
+
+from hestia_earth.models.log import logRequirements
+from hestia_earth.models.utils.crop import is_plantation
+from . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "completeness.seed": "False",
+        "inputs": [
+            {"@type": "Input", "value": "", "term.@id": ["seed", "saplingsDepreciatedAmountPerCycle"]}
+        ],
+        "site": {
+            "@type": "Site",
+            "siteType": ["cropland", "glass or high accessible cover"]
+        }
+    }
+}
+RETURNS = {
+    "Completeness": {
+        "seed": ""
+    }
+}
+LOOKUPS = {
+    "crop": "isPlantation"
+}
+MODEL_KEY = 'seed'
+ALLOWED_SITE_TYPES = [
+    SiteSiteType.CROPLAND.value,
+    SiteSiteType.GLASS_OR_HIGH_ACCESSIBLE_COVER.value
+]
+
+
+def run(cycle: dict):
+    site_type = cycle.get('site', {}).get('siteType')
+    site_type_allowed = site_type in ALLOWED_SITE_TYPES
+
+    has_seed = find_term_match(cycle.get('inputs', []), 'seed', None)
+
+    product = find_primary_product(cycle) or {}
+    term_id = product.get('term', {}).get('@id')
+    has_saplingsDepreciatedAmountPerCycle = find_term_match(cycle.get('inputs', []),
+                                                            'saplingsDepreciatedAmountPerCycle',
+                                                            None) and is_plantation(MODEL, None, term_id)
+
+    logRequirements(cycle, model=MODEL, term=None, key=MODEL_KEY,
+                    site_type_allowed=site_type_allowed,
+                    has_seed=has_seed,
+                    has_saplingsDepreciatedAmountPerCycle=has_saplingsDepreciatedAmountPerCycle)
+
+    return all([site_type_allowed, has_seed or has_saplingsDepreciatedAmountPerCycle])