hestia-earth-models 0.65.4__py3-none-any.whl → 0.65.6__py3-none-any.whl

hestia_earth/models/pooreNemecek2018/freshwaterWithdrawalsDuringCycle.py

@@ -66,7 +66,10 @@ def _run(impact_assessment: dict, product: dict, irrigation: float):
     conveyancing = _get_conveyancing_efficiency(impact_assessment, product)
     # convert from m3 to litre
     value = convert_value_from_cycle(
-        product, irrigation / conveyancing * 1000 if irrigation > 0 else 0, model=MODEL, term_id=TERM_ID
+        impact_assessment,
+        product,
+        irrigation / conveyancing * 1000 if irrigation > 0 else 0,
+        model=MODEL, term_id=TERM_ID
     )
     debugValues(impact_assessment, model=MODEL, term=TERM_ID,
                 value=value)

hestia_earth/models/schererPfister2015/nErosionSoilFlux.py

@@ -1,28 +1,36 @@
 from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.measurement import most_relevant_measurement_value
-from .utils import get_pcorr, get_p_ef_c1, get_ef_p_c2, get_practice_factor, get_water, calculate_R, calculate_A
+from .utils import get_pcorr, get_p_ef_c1, get_ef_p_c2, get_practice_factor, get_water_input, calculate_R, calculate_A
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
         "endDate": "",
-        "inputs": [
-            {"@type": "Input", "value": "", "term.termType": "water"}
-        ],
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "> 0", "term.termType": "water"}
+            ],
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {"@type": "Measurement", "value": "> 0", "term.@id": "precipitationAnnual"}
+                ]
+            }
+        },
         "site": {
             "@type": "Site",
             "country": {"@type": "Term", "termType": "region"},
             "measurements": [
-                {"@type": "Measurement", "value": "", "term.@id": "nutrientLossToAquaticEnvironment"},
-                {"@type": "Measurement", "value": "", "term.@id": "heavyWinterPrecipitation"},
-                {"@type": "Measurement", "value": "", "term.@id": "totalNitrogenPerKgSoil"},
-                {"@type": "Measurement", "value": "", "term.@id": "precipitationAnnual"},
-                {"@type": "Measurement", "value": "", "term.@id": "erodibility"},
-                {"@type": "Measurement", "value": "", "term.@id": "slopeLength"},
-                {"@type": "Measurement", "value": "", "term.@id": "slope"}
+                {"@type": "Measurement", "value": "> 0", "term.@id": "nutrientLossToAquaticEnvironment"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "heavyWinterPrecipitation"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "totalNitrogenPerKgSoil"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "erodibility"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "slopeLength"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "slope"}
             ]
         }
     }
@@ -82,7 +90,7 @@ def _should_run(cycle: dict):
     heavy_winter_precipitation = _get_measurement_content('heavyWinterPrecipitation')
 
     precipitation = _get_measurement_content('precipitationAnnual')
-    water = get_water(cycle, precipitation)
+    inputs_water = get_water_input(cycle)
 
     practice_factor = get_practice_factor(TERM_ID, site)
     pcorr = get_pcorr(slope / 100) if slope is not None else None
@@ -92,7 +100,7 @@ def _should_run(cycle: dict):
     list_of_contents_for_A = [
         practice_factor, erodibility, slope_length,
         pcorr, p_ef_c1, ef_p_c2]
-    list_of_contents_for_R = [heavy_winter_precipitation, water]
+    list_of_contents_for_R = [heavy_winter_precipitation, list_sum([(inputs_water or 0)/10, precipitation or 0])]
     list_of_contents_for_value = [nla_environment, soil_nitrogen_content]
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
@@ -104,7 +112,8 @@ def _should_run(cycle: dict):
                     p_ef_c1=p_ef_c1,
                     ef_p_c2=ef_p_c2,
                     heavy_winter_precipitation=heavy_winter_precipitation,
-                    water=water,
+                    inputs_water=inputs_water,
+                    precipitationAnnual=precipitation,
                     nla_environment=nla_environment,
                     soil_nitrogen_content=soil_nitrogen_content)
 

hestia_earth/models/schererPfister2015/pErosionSoilFlux.py

@@ -1,29 +1,36 @@
 from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import debugValues, logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.measurement import most_relevant_measurement_value
-from .utils import get_pcorr, get_p_ef_c1, get_ef_p_c2, get_practice_factor, get_water, calculate_R, calculate_A
+from .utils import get_pcorr, get_p_ef_c1, get_ef_p_c2, get_practice_factor, get_water_input, calculate_R, calculate_A
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
         "endDate": "",
-        "inputs": [
-            {"@type": "Input", "value": "", "term.termType": "water"}
-        ],
+        "or": {
+            "inputs": [
+                {"@type": "Input", "value": "> 0", "term.termType": "water"}
+            ],
+            "site": {
+                "@type": "Site",
+                "measurements": [
+                    {"@type": "Measurement", "value": "> 0", "term.@id": "precipitationAnnual"}
+                ]
+            }
+        },
         "site": {
             "@type": "Site",
             "country": {"@type": "Term", "termType": "region"},
             "measurements": [
-                {"@type": "Measurement", "value": "", "term.@id": "nutrientLossToAquaticEnvironment"},
-                {"@type": "Measurement", "value": "", "term.@id": "heavyWinterPrecipitation"},
-                {"@type": "Measurement", "value": "", "term.@id": "totalPhosphorusPerKgSoil"},
-                {"@type": "Measurement", "value": "", "term.@id": "totalNitrogenPerKgSoil"},
-                {"@type": "Measurement", "value": "", "term.@id": "precipitationAnnual"},
-                {"@type": "Measurement", "value": "", "term.@id": "erodibility"},
-                {"@type": "Measurement", "value": "", "term.@id": "slopeLength"},
-                {"@type": "Measurement", "value": "", "term.@id": "slope"}
+                {"@type": "Measurement", "value": "> 0", "term.@id": "nutrientLossToAquaticEnvironment"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "heavyWinterPrecipitation"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "totalPhosphorusPerKgSoil"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "erodibility"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "slopeLength"},
+                {"@type": "Measurement", "value": "> 0", "term.@id": "slope"}
             ]
         }
     }
@@ -83,7 +90,7 @@ def _should_run(cycle: dict):
     heavy_winter_precipitation = _get_measurement_content('heavyWinterPrecipitation')
 
     precipitation = _get_measurement_content('precipitationAnnual')
-    water = get_water(cycle, precipitation)
+    inputs_water = get_water_input(cycle)
 
     practice_factor = get_practice_factor(TERM_ID, site)
     pcorr = get_pcorr(slope / 100) if slope is not None else None
@@ -93,7 +100,7 @@ def _should_run(cycle: dict):
     list_of_contents_for_A = [
         practice_factor, erodibility, slope_length,
         pcorr, p_ef_c1, ef_p_c2]
-    list_of_contents_for_R = [heavy_winter_precipitation, water]
+    list_of_contents_for_R = [heavy_winter_precipitation, list_sum([(inputs_water or 0)/10, precipitation or 0])]
     list_of_contents_for_value = [nla_environment, soil_phosphorus_content]
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
@@ -105,7 +112,8 @@ def _should_run(cycle: dict):
                     p_ef_c1=p_ef_c1,
                     ef_p_c2=ef_p_c2,
                     heavy_winter_precipitation=heavy_winter_precipitation,
-                    water=water,
+                    inputs_water=inputs_water,
+                    precipitationAnnual=precipitation,
                     nla_environment=nla_environment,
                     soil_phosphorus_content=soil_phosphorus_content)
 

hestia_earth/models/schererPfister2015/utils.py

@@ -64,11 +64,9 @@ def get_ef_p_c2(term_id: str, cycle: dict):
         get_lookup_value(country, 'EF_P_C2', model=MODEL, term=term_id), None)
 
 
-def get_water(cycle: dict, precipitation: float):
-    inputs = cycle.get('inputs', [])
-    filter_irrigation = filter_list_term_type(inputs, TermTermType.WATER)
-    irrigation = list_sum(get_total_value(filter_irrigation))
-    return list_sum([irrigation/10, precipitation or 0])
+def get_water_input(cycle: dict):
+    inputs_water = filter_list_term_type(cycle.get('inputs', []), TermTermType.WATER)
+    return list_sum(get_total_value(inputs_water), default=None)
 
 
 def calculate_R(heavy_winter_precipitation: bool, water: float):

hestia_earth/models/site/management.py

@@ -10,11 +10,18 @@ tillage, cropResidueManagement and landUseManagement.
 All values are copied from the source node, except for crop and forage terms in which case the dates are copied from the
 cycle.
 
+Where `startDate` is missing from landCover products, gap-filling is attempted using `endDate` - `maximumCycleDuration`.
+This is the `endDate` of the `landCover` product.
+This ensures no overlapping date ranges.
+If both `endDate` and `startDate` are missing from the product, these will be gap-filled from the `Cycle`.
+
 When nodes are chronologically consecutive with "% area" or "boolean" units and the same term and value, they are
 condensed into a single node to aid readability.
 """
+from datetime import timedelta, datetime
 from functools import reduce
 from hestia_earth.schema import TermTermType, SiteSiteType
+from hestia_earth.utils.lookup import column_name, get_table_value, download_lookup
 from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import safe_parse_float, flatten
 from hestia_earth.utils.blank_node import get_node_value
@@ -23,12 +30,12 @@ from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils import _include, _omit, group_by
 from hestia_earth.models.utils.management import _new_management
 from hestia_earth.models.utils.term import get_lookup_value
-from hestia_earth.models.utils.blank_node import condense_nodes
-from hestia_earth.models.utils.crop import get_landCover_term_id
+from hestia_earth.models.utils.blank_node import condense_nodes, DatestrFormat, _gapfill_datestr, DatestrGapfillMode
 from hestia_earth.models.utils.site import (
     related_cycles, get_land_cover_term_id as get_landCover_term_id_from_site_type
 )
 from . import MODEL
+from ..utils.crop import get_landCover_term_id
 
 REQUIREMENTS = {
     "Site": {
@@ -81,13 +88,13 @@ RETURNS = {
     }]
 }
 LOOKUPS = {
-    "crop": ["landCoverTermId"],
+    "crop": ["landCoverTermId", "maximumCycleDuration"],
     "forage": ["landCoverTermId"],
     "inorganicFertiliser": "nitrogenContent",
     "organicFertiliser": "ANIMAL_MANURE",
     "soilAmendment": "PRACTICE_INCREASING_C_INPUT",
     "landUseManagement": "GAP_FILL_TO_MANAGEMENT",
-    "property": "GAP_FILL_TO_MANAGEMENT"
+    "property": ["GAP_FILL_TO_MANAGEMENT", "CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY"]
 }
 MODEL_KEY = 'management'
 
@@ -126,19 +133,49 @@ _INPUT_RULES = {
 _SKIP_LAND_COVER_SITE_TYPES = [
     SiteSiteType.CROPLAND.value
 ]
+_CYCLE_DATE_TERM_TYPES = {TermTermType.CROP.value, TermTermType.FORAGE.value}
 
 
 def management(data: dict):
     node = _new_management(data.get('id'))
     node['value'] = data['value']
-    node['endDate'] = data['endDate']
+    node['endDate'] = _gap_filled_date_only_str(data['endDate'])
     if data.get('startDate'):
-        node['startDate'] = data['startDate']
+        node['startDate'] = _gap_filled_date_only_str(date_str=data['startDate'], mode=DatestrGapfillMode.START)
     if data.get('properties'):
         node['properties'] = data['properties']
     return node
 
 
+def _get_maximum_cycle_duration(land_cover_id: str):
+    lookup = download_lookup("crop.csv")
+    return safe_parse_float(
+        get_table_value(lookup, column_name('landCoverTermId'), land_cover_id, column_name('maximumCycleDuration'))
+    )
+
+
+def _gap_filled_date_only_str(date_str: str, mode: str = DatestrGapfillMode.END) -> str:
+    return _gapfill_datestr(datestr=date_str, mode=mode)[:10]
+
+
+def _gap_filled_date_obj(date_str: str, mode: str = DatestrGapfillMode.END) -> datetime:
+    return datetime.strptime(
+        _gap_filled_date_only_str(date_str=date_str, mode=mode),
+        DatestrFormat.YEAR_MONTH_DAY.value
+    )
+
+
+def _gap_filled_start_date(land_cover_id: str, end_date: str, cycle: dict) -> str:
+    """If possible, gap-fill the startDate based on the endDate - maximumCycleDuration"""
+    maximum_cycle_duration = _get_maximum_cycle_duration(land_cover_id)
+    return max(
+        _gap_filled_date_obj(end_date) - timedelta(days=maximum_cycle_duration)
+        if maximum_cycle_duration else datetime.fromtimestamp(0),
+        _gap_filled_date_obj(cycle.get("startDate"), mode=DatestrGapfillMode.START)
+        if cycle.get("startDate") else datetime.fromtimestamp(0)
+    ) if any([maximum_cycle_duration, cycle.get("startDate")]) else None
+
+
 def _should_gap_fill(term: dict):
     value = get_lookup_value(lookup_term=term, column='GAP_FILL_TO_MANAGEMENT')
     return bool(value)
@@ -167,20 +204,27 @@ def _copy_item_if_exists(source: dict, keys: list[str] = None, dest: dict = None
     return reduce(lambda p, c: p | ({c: source[c]} if source.get(c) else {}), keys or [], dest or {})
 
 
-def _get_landCover_term_id(product: dict) -> str:
-    term = product.get('term', {})
-    return get_landCover_term_id(term, model=MODEL, term=term.get('@id'), model_key=MODEL_KEY)
-
-
 def _get_relevant_items(cycle: dict, item_name: str, relevant_terms: list):
     """
     Get items from the list of cycles with any of the relevant terms.
     Also adds dates from Cycle.
     """
-    return [
-        _include(cycle, ["startDate", "endDate"]) | item
+    items = [
+        _include(cycle, ["startDate", "endDate"]) |
+        _include(
+            {
+                "startDate": _gap_filled_start_date(
+                    land_cover_id=get_landCover_term_id(item.get('term', {})),
+                    end_date=item.get("endDate") if "endDate" in item else cycle.get("endDate", ""),
+                    cycle=cycle
+                )
+            } if "startDate" not in item else {},
+            "startDate"
+        ) |
+        item
         for item in filter_list_term_type(cycle.get(item_name, []), relevant_terms)
     ]
+    return items
 
 
 def _process_rule(node: dict, term: dict) -> list:
@@ -228,11 +272,12 @@ def _run_products(cycle: dict, products: list, total_products: int = None, use_c
             source=product,
             keys=['properties', 'startDate', 'endDate'],
             dest={
-                "term": {'@id': _get_landCover_term_id(product)},
+                "term": {'@id': get_landCover_term_id(product.get('term', {}))},
                 "value": round(100 / (total_products or len(products)), 2)
             }
         ) | (
-            default_dates if use_cycle_dates else {}
+            default_dates if use_cycle_dates or product.get("term", {}).get("termType") in _CYCLE_DATE_TERM_TYPES
+            else {}
         ))
         for product in products
     ]
@@ -242,7 +287,7 @@ def _run_from_landCover(cycle: dict, crop_forage_products: list):
     """
     Copy landCover items, and include crop/forage landCover items with properties to count in ratio.
     """
-    products = [
+    land_cover_products = [
         _map_to_value(_extract_node_value(
             _include(
                 value=product,
@@ -254,14 +299,29 @@ def _run_from_landCover(cycle: dict, crop_forage_products: list):
             relevant_terms=[TermTermType.LANDCOVER]
         )
     ]
-    return products + _run_products(
+    return land_cover_products + _run_products(
         cycle,
         crop_forage_products,
-        total_products=len(crop_forage_products) + len(products),
+        total_products=len(crop_forage_products) + len(land_cover_products),
         use_cycle_dates=True
     )
 
 
+def _should_group_landCover(term: dict):
+    value = get_lookup_value(lookup_term=term, column='CALCULATE_TOTAL_LAND_COVER_SHARE_SEPARATELY')
+    return bool(value)
+
+
+def _has_prop_grouped_with_landCover(product: dict):
+    return bool(
+        next((
+            p
+            for p in product.get('properties', [])
+            if _should_group_landCover(p.get('term', {}))
+        ), None)
+    )
+
+
 def _run_from_crop_forage(cycle: dict):
     products = _get_relevant_items(
         cycle=cycle,
@@ -269,13 +329,13 @@ def _run_from_crop_forage(cycle: dict):
         relevant_terms=[TermTermType.CROP, TermTermType.FORAGE]
     )
     # only take products with a matching landCover term
-    products = list(filter(_get_landCover_term_id, products))
+    products = [p for p in products if get_landCover_term_id(p.get('term', {}))]
     # remove any properties that should not get gap-filled
     products = list(map(_filter_properties, products))
 
-    # split products with properties and those without
-    products_with_gap_filled_props = [p for p in products if p.get('properties')]
-    products_without_gap_filled_props = [p for p in products if not p.get('properties')]
+    # split products with properties that group with landCover
+    products_with_gap_filled_props = [p for p in products if _has_prop_grouped_with_landCover(p)]
+    products_without_gap_filled_props = [p for p in products if not _has_prop_grouped_with_landCover(p)]
 
     return _run_from_landCover(
         cycle=cycle,

hestia_earth/models/utils/blank_node.py

@@ -663,6 +663,7 @@ DATESTR_FORMAT_TO_EXPECTED_LENGTH = {
 
 DatestrGapfillMode = Enum("DatestrGapfillMode", [
     "START",
+    "MIDDLE",
     "END"
 ])
 """
@@ -738,8 +739,25 @@ def _gapfill_datestr_end(datestr: str, format: DatestrFormat) -> str:
     return datestr + completion_str[len(datestr):]
 
 
+def _gapfill_datestr_middle(datestr: str, format: DatestrFormat) -> str:
+    """
+    Gap-fill an incomplete datestr with the middle value, halfway between the latest and earliest values.
+    """
+    start_date_obj = datetime.strptime(
+        _gapfill_datestr_start(datestr),
+        DatestrFormat.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND.value
+    )
+    end_date_obj = datetime.strptime(
+        _gapfill_datestr_end(datestr, format=format),
+        DatestrFormat.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND.value
+    )
+    middle_date = start_date_obj + (end_date_obj - start_date_obj) / 2
+    return datetime.strftime(middle_date, DatestrFormat.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND.value)
+
+
 DATESTR_GAPFILL_MODE_TO_GAPFILL_FUNCTION = {
     DatestrGapfillMode.START: _gapfill_datestr_start,
+    DatestrGapfillMode.MIDDLE: _gapfill_datestr_middle,
     DatestrGapfillMode.END: _gapfill_datestr_end
 }
 
@@ -757,6 +775,16 @@ def _gapfill_datestr(datestr: str, mode: DatestrGapfillMode = DatestrGapfillMode
     return DATESTR_GAPFILL_MODE_TO_GAPFILL_FUNCTION[mode](_datestr, format) if should_run else _datestr
 
 
+def _str_dates_match(date_str_one: str, date_str_two: str, mode=DatestrGapfillMode.END) -> bool:
+    """
+    Comparison of non-gap-filled string dates.
+    example: For end dates, '2010' would match '2010-12-31', but not '2010-01-01'
+    """
+    return (
+        _gapfill_datestr(datestr=date_str_one, mode=mode) == _gapfill_datestr(datestr=date_str_two, mode=mode)
+    )
+
+
 def _datetime_within_range(datetime: datetime, range: DatetimeRange) -> bool:
     """
     Determine whether or not a `datetime` falls within a `DatetimeRange`.

hestia_earth/models/utils/crop.py

@@ -65,4 +65,8 @@ def valid_site_type(cycle: dict, include_permanent_pasture=False):
 
 def get_landCover_term_id(lookup_term: dict, **log_args) -> str:
     value = get_lookup_value(lookup_term, 'landCoverTermId', **log_args)
-    return value.split(';')[0] if value else None
+    return (
+        lookup_term.get("@id") if lookup_term.get("termType") == TermTermType.LANDCOVER.value else
+        value.split(';')[0] if value else
+        None
+    )

hestia_earth/models/utils/fuel.py

@@ -13,7 +13,10 @@ def impact_lookup_value(model: str, term_id: str, impact_assessment: dict, looku
     fuels = filter_list_term_type(cycle.get('inputs', []), TermTermType.FUEL)
     has_fuels_inputs = len(fuels) > 0
     fuels_total_value = convert_value_from_cycle(
-        product, cycle_lookup_value(model, term_id, cycle, fuels, lookup_col), model=model, term_id=term_id
+        impact_assessment,
+        product,
+        cycle_lookup_value(model, term_id, cycle, fuels, lookup_col),
+        model=model, term_id=term_id
     ) if has_fuels_inputs else None
     logRequirements(impact_assessment, model=model, term=term_id,
                     term_type_electricityFuel_complete=fuel_complete,

hestia_earth/models/utils/impact_assessment.py

@@ -4,7 +4,7 @@ from hestia_earth.utils.lookup import download_lookup
 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 logRequirements, debugValues, log_as_table
+from hestia_earth.models.log import debugValues, log_as_table
 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
@@ -244,13 +244,15 @@ def emission_value(impact_assessment: dict, term_id: str):
     return find_term_match(impact_assessment.get('emissionsResourceUse', []), term_id).get('value')
 
 
-def convert_value_from_cycle(product: dict, value: float, default=None, model: str = None, term_id: str = None):
+def convert_value_from_cycle(
+    log_node: dict, product: dict, value: float, default=None, model: str = None, term_id: str = None
+):
     pyield = list_sum(product.get('value', [])) if product else 0
     economic_value = product.get('economicValueShare') if product else 0
 
-    logRequirements({}, model=model, term=term_id,
-                    product_yield=pyield,
-                    economicValueShare=economic_value)
+    debugValues(log_node, model=model, term=term_id,
+                product_yield=pyield,
+                economicValueShare=economic_value)
 
     return (value / pyield) * economic_value / 100 if all([
         value is not None, pyield > 0, economic_value

hestia_earth/models/utils/pesticideAI.py

@@ -22,6 +22,7 @@ def impact_lookup_value(model: str, term_id: str, impact_assessment: dict, looku
         get_pesticides_from_inputs(cycle)
     has_pesticides_inputs = len(pesticides) > 0
     pesticides_total_value = convert_value_from_cycle(
+        log_node=impact_assessment,
         product=product,
         value=cycle_lookup_value(model, term_id, cycle, pesticides, lookup_col),
         default=None,

hestia_earth/models/version.py

@@ -1 +1 @@
-VERSION = '0.65.4'
+VERSION = '0.65.6'

{hestia_earth_models-0.65.4.dist-info → hestia_earth_models-0.65.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.65.4
+Version: 0.65.6
 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==30.*
-Requires-Dist: hestia-earth-utils>=0.13.12
+Requires-Dist: hestia-earth-utils>=0.13.14
 Requires-Dist: python-dateutil>=2.8.1
 Requires-Dist: CurrencyConverter==0.16.8
 Requires-Dist: haversine>=2.7.0