hestia-earth-models 0.69.1__py3-none-any.whl → 0.70.1__py3-none-any.whl

hestia_earth/models/pooreNemecek2018/excretaKgN.py

@@ -52,7 +52,7 @@ REQUIREMENTS = {
             }
         ],
         "optional": {
-            "practices": [{"@type": "Practice", "term.termType": "systemn"}]
+            "practices": [{"@type": "Practice", "term.termType": "system"}]
         }
     }
 }

hestia_earth/models/pooreNemecek2018/freshwaterWithdrawalsDuringCycle.py

@@ -13,7 +13,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "product": {"@type": "Product", "term": {"@type": "Term"}},
+        "product": {"@type": "Product"},
         "cycle": {
             "@type": "Cycle",
             "products": [{

hestia_earth/models/pooreNemecek2018/utils.py

@@ -31,12 +31,18 @@ def run_products_average(cycle: dict, term_id: str, get_value_func):
     return list_average(values) if should_run else None
 
 
+def _excreta_product_id(data: str, term_id):
+    value = extract_grouped_data(data, term_id) or ''
+    return value.split('|')[0] if '|' in value else value
+
+
 def get_excreta_product_with_ratio(cycle: dict, lookup: str, **log_args):
     product = find_primary_product(cycle) or {}
 
     data = get_lookup_value(product.get('term'), lookup, model=MODEL, **log_args)
 
-    default_product_id = extract_grouped_data(data, 'default')
+    # TODO: handle multiple products delimited by `|`
+    default_product_id = _excreta_product_id(data, 'default')
 
     # find matching practices and assign a ratio for each
     # if no matches, use default id with 100% ratio
@@ -44,7 +50,7 @@ def get_excreta_product_with_ratio(cycle: dict, lookup: str, **log_args):
     practices = [
         {
             'id': practice.get('term', {}).get('@id'),
-            'product-id': extract_grouped_data(data, practice.get('term', {}).get('@id')) or default_product_id,
+            'product-id': _excreta_product_id(data, practice.get('term', {}).get('@id')) or default_product_id,
             'value': list_sum(practice.get('value'))
         }
         for practice in practices
@@ -80,7 +86,10 @@ def get_excreta_product_with_ratio(cycle: dict, lookup: str, **log_args):
         ) | {'value': [practice.get('ratio')]}
         for product, practice in practices_with_products
         # ignore matching products with an existing value
-        if not product or not product.get('value', [])
+        if all([
+            not product or not product.get('value', []),
+            product or practice.get('product-id')
+        ])
     ] if practices_with_products else None
 
     return products or non_empty_list([{

hestia_earth/models/schmidt2007/ch4ToAirWasteTreatment.py

@@ -8,12 +8,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "or": {
-            "product": [
-                {"@type": "Product", "value": "", "term.termType": "waste"}
-            ],
-            "completeness.waste": ""
-        }
+        "products": [{"@type": "Product", "value": ""}]
     }
 }
 RETURNS = {

hestia_earth/models/schmidt2007/h2SToAirWasteTreatment.py

@@ -8,12 +8,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "or": {
-            "product": [
-                {"@type": "Product", "value": "", "term.termType": "waste"}
-            ],
-            "completeness.waste": ""
-        }
+        "products": [{"@type": "Product", "value": ""}]
     }
 }
 RETURNS = {

hestia_earth/models/schmidt2007/n2OToAirWasteTreatmentDirect.py

@@ -8,12 +8,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "or": {
-            "product": [
-                {"@type": "Product", "value": "", "term.termType": "waste"}
-            ],
-            "completeness.waste": ""
-        }
+        "products": [{"@type": "Product", "value": ""}]
     }
 }
 RETURNS = {

hestia_earth/models/schmidt2007/nh3ToAirWasteTreatment.py

@@ -8,12 +8,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "or": {
-            "product": [
-                {"@type": "Product", "value": "", "term.termType": "waste"}
-            ],
-            "completeness.waste": ""
-        }
+        "products": [{"@type": "Product", "value": ""}]
     }
 }
 RETURNS = {

hestia_earth/models/site/pre_checks/country.py

@@ -1,4 +1,6 @@
-from hestia_earth.utils.api import download_hestia
+from hestia_earth.schema import TermTermType
 
+from hestia_earth.models.utils.term import download_term
 
-def run(site: dict): return site | {'country': download_hestia(site.get('country', {}).get('@id'))}
+
+def run(site: dict): return site | {'country': download_term(site.get('country', {}).get('@id'), TermTermType.REGION)}

hestia_earth/models/transformation/input/excreta.py

@@ -28,7 +28,7 @@ RETURNS = {
             "@type": "Input",
             "term.termType": "excreta",
             "value": "",
-            "fromCycle": "true"
+            "fromCycle": "True"
         }]
     }]
 }

hestia_earth/models/utils/aggregated.py

@@ -10,7 +10,6 @@ from . import current_year
 from .cycle import is_organic
 
 MODEL_KEY = 'impactAssessment'
-MATCH_WORLD_QUERY = {'match': {'country.name.keyword': {'query': 'World', 'boost': 1}}}
 
 
 def aggregated_end_date(end_date: str):
@@ -18,26 +17,25 @@ def aggregated_end_date(end_date: str):
     return min([round(math.floor(year / 10) * 10) + 9, current_year()])
 
 
-def _match_region_country(region: dict, country: dict):
-    region_name = region.get('name') if region else None
+def _match_country_query(name: str = 'World', boost: int = 1):
+    return {'match': {'country.name.keyword': {'query': name, 'boost': boost}}}
+
+
+def _match_country(country: dict):
     country_name = country.get('name') if country else None
     return {
         'bool': {
             # either get with exact country, or default to global
             'should': non_empty_list([
-                (
-                    {'match': {'region.name.keyword': {'query': region_name, 'boost': 1000}}} if region_name else
-                    {'match': {'country.name.keyword': {'query': country_name, 'boost': 1000}}} if country_name else
-                    None
-                ),
-                MATCH_WORLD_QUERY
+                _match_country_query(name=country_name, boost=1000) if country_name else None,
+                _match_country_query()
             ]),
             'minimum_should_match': 1
         }
     }
 
 
-def find_closest_impact(cycle: dict, end_date: str, term: dict, region: dict, country: dict, must_queries=[]):
+def find_closest_impact(cycle: dict, end_date: str, term: dict, country: dict, must_queries=[]):
     query = {
         'bool': {
             'must': non_empty_list([
@@ -54,7 +52,7 @@ def find_closest_impact(cycle: dict, end_date: str, term: dict, region: dict, co
                         'minimum_should_match': 1
                     }
                 } if term else None,
-                _match_region_country(region, country)
+                _match_country(country)
             ]) + must_queries,
             'should': [
                 # if the Cycle is organic, we can try to match organic aggregate first
@@ -76,14 +74,13 @@ def _link_input_to_impact(model: str, cycle: dict, date: int):
     def run(input: dict):
         term = input.get('term', {})
         term_id = term.get('@id')
-        region = input.get('region')
         country = input.get('country')
-        impact = find_closest_impact(cycle, date, term, region, country)
+        impact = find_closest_impact(cycle, date, term, country)
 
-        search_by_region_id = (region or country or {}).get('@id') or 'region-world'
+        search_by_country_id = (country or {}).get('@id') or 'region-world'
         debugValues(cycle, model=model, term=term_id, key=MODEL_KEY,
                     search_by_input_term_id=term_id,
-                    search_by_region_id=search_by_region_id,
+                    search_by_country_id=search_by_country_id,
                     search_by_end_date=str(date),
                     impact_assessment_id_found=(impact or {}).get('@id'))
 

hestia_earth/models/utils/background_emissions.py

@@ -0,0 +1,52 @@
+from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import flatten
+
+from . import is_from_model
+
+
+def _animal_inputs(animal: dict):
+    inputs = animal.get('inputs', [])
+    return [(input | {'animal': animal.get('term', {})}) for input in inputs]
+
+
+def _should_run_input(products: list):
+    def should_run(input: dict):
+        return all([
+            # make sure Input is not a Product as well or we might double-count emissions
+            find_term_match(products, input.get('term', {}).get('@id'), None) is None,
+            # ignore inputs which are flagged as Product of the Cycle
+            not input.get('fromCycle', False),
+            not input.get('producedInCycle', False)
+        ])
+    return should_run
+
+
+def get_background_inputs(cycle: dict, extra_inputs: list = []):
+    # add all the properties of some Term that inlcude others with the mapping
+    inputs = flatten(
+        cycle.get('inputs', []) +
+        list(map(_animal_inputs, cycle.get('animals', []))) +
+        extra_inputs
+    )
+    return list(filter(_should_run_input(cycle.get('products', [])), inputs))
+
+
+def no_gap_filled_background_emissions(cycle: dict):
+    emissions = cycle.get('emissions', [])
+
+    def check_input(input: dict):
+        input_term_id = input.get('term', {}).get('@id')
+        operation_term_id = input.get('operation', {}).get('@id')
+        animal_term_id = input.get('animal', {}).get('@id')
+
+        return not any([
+            is_from_model(emission)
+            for emission in emissions
+            if all([
+                any([i.get('@id') == input_term_id for i in emission.get('inputs', [])]),
+                emission.get('operation', {}).get('@id') == operation_term_id,
+                emission.get('animal', {}).get('@id') == animal_term_id
+            ])
+        ])
+
+    return check_input

hestia_earth/models/utils/blank_node.py

@@ -27,6 +27,7 @@ from hestia_earth.utils.tools import (
 )
 from hestia_earth.utils.lookup_utils import (
     is_model_siteType_allowed,
+    is_model_product_id_allowed,
     is_siteType_allowed,
     is_product_id_allowed,
     is_product_termType_allowed,
@@ -124,13 +125,16 @@ def _module_term_id(term_id: str, module):
     return getattr(module, 'TERM_ID', term_id_str).split(',')[0]
 
 
-def _run_model_required(model: str, term_id: str, data: dict):
+def _run_model_required(model: str, term_id: str, data: dict, skip_logs: bool = False):
     siteType_allowed = is_model_siteType_allowed(model, term_id, data)
+    product_id_allowed = is_model_product_id_allowed(model, term_id, data)
 
-    run_required = all([siteType_allowed])
-    debugValues(data, model=model, term=term_id,
-                run_required=run_required,
-                siteType_allowed=siteType_allowed)
+    run_required = all([siteType_allowed, product_id_allowed])
+    if not skip_logs:
+        debugValues(data, model=model, term=term_id,
+                    run_required=run_required,
+                    siteType_allowed=siteType_allowed,
+                    product_id_allowed=product_id_allowed)
     return run_required
 
 
@@ -398,9 +402,17 @@ def convert_to_nitrogen(node: dict, model: str, blank_nodes: list, **log_args):
         return value or get_node_property_value(model, input, 'crudeProteinContent', default=0, **log_args) / 6.25
 
     values = [(i, prop_value(i)) for i in blank_nodes]
-    missing_nitrogen_property = [i.get('term', {}).get('@id') for i, p_value in values if not p_value]
+    missing_nitrogen_property = [i.get('term', {}).get('@id') for i, value in values if not value]
 
     debugValues(node, model=model,
+                convertion_details=log_as_table([
+                    {
+                        'id': i.get('term', {}).get('@id'),
+                        'value': list_sum(i.get('value', [])),
+                        'conversion-factor': value
+                    }
+                    for i, value in values
+                ]),
                 missing_nitrogen_property=';'.join(set(missing_nitrogen_property)),
                 **log_args)
 
@@ -1010,6 +1022,7 @@ def group_nodes_by_year(
     nodes: list[dict],
     default_node_duration: int = 1,
     sort_result: bool = True,
+    include_spillovers: bool = False,
     inner_key: Union[Any, None] = None,
     mode: GroupNodesByYearMode = GroupNodesByYearMode.START_AND_END_DATE
 ) -> dict[int, list[dict]]:
@@ -1026,6 +1039,10 @@ def group_nodes_by_year(
         Default duration of a node years if start date is not available, by default 1.
     sort_result : bool, optional
         Flag to sort the result by year, by default True.
+    include_spillovers : bool, optional
+        If grouping by start and end date, flag to determine whether nodes should be included in year groups that they
+        spill-over into. If `False` year groups will not include nodes that overlap with them by less than 30% of a
+        year, unless it is the only year group it overlaps with. By default False.
     inner_key: Any | None
         An optional inner dictionary key for the outputted annualised groups (can be used to merge annualised
         dictionaries together), default value: `None`.
@@ -1066,6 +1083,7 @@ def group_nodes_by_year(
 
             should_run = (
                 mode == GroupNodesByYearMode.DATES
+                or include_spillovers
                 or _validate_time_fraction_dict(
                     time_fraction_dict,
                     is_final_year

hestia_earth/models/utils/impact_assessment.py

@@ -3,7 +3,7 @@ from hestia_earth.schema import TermTermType
 from hestia_earth.utils.model import find_term_match, filter_list_term_type
 from hestia_earth.utils.tools import list_sum, safe_parse_date
 
-from hestia_earth.models.log import debugValues, log_as_table
+from hestia_earth.models.log import debugValues
 from .lookup import all_factor_value, _term_factor_value, _aware_factor_value, fallback_country
 from .product import find_by_product
 from .site import region_level_1_id
@@ -157,22 +157,22 @@ def impact_country_value(
         The impact total value.
     """
     term_type = TermTermType.RESOURCEUSE.value if 'resourceUse' in lookup else TermTermType.EMISSION.value
-    nodes = filter_list_term_type(impact.get('emissionsResourceUse', []), term_type)
+    blank_nodes = filter_list_term_type(impact.get('emissionsResourceUse', []), term_type)
 
     country_id = get_country_id(impact)
     country_id = fallback_country(country_id, [lookup]) if country_fallback else country_id
 
-    values = list(map(_term_factor_value(model, term_id, lookup, country_id, group_key), nodes))
-    debugValues(impact, model=model, term=term_id,
-                values_used=log_as_table(values))
-
-    has_values = len(values) > 0
-    missing_values = set([v.get('id') for v in values if v.get('value') and v.get('coefficient') is None])
-    all_with_factors = not missing_values
-    values = [float((v.get('value') or 0) * (v.get('coefficient') or 0)) for v in values]
-
-    # fail if some factors are missing
-    return None if not all_with_factors else (list_sum(values) if has_values else default_no_values)
+    return all_factor_value(
+        model=model,
+        term_id=term_id,
+        node=impact,
+        lookup_name=lookup,
+        lookup_col=country_id,
+        blank_nodes=blank_nodes,
+        grouped_key=group_key,
+        default_no_values=None,
+        factor_value_func=_term_factor_value
+    )
 
 
 def impact_aware_value(model: str, term_id: str, impact: dict, lookup: str, group_key: str = None) -> float:
@@ -197,14 +197,23 @@ def impact_aware_value(model: str, term_id: str, impact: dict, lookup: str, grou
     int
         The impact total value.
     """
-    nodes = impact.get('emissionsResourceUse', [])
+    blank_nodes = impact.get('emissionsResourceUse', [])
     site = get_site(impact)
     aware_id = site.get('awareWaterBasinId')
     if aware_id is None:
         return None
-    factors = list(map(_aware_factor_value(model, term_id, lookup, aware_id, group_key), nodes))
-    values = [value for value in factors if value is not None]
-    return list_sum(values) if len(values) > 0 else None
+
+    return all_factor_value(
+        model=model,
+        term_id=term_id,
+        node=impact,
+        lookup_name=lookup,
+        lookup_col=aware_id,
+        blank_nodes=blank_nodes,
+        grouped_key=group_key,
+        default_no_values=None,
+        factor_value_func=_aware_factor_value
+    )
 
 
 def impact_endpoint_value(model: str, term_id: str, impact: dict, lookup_col: str) -> float:

hestia_earth/models/utils/lookup.py

@@ -26,7 +26,8 @@ def _factor_value(model: str, term_id: str, lookup_name: str, lookup_col: str, g
         coefficient = get_region_lookup_value(lookup_name, node_term_id, lookup_col, model=model, term=term_id)
         # value is either a number or matching between a model and a value (restrict value to specific model only)
         coefficient = safe_parse_float(
-            extract_grouped_data(coefficient, grouped_data_key), None
+            extract_grouped_data(coefficient, grouped_data_key),
+            default=None
         ) if ':' in str(coefficient) else safe_parse_float(coefficient, None)
         if value is not None and coefficient is not None:
             if model:
@@ -39,43 +40,15 @@ def _factor_value(model: str, term_id: str, lookup_name: str, lookup_col: str, g
     return get_value
 
 
-def all_factor_value(
-    model: str,
-    term_id: str,
-    node: dict,
-    lookup_name: str,
-    lookup_col: str,
-    blank_nodes: List[dict],
-    grouped_key: Optional[str] = None,
-    default_no_values=0
-):
-    values = list(map(_factor_value(model, term_id, lookup_name, lookup_col, grouped_key), blank_nodes))
-
-    has_values = len(values) > 0
-    missing_values = set([v.get('id') for v in values if v.get('value') and v.get('coefficient') is None])
-    all_with_factors = not missing_values
-
-    for missing_value in missing_values:
-        debugMissingLookup(lookup_name, 'termid', missing_value, lookup_col, None, model=model, term=term_id)
-
-    debugValues(node, model=model, term=term_id,
-                all_with_factors=all_with_factors,
-                missing_lookup_factor=';'.join(missing_values),
-                has_values=has_values,
-                values_used=log_as_table(values))
-
-    values = [float((v.get('value') or 0) * (v.get('coefficient') or 0)) for v in values]
-
-    # fail if some factors are missing
-    return None if not all_with_factors else (list_sum(values) if has_values else default_no_values)
-
-
 def _term_factor_value(model: str, term_id: str, lookup_name: str, lookup_term_id: str, group_key: str = None):
     def get_value(data: dict):
         node_term_id = data.get('term', {}).get('@id')
         value = _node_value(data)
         coefficient = get_region_lookup_value(lookup_name, lookup_term_id, node_term_id, model=model, term=term_id)
-        coefficient = safe_parse_float(extract_grouped_data(coefficient, group_key) if group_key else coefficient)
+        coefficient = safe_parse_float(
+            extract_grouped_data(coefficient, group_key) if group_key else coefficient,
+            default=None
+        )
         if value is not None and coefficient is not None:
             debugValues(data, model=model, term=term_id,
                         node=node_term_id,
@@ -90,23 +63,59 @@ def _aware_factor_value(model: str, term_id: str, lookup_name: str, aware_id: st
     lookup_col = column_name('awareWaterBasinId')
 
     def get_value(data: dict):
+        node_term_id = data.get('term', {}).get('@id')
+        value = _node_value(data)
+
         try:
-            node_term_id = data.get('term', {}).get('@id')
-            value = _node_value(data)
             coefficient = _get_single_table_value(lookup, lookup_col, int(aware_id), column_name(node_term_id))
-            coefficient = safe_parse_float(extract_grouped_data(coefficient, group_key)) if group_key else coefficient
+            coefficient = safe_parse_float(
+                extract_grouped_data(coefficient, group_key),
+                default=None
+            ) if group_key else coefficient
             if value is not None and coefficient is not None:
                 debugValues(data, model=model, term=term_id,
                             node=node_term_id,
                             value=value,
                             coefficient=coefficient)
-                return value * coefficient
-            return None
         except ValueError:  # factor does not exist
-            return None
+            coefficient = None
+
+        return {'id': node_term_id, 'value': value, 'coefficient': coefficient}
     return get_value
 
 
+def all_factor_value(
+    model: str,
+    term_id: str,
+    node: dict,
+    lookup_name: str,
+    lookup_col: str,
+    blank_nodes: List[dict],
+    grouped_key: Optional[str] = None,
+    default_no_values=0,
+    factor_value_func=_factor_value
+):
+    values = list(map(factor_value_func(model, term_id, lookup_name, lookup_col, grouped_key), blank_nodes))
+
+    has_values = len(values) > 0
+    missing_values = set([v.get('id') for v in values if v.get('value') and v.get('coefficient') is None])
+    all_with_factors = not missing_values
+
+    for missing_value in missing_values:
+        debugMissingLookup(lookup_name, 'termid', missing_value, lookup_col, None, model=model, term=term_id)
+
+    debugValues(node, model=model, term=term_id,
+                all_with_factors=all_with_factors,
+                missing_lookup_factor=';'.join(missing_values),
+                has_values=has_values,
+                values_used=log_as_table(values))
+
+    values = [float((v.get('value') or 0) * (v.get('coefficient') or 0)) for v in values]
+
+    # fail if some factors are missing
+    return None if not all_with_factors else (list_sum(values) if has_values else default_no_values)
+
+
 def _country_in_lookup(country_id: str):
     def in_lookup(lookup_name: str):
         return (

hestia_earth/models/utils/measurement.py

@@ -10,7 +10,7 @@ from hestia_earth.utils.date import diff_in_days
 
 from . import flatten_args
 from .blank_node import most_relevant_blank_node_by_id
-from .method import include_methodModel
+from .method import include_method
 from .term import download_term, get_lookup_value
 
 
@@ -26,10 +26,10 @@ MEASUREMENT_REDUCE = {
 MEASUREMENT_METHOD_CLASSIFICATIONS = [e.value for e in MeasurementMethodClassification]
 
 
-def _new_measurement(term, model=None):
+def _new_measurement(term, method=None):
     node = {'@type': SchemaType.MEASUREMENT.value}
     node['term'] = linked_node(term if isinstance(term, dict) else download_term(term))
-    return include_methodModel(node, term_id=model)
+    return include_method(node, term_id=method)
 
 
 def measurement_value(measurement: dict, is_larger_unit: bool = False) -> float:

hestia_earth/models/utils/product.py

@@ -153,7 +153,7 @@ def get_animal_produced_nitrogen(model: str, products: list) -> float:
     def product_value(product: dict):
         value = convert_product_to_unit(product, Units.KG_LIVEWEIGHT)
         property = prop_value(product)
-        return value * property / 100 if all([value, property]) else 0
+        return value * property if all([value, property]) else 0
 
     return list_sum(list(map(product_value, products)))
 

hestia_earth/models/utils/source.py

@@ -52,7 +52,8 @@ def _extract(content: str):
 
 def _list_sources():
     dir = pathlib.Path(ROOT_DIR)
-    files = list(dir.rglob('**/*.py'))
+    # ignore current file
+    files = list(filter(lambda f: not str(f).endswith('utils/source.py'), list(dir.rglob('**/*.py'))))
     return list(set(flatten([_extract(open(f, 'r').read().replace('\n', '')) for f in files])))
 
 

hestia_earth/models/utils/term.py

@@ -715,7 +715,7 @@ def get_land_cover_terms():
 
     Returns
     -------
-        List of landCover terms with associated siteTypes.
+        List of landCover terms IDs.
     """
     terms = search({
         "bool": {
@@ -726,3 +726,28 @@ def get_land_cover_terms():
         },
     }, limit=LIMIT, fields=['@id'])
     return list(map(lambda n: n["@id"], terms))
+
+
+def get_ionophore_terms():
+    """
+    Find all `Ionophore` terms from the Glossary: https://hestia.earth/glossary?query=ionophore
+
+    Returns
+    -------
+        List of ionophore term IDs.
+    """
+    terms = search({
+        "bool": {
+            "must": [
+                {"match": {"@type": SchemaType.TERM.value}},
+                {"match_phrase_prefix": {"name": "ionophore"}}
+            ],
+            "should": [
+                {"match": {"termType": TermTermType.FEEDFOODADDITIVE.value}},
+                {"match": {"termType": TermTermType.VETERINARYDRUG.value}},
+
+            ],
+            "minimum_should_match": 1
+        },
+    }, limit=LIMIT, fields=['@id'])
+    return list(map(lambda n: n["@id"], terms))

hestia_earth/models/version.py

@@ -1 +1 @@
-VERSION = '0.69.1'
+VERSION = '0.70.1'

{hestia_earth_models-0.69.1.dist-info → hestia_earth_models-0.70.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.69.1
+Version: 0.70.1
 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
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: hestia-earth-schema==31.*
-Requires-Dist: hestia-earth-utils>=0.14.0
+Requires-Dist: hestia-earth-utils>=0.14.1
 Requires-Dist: python-dateutil>=2.8.1
 Requires-Dist: CurrencyConverter==0.16.8
 Requires-Dist: haversine>=2.7.0