hestia-earth-models 0.61.2__py3-none-any.whl → 0.61.4__py3-none-any.whl

hestia_earth/models/pooreNemecek2018/no3ToGroundwaterInorganicFertiliser.py

@@ -8,15 +8,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "inorganicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "inorganicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "inorganicFertiliser"}]
             }
-        }],
+        ],
         "site": {
             "@type": "Site",
             "measurements": [

hestia_earth/models/pooreNemecek2018/no3ToGroundwaterOrganicFertiliser.py

@@ -8,15 +8,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "organicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "organicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
             }
-        }],
+        ],
         "site": {
             "@type": "Site",
             "measurements": [

hestia_earth/models/schererPfister2015/pToDrainageWaterSoilFlux.py

@@ -9,7 +9,19 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "endDate": "",
-        "inputs": [{"@type": "Input", "value": "", "term.termType": "organicFertiliser"}],
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "organicFertiliser"
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
+            }
+        ],
         "site": {
             "@type": "Site",
             "country": {"@type": "Term", "termType": "region"},

hestia_earth/models/schererPfister2015/pToSurfaceWaterSoilFlux.py

@@ -10,7 +10,19 @@ from .utils import get_liquid_slurry_sludge_P_total
 REQUIREMENTS = {
     "Cycle": {
         "endDate": "",
-        "inputs": [{"@type": "Input", "value": "", "term.termType": "organicFertiliser"}],
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "organicFertiliser"
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
+            }
+        ],
         "site": {
             "@type": "Site",
             "country": {"@type": "Term", "termType": "region"},

hestia_earth/models/schererPfister2015/utils.py

@@ -1,11 +1,11 @@
-from hestia_earth.models.utils.term import get_tillage_terms
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.tools import list_sum, safe_parse_float
 from hestia_earth.utils.model import filter_list_term_type, find_primary_product
 
 from hestia_earth.models.utils.blank_node import get_total_value, get_P2O5_total
-from hestia_earth.models.utils.term import get_lookup_value
+from hestia_earth.models.utils.term import get_lookup_value, get_tillage_terms
 from hestia_earth.models.utils.input import match_lookup_value
+from hestia_earth.models.utils.organicFertiliser import get_cycle_inputs as get_organicFertiliser_inputs
 
 SLOPE_RANGE = [
     [0.0, 0.03, 1.2],
@@ -20,7 +20,7 @@ SLOPE_RANGE = [
 
 
 def get_liquid_slurry_sludge_P_total(cycle: dict):
-    inputs = filter_list_term_type(cycle.get('inputs', []), TermTermType.ORGANICFERTILISER)
+    inputs = get_organicFertiliser_inputs(cycle)
     lookup_name = 'OrganicFertiliserClassification'
     lss_P_total = list_sum(get_P2O5_total([
         i for i in inputs if match_lookup_value(i, col_name=lookup_name, col_value='Liquid, Slurry, Sewage Sludge')

hestia_earth/models/site/management.py

@@ -1,7 +1,7 @@
 """
 Management node with data gap-filled data from cycles.
 """
-from typing import List, Any
+from typing import List, Any, Callable
 from functools import reduce
 from hestia_earth.schema import SchemaType, TermTermType
 from hestia_earth.utils.api import download_hestia
@@ -118,8 +118,12 @@ def _extract_node_value(node: dict) -> dict:
 def _include(value: dict, keys: list): return {k: v for k, v in value.items() if k in keys}
 
 
-def _include_start_end(cycle: dict, values: list):
-    return [(_include(cycle, ['startDate', 'endDate']) | v) for v in values]
+def _default_dates(cycle: dict, values: list):
+    return [(_include(cycle, ["startDate", "endDate"]) | v) for v in values]
+
+
+def _overwrite_dates(cycle: dict, values: list) -> list:
+    return [v | _include(cycle, ["startDate", "endDate"]) for v in values]
 
 
 def _copy_item_if_exists(source: dict, keys: List[str] = None, dest: dict = None) -> dict:
@@ -134,11 +138,13 @@ def _get_landCover_term_id(product: dict) -> str:
     return value.split(';')[0] if value else None
 
 
-def _get_items_with_relevant_term_type(cycles: List[dict], item_name: str, relevant_values: list):
+def _get_items_with_relevant_term_type(
+        cycles: List[dict], item_name: str, relevant_values: list, date_fill: Callable = _default_dates
+):
     """Get items from the list of cycles with any of the relevant values. Also adds dates if missing."""
     return flatten(
         [
-            _include_start_end(
+            date_fill(
                 cycle=cycle,
                 values=filter_list_term_type(cycle.get(item_name, []), relevant_values)
             ) for cycle in cycles
@@ -210,7 +216,8 @@ def _should_run(site: dict):
     products_crop_forage = _get_items_with_relevant_term_type(
         cycles=cycles,
         item_name="products",
-        relevant_values=[TermTermType.CROP, TermTermType.FORAGE]
+        relevant_values=[TermTermType.CROP, TermTermType.FORAGE],
+        date_fill=_overwrite_dates
     )
     products_crop_forage = [
         _copy_item_if_exists(

hestia_earth/models/site/organicCarbonPerHa.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Union
 
 from hestia_earth.schema import MeasurementMethodClassification
 from hestia_earth.utils.date import diff_in_days
@@ -53,11 +53,13 @@ SOIL_BULK_DENSITY_TERM_ID = 'soilBulkDensity'
 ORGANIC_CARBON_PER_KG_SOIL_TERM_ID = 'organicCarbonPerKgSoil'
 
 
-def _measurement(site: dict, value: float, depthUpper: int, depthLower: int, date: Optional[str] = None):
+def _measurement(
+    site: dict, value: float, depthUpper: Union[int, float], depthLower: Union[int, float], date: Optional[str] = None
+) -> dict:
     data = _new_measurement(TERM_ID)
     data['value'] = [value]
-    data['depthUpper'] = depthUpper
-    data['depthLower'] = depthLower
+    data['depthUpper'] = int(depthUpper)
+    data['depthLower'] = int(depthLower)
     data['methodClassification'] = MeasurementMethodClassification.MODELLED_USING_OTHER_MEASUREMENTS.value
     if date is not None:
         data['dates'] = [date]

hestia_earth/models/stehfestBouwman2006/n2OToAirInorganicFertiliserDirect.py

@@ -8,15 +8,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "inorganicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "inorganicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "inorganicFertiliser"}]
             }
-        }],
+        ],
         "site": {
             "@type": "Site",
             "measurements": [

hestia_earth/models/stehfestBouwman2006/n2OToAirOrganicFertiliserDirect.py

@@ -8,15 +8,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "organicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "organicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
             }
-        }],
+        ],
         "site": {
             "@type": "Site",
             "measurements": [

hestia_earth/models/stehfestBouwman2006/noxToAirInorganicFertiliser.py

@@ -8,15 +8,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "inorganicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "inorganicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "inorganicFertiliser"}]
             }
-        }],
+        ],
         "site": {
             "@type": "Site",
             "measurements": [

hestia_earth/models/stehfestBouwman2006/noxToAirOrganicFertiliser.py

@@ -8,15 +8,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "organicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "organicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
             }
-        }],
+        ],
         "site": {
             "@type": "Site",
             "measurements": [

hestia_earth/models/stehfestBouwman2006GisImplementation/noxToAirInorganicFertiliser.py

@@ -8,15 +8,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "inorganicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "inorganicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "inorganicFertiliser"}]
             }
-        }],
+        ],
         "site": {
             "@type": "Site",
             "country": {"@type": "Term", "termType": "region"}

hestia_earth/models/stehfestBouwman2006GisImplementation/noxToAirOrganicFertiliser.py

@@ -8,15 +8,23 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "completeness.fertiliser": "True",
-        "inputs": [{
-            "@type": "Input",
-            "value": "",
-            "term.units": ["kg", "kg N"],
-            "term.termType": "organicFertiliser",
-            "optional": {
-                "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+        "inputs": [
+            {
+                "@type": "Input",
+                "value": "",
+                "term.units": ["kg", "kg N"],
+                "term.termType": "organicFertiliser",
+                "optional": {
+                    "properties": [{"@type": "Property", "value": "", "term.@id": "nitrogenContent"}]
+                }
+            },
+            {
+                "@type": "Input",
+                "value": "",
+                "term.termType": "fertiliserBrandName",
+                "properties": [{"@type": "Property", "value": "", "key.termType": "organicFertiliser"}]
             }
-        }],
+        ],
         "site": {
             "@type": "Site",
             "country": {"@type": "Term", "termType": "region"}

hestia_earth/models/utils/blank_node.py

@@ -14,7 +14,9 @@ from typing import (
     Optional,
     Union
 )
+from hestia_earth.schema import TermTermType
 from hestia_earth.utils.api import download_hestia
+from hestia_earth.utils.model import filter_list_term_type
 from hestia_earth.utils.tools import (
     flatten,
     list_sum,
@@ -1229,3 +1231,30 @@ def group_nodes_by_last_date(nodes: list) -> dict[str, list[dict]]:
         return group | {key: group.get(key, []) + [node]}
 
     return reduce(group_by, nodes, {})
+
+
+def get_inputs_from_properties(input: dict, term_types: Union[TermTermType, List[TermTermType]]):
+    """
+    Compute a list of inputs from the input properties, in the `key:value` form.
+
+    Parameters
+    ----------
+    input : dict
+        The Input.
+    term_types : TermTermType | List[TermTermType]
+        List of `termType` valid for the properties `key`.
+
+    Return
+    ------
+    dict
+        A dictionary of nodes grouped by latest date, in the format `{date: list[node]}`.
+    """
+    input_value = list_sum(input.get('value', []))
+    properties = input.get('properties') or download_hestia(input.get('term', {}).get('@id')).get('defaultProperties')
+    inputs = non_empty_list([
+        {
+            'term': p.get('key'),
+            'value': [(p.get('value') / 100) * (p.get('share', 100) / 100) * input_value]
+        } for p in (properties or []) if all([p.get('key'), p.get('value')])
+    ]) if input_value > 0 else []
+    return filter_list_term_type(inputs, term_types)

hestia_earth/models/utils/cycle.py

@@ -12,6 +12,8 @@ from .measurement import most_relevant_measurement_value
 from .site import valid_site_type as site_valid_site_type
 from .crop import is_plantation
 from .currency import DEFAULT_CURRENCY
+from .inorganicFertiliser import get_cycle_inputs as get_inorganicFertiliser_inputs
+from .organicFertiliser import get_cycle_inputs as get_organicFertiliser_inputs
 
 
 def unique_currencies(cycle: dict) -> list:
@@ -121,7 +123,7 @@ def get_organic_fertiliser_N_total(cycle: dict) -> float:
     float
         The total value as a number.
     """
-    values = get_N_total(filter_list_term_type(cycle.get('inputs', []), TermTermType.ORGANICFERTILISER))
+    values = get_N_total(get_organicFertiliser_inputs(cycle))
     default_value = 0 if _is_term_type_complete(cycle, 'fertiliser') else None
     return list_sum(values, default_value)
 
@@ -147,7 +149,7 @@ def get_organic_fertiliser_P_total(cycle: dict) -> float:
     float
         The total value as a number.
     """
-    values = get_P2O5_total(filter_list_term_type(cycle.get('inputs', []), TermTermType.ORGANICFERTILISER))
+    values = get_P2O5_total(get_organicFertiliser_inputs(cycle))
     default_value = 0 if _is_term_type_complete(cycle, 'fertiliser') else None
     return list_sum(values, default_value)
 
@@ -171,7 +173,7 @@ def get_inorganic_fertiliser_N_total(cycle: dict) -> float:
     float
         The total value as a number.
     """
-    values = get_N_total(filter_list_term_type(cycle.get('inputs', []), TermTermType.INORGANICFERTILISER))
+    values = get_N_total(get_inorganicFertiliser_inputs(cycle))
     default_value = 0 if _is_term_type_complete(cycle, 'fertiliser') else None
     return list_sum(values, default_value)
 
@@ -195,7 +197,7 @@ def get_inorganic_fertiliser_P_total(cycle: dict) -> float:
     float
         The total value as a number.
     """
-    values = get_P2O5_total(filter_list_term_type(cycle.get('inputs', []), TermTermType.INORGANICFERTILISER))
+    values = get_P2O5_total(get_inorganicFertiliser_inputs(cycle))
     default_value = 0 if _is_term_type_complete(cycle, 'fertiliser') else None
     return list_sum(values, default_value)
 

hestia_earth/models/utils/fertiliser.py

@@ -0,0 +1,14 @@
+from typing import Union, List
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import flatten
+
+from .blank_node import get_inputs_from_properties
+
+_TERM_TYPES = [TermTermType.INORGANICFERTILISER, TermTermType.ORGANICFERTILISER]
+
+
+def get_fertilisers_from_inputs(cycle: dict, term_types: Union[TermTermType, List[TermTermType]] = _TERM_TYPES):
+    inputs = flatten(cycle.get('inputs', []) + [a.get('inputs', []) for a in cycle.get('animals', [])])
+    inputs = filter_list_term_type(inputs, TermTermType.FERTILISERBRANDNAME)
+    return flatten([get_inputs_from_properties(i, term_types) for i in inputs])

hestia_earth/models/utils/inorganicFertiliser.py

@@ -1,9 +1,11 @@
 from hestia_earth.schema import TermTermType
 from hestia_earth.utils.lookup import column_name, download_lookup, get_table_value, extract_grouped_data
 from hestia_earth.utils.tools import safe_parse_float
+from hestia_earth.utils.model import filter_list_term_type
 
 from ..log import debugMissingLookup
 from .term import get_lookup_value
+from .fertiliser import get_fertilisers_from_inputs
 
 BREAKDOWN_LOOKUP = 'region-inorganicFertiliser-fertGroupingNitrogen-breakdown.csv'
 
@@ -37,3 +39,8 @@ def get_country_breakdown(model: str, term_id: str, country_id: str, col_name: s
     value = get_table_value(lookup, 'termid', country_id, column_name(col_name))
     debugMissingLookup(BREAKDOWN_LOOKUP, 'termid', country_id, col_name, value, model=model, term=term_id)
     return safe_parse_float(value, 1)
+
+
+def get_cycle_inputs(cycle: dict):
+    return filter_list_term_type(cycle.get('inputs', []), TermTermType.INORGANICFERTILISER) + \
+        get_fertilisers_from_inputs(cycle, TermTermType.INORGANICFERTILISER)

hestia_earth/models/utils/organicFertiliser.py

@@ -0,0 +1,9 @@
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.model import filter_list_term_type
+
+from .fertiliser import get_fertilisers_from_inputs
+
+
+def get_cycle_inputs(cycle: dict):
+    return filter_list_term_type(cycle.get('inputs', []), TermTermType.ORGANICFERTILISER) + \
+        get_fertilisers_from_inputs(cycle, TermTermType.ORGANICFERTILISER)

hestia_earth/models/utils/pesticideAI.py

@@ -1,36 +1,25 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.api import download_hestia
 from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.utils.tools import flatten, non_empty_list, list_sum
+from hestia_earth.utils.tools import flatten
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from .blank_node import get_inputs_from_properties
 from .impact_assessment import convert_value_from_cycle, get_product
 from .cycle import impact_lookup_value as cycle_lookup_value
 
 
-def _get_input_from_properties(input: dict):
-    input_value = list_sum(input.get('value', []))
-    properties = input.get('properties') or download_hestia(input.get('term', {}).get('@id')).get('defaultProperties')
-    return non_empty_list([
-        {'term': p.get('key'), 'value': [p.get('value') / 100 * input_value]} for p in (properties or []) if all([
-            p.get('key'), p.get('value')
-        ])
-    ]) if input_value > 0 else []
-
-
-def get_from_inputs(cycle: dict):
+def get_pesticides_from_inputs(cycle: dict):
     inputs = flatten(cycle.get('inputs', []) + [a.get('inputs', []) for a in cycle.get('animals', [])])
     inputs = filter_list_term_type(inputs, TermTermType.PESTICIDEBRANDNAME)
-    return flatten([
-        _get_input_from_properties(i) for i in inputs
-    ])
+    return flatten([get_inputs_from_properties(i, TermTermType.PESTICIDEAI) for i in inputs])
 
 
 def impact_lookup_value(model: str, term_id: str, impact_assessment: dict, lookup_col: str):
     cycle = impact_assessment.get('cycle', {})
     is_complete = cycle.get('completeness', {}).get('pesticideVeterinaryDrug', False)
     product = get_product(impact_assessment)
-    pesticides = filter_list_term_type(cycle.get('inputs', []), TermTermType.PESTICIDEAI) + get_from_inputs(cycle)
+    pesticides = filter_list_term_type(cycle.get('inputs', []), TermTermType.PESTICIDEAI) + \
+        get_pesticides_from_inputs(cycle)
     has_pesticides_inputs = len(pesticides) > 0
     pesticides_total_value = convert_value_from_cycle(
         product, cycle_lookup_value(model, term_id, pesticides, lookup_col, False), model=model, term_id=term_id

hestia_earth/models/utils/term.py

@@ -603,3 +603,25 @@ def get_pasture_system_terms():
         'name': 'pasture'
     }, limit=LIMIT)
     return list(map(lambda n: n["@id"], terms))
+
+
+def get_electricity_grid_mix_terms():
+    """
+    Find all `Electricity` terms with the name `grid mix`:
+    https://hestia.earth/glossary?termType=electricity&query=grid%20mix
+
+    Returns
+    -------
+    list
+        List of matching `Term` as dict.
+    """
+    return search({
+        "bool": {
+            "must": [
+                {"match": {"@type": SchemaType.TERM.value}},
+                {"match": {"termType.keyword": TermTermType.ELECTRICITY.value}},
+                {"match": {"name": "grid"}},
+                {"match": {"name": "mix"}}
+            ],
+        }
+    }, limit=LIMIT, fields=['@type', '@id', 'name', 'termType', 'units'])

hestia_earth/models/version.py

@@ -1 +1 @@
-VERSION = '0.61.2'
+VERSION = '0.61.4'