hestia-earth-models 0.61.4__tar.gz → 0.61.6__tar.gz

{hestia-earth-models-0.61.4/hestia_earth_models.egg-info → hestia-earth-models-0.61.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.61.4
+Version: 0.61.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
@@ -46,6 +46,13 @@ from hestia_earth.models.pooreNemecek2018 import run
 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:

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/README.md

@@ -31,6 +31,13 @@ from hestia_earth.models.pooreNemecek2018 import run
 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:

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/ecoinventV3AndEmberClimate/__init__.py

@@ -7,6 +7,7 @@ from functools import reduce
 from typing import Tuple
 
 from hestia_earth.utils.tools import list_sum, flatten
+from hestia_earth.utils.model import linked_node
 from hestia_earth.schema import EmissionMethodTier
 
 from hestia_earth.models.log import logShouldRun, logRequirements, log_blank_nodes_id
@@ -14,6 +15,7 @@ from hestia_earth.models.utils.emission import _new_emission
 from hestia_earth.models.utils.blank_node import group_by_keys
 from hestia_earth.models.utils.completeness import _is_term_type_complete
 from hestia_earth.models.utils.term import get_electricity_grid_mix_terms
+from hestia_earth.models.utils.cycle import cycle_end_year
 from .utils import get_emission, get_all_emission_terms
 
 REQUIREMENTS = {
@@ -52,7 +54,7 @@ def _emission(value: float, term_id: str, inputs: list, operation: dict) -> dict
     emission = _new_emission(term_id, MODEL)
     emission['value'] = [value]
     emission['methodTier'] = TIER
-    emission["inputs"] = list(inputs)
+    emission['inputs'] = list(map(linked_node, inputs))
     if operation:
         emission["operation"] = operation
     return emission
@@ -65,23 +67,34 @@ def _grid_inputs(inputs: list, electricity_grid_terms: list):
     ]
 
 
-def _run_input(cycle: dict, inputs: list, emission_term_id: str, input_term: dict):
-    inputs = _grid_inputs(inputs, [input_term])
-    return [
-        _emission(
-            value=get_emission(
-                term_id=emission_term_id,
-                country=cycle.get("site", {}).get("country", {}).get("@id", ""),
-                energy=list_sum(flatten([i.get("value", []) for i in op_inputs])),
-                year=cycle.get("endDate", ""),
-                model=MODEL
-            ),
+def _run_input(cycle: dict, inputs: list, emission_term_id: str, electricity_grid_term: dict):
+    electricity_grid_inputs = [electricity_grid_term]
+    inputs = _grid_inputs(inputs, electricity_grid_inputs)
+
+    def run(grouped_inputs: list):
+        input = grouped_inputs[0]
+        term_id = input.get('term', {}).get('@id')
+        input_value = list_sum(flatten(input.get('value', []) for input in grouped_inputs))
+        country_id = cycle.get("site", {}).get("country", {}).get("@id")
+        year = cycle_end_year(cycle)
+        value = get_emission(
             term_id=emission_term_id,
-            inputs=[input_term],
-            operation=op_inputs[0].get("operation")
+            country=country_id,
+            energy=input_value,
+            year=year,
+            model=MODEL
         )
-        for op_inputs in _group_by_operation(inputs).values()
-    ] if inputs else []
+
+        logRequirements(cycle, model=MODEL, term=term_id,
+                        input_value=input_value,
+                        emission_value=value)
+
+        should_run = all([input_value > 0, value])
+        logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER)
+
+        return _emission(value, emission_term_id, electricity_grid_inputs, input.get("operation"))
+
+    return list(map(run, _group_by_operation(inputs).values() if inputs else []))
 
 
 def _group_by_operation(inputs: list) -> dict:
@@ -94,8 +107,8 @@ def _run_emission(cycle: dict, electricity_grid_terms: list, inputs: list, emiss
             cycle=cycle,
             inputs=inputs,
             emission_term_id=emission_term_id,
-            input_term=input_term
-        ) for input_term in electricity_grid_terms
+            electricity_grid_term=electricity_grid_term
+        ) for electricity_grid_term in electricity_grid_terms
     ])
 
 
@@ -104,11 +117,16 @@ def _should_run_emission(cycle: dict, electricity_grid_terms: list, term_id: str
     inputs = _grid_inputs(cycle.get('inputs', []), electricity_grid_terms)
     has_relevant_inputs = bool(inputs)
     has_country = bool(cycle.get("site", {}).get("country", {}))
+    has_end_date = bool(cycle.get("endDate"))
 
     logRequirements(cycle, model=MODEL, term=term_id,
-                    input_ids=log_blank_nodes_id(inputs))
+                    term_type_electricityFuel_complete=term_type_complete,
+                    input_ids=log_blank_nodes_id(inputs),
+                    has_relevant_inputs=has_relevant_inputs,
+                    has_country=has_country,
+                    has_end_date=has_end_date)
 
-    should_run = all([term_type_complete, has_relevant_inputs, has_country])
+    should_run = all([term_type_complete, has_relevant_inputs, has_country, has_end_date])
     logShouldRun(cycle, MODEL, term_id, should_run, methodTier=TIER)
     return should_run, inputs
 

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/ecoinventV3AndEmberClimate/utils.py

@@ -10,27 +10,18 @@ from hestia_earth.models.data.ecoinventV3 import ecoinventV3_emissions
 EMBER_ECOINVENT_LOOKUP_NAME = "ember-ecoinvent-mapping.csv"
 
 
-def _lookup_data(term_id: str, grouping: str, country_id: str, year: int, lookup_name: str, **log_args):
+def _lookup_data(term_id: str, grouping: str, country_id: str, year: str, lookup_name: str, **log_args):
     lookup = download_lookup(lookup_name)
-    data = get_table_value(lookup, 'termid', country_id, column_name(grouping))
-    debugMissingLookup(lookup_name, 'termid', country_id, grouping, data, term=term_id, **log_args)
-    percentage = extract_grouped_data(data, str(year))
+    column = column_name(grouping)
+    data = get_table_value(lookup, 'termid', country_id, column)
+    percentage = extract_grouped_data(data, year)
+    debugMissingLookup(lookup_name, 'termid', country_id, column, percentage, year=year, term=term_id, **log_args)
     return safe_parse_float(percentage, None)
 
 
 def _convert_name(name: str) -> str: return name.replace(";", ",")
 
 
-def _safe_parse_int(value: str, default=0):
-    """
-    Parse a string into an int.
-    """
-    try:
-        return int(value)
-    except ValueError:
-        return default
-
-
 def _zero_from_non_numeric(value: Any) -> float:
     try:
         return float(value)
@@ -62,7 +53,7 @@ def _get_emission_rate_per_source(ember_ecoinvent_mapping: Dict, emission_term_i
     }
 
 
-def get_emission(term_id: str, country: str, year: str, energy: float, model: str) -> float:
+def get_emission(term_id: str, country: str, year: int, energy: float, model: str) -> float:
     """
     Get the <term_id> emissions in kg for the energy consumed.
         a: ecoInventId of each source        - from "ember-ecoinvent-mapping.csv"
@@ -89,7 +80,7 @@ def get_emission(term_id: str, country: str, year: str, energy: float, model: st
             term_id=source,
             grouping=source,
             country_id=country,
-            year=_safe_parse_int(year),
+            year=str(year),
             lookup_name="region-ember-energySources.csv",
             model=model
         )

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/ipcc2019/animal/weightAtMaturity.py

@@ -91,7 +91,11 @@ def _should_run(cycle: dict):
                         weightAtMaturity=lookup_value,
                         liveweightPerHead=liveweightPerHead_value)
 
-        should_run = all([country_id, value.get('value') is not None, lookup_value >= liveweightPerHead_value])
+        should_run = all([
+            country_id,
+            lookup_value is not None,
+            lookup_value is None or liveweightPerHead_value is None or lookup_value >= liveweightPerHead_value
+        ])
         logShouldRun(cycle, MODEL, term_id, should_run)
 
         return should_run

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/ipcc2019/co2ToAirSoilOrganicCarbonStockChangeManagementChange.py

@@ -694,7 +694,7 @@ def _should_run(cycle: dict) -> tuple:
     """
     cycle_id = cycle.get("@id")
     site = get_site(cycle)
-    cycles = related_cycles(site.get("@id"))
+    cycles = related_cycles(site)
 
     grouped_soc_stocks = _get_grouped_soc_stocks(site)
     grouped_soc_stock_changes = _calc_grouped_soc_stock_changes(grouped_soc_stocks)

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/ipcc2019/organicCarbonPerHa.py

@@ -1891,11 +1891,12 @@ def _get_carbon_sources_from_cycles(cycles: dict) -> list[CarbonSource]:
     inputs_and_products = non_empty_list(flatten(
         [cycle.get("inputs", []) + cycle.get("products", []) for cycle in cycles]
     ))
+    crop_residue_terms = get_crop_residue_incorporated_or_left_on_field_terms()
 
     return non_empty_list([
         _iterate_carbon_source(node) for node in inputs_and_products
         if any([
-            node.get("term", {}).get("@id") in get_crop_residue_incorporated_or_left_on_field_terms(),
+            node.get("term", {}).get("@id") in crop_residue_terms,
             node.get("term", {}).get("termType") in CARBON_SOURCE_TERM_TYPES
         ])
     ])
@@ -3236,9 +3237,10 @@ def _get_carbon_input_kwargs(
         cumulative_threshold=MIN_AREA_THRESHOLD
     )
 
+    cover_crop_property_terms = get_cover_crop_property_terms()
     has_cover_crop = cumulative_nodes_match(
         lambda node: any(
-            get_node_property(node, term_id, False).get("value", False) for term_id in get_cover_crop_property_terms()
+            get_node_property(node, term_id, False).get("value", False) for term_id in cover_crop_property_terms
         ),
         land_cover_nodes,
         cumulative_threshold=MIN_AREA_THRESHOLD
@@ -3515,7 +3517,7 @@ def _should_run(site: dict) -> tuple[bool, dict]:
     site_type = site.get("siteType", "")
     management_nodes = site.get("management", [])
     measurement_nodes = site.get("measurements", [])
-    cycles = related_cycles(site.get("@id"))
+    cycles = related_cycles(site)
 
     has_management = len(management_nodes) > 0
     has_measurements = len(measurement_nodes) > 0
@@ -3768,14 +3770,16 @@ def _get_grouped_climate_measurements(grouped_measurements: dict) -> dict:
 
 
 def _get_grouped_irrigated_monthly(grouped_cycles: dict) -> dict:
+    irrigated_terms = get_irrigated_terms()
+
     return {
         year: {
-            _InventoryKey.IRRIGATED_MONTHLY: _get_irrigated_monthly(year, cycles)
+            _InventoryKey.IRRIGATED_MONTHLY: _get_irrigated_monthly(year, cycles, irrigated_terms)
         } for year, cycles in grouped_cycles.items()
     }
 
 
-def _get_irrigated_monthly(year: int, cycles: list[dict]) -> list[bool]:
+def _get_irrigated_monthly(year: int, cycles: list[dict], irrigated_terms: list[str]) -> list[bool]:
     # Get practice nodes and add "startDate" and "endDate" from cycle if missing.
     irrigation_nodes = non_empty_list(flatten([
         [
@@ -3793,7 +3797,7 @@ def _get_irrigated_monthly(year: int, cycles: list[dict]) -> list[bool]:
     return [
         cumulative_nodes_term_match(
             grouped_nodes.get(year, {}).get(month, []),
-            target_term_ids=get_irrigated_terms(),
+            target_term_ids=irrigated_terms,
             cumulative_threshold=MIN_AREA_THRESHOLD
         ) for month in range(1, 13)
     ]
@@ -3862,12 +3866,13 @@ def _check_is_paddy_rice(cycles: list[dict]) -> bool:
         default_node_value=MIN_YIELD_THRESHOLD
     ) for cycle in cycles)
 
+    reice_terms = get_upland_rice_crop_terms() + get_upland_rice_land_cover_terms()
     has_upland_rice_products = any(cumulative_nodes_term_match(
         filter_list_term_type(
             cycle.get("products", []) + cycle.get("practices", []),
             [TermTermType.CROP, TermTermType.FORAGE, TermTermType.LANDCOVER]
         ),
-        target_term_ids=get_upland_rice_crop_terms() + get_upland_rice_land_cover_terms(),
+        target_term_ids=reice_terms,
         cumulative_threshold=MIN_YIELD_THRESHOLD,
         default_node_value=MIN_YIELD_THRESHOLD
     ) for cycle in cycles)

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/mocking/__init__.py

@@ -1,23 +1,20 @@
+import os
 from hestia_earth.models.utils import measurement, site
 
 from .mock_search import mock as mock_search
 
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+RESULTS_PATH = os.path.join(CURRENT_DIR, 'search-results.json')
 
-def enable_mock(node: dict = None):
-    """
-    Mock calls to Hestia API using pre-loaded search results.
 
-    Parameters
-    ----------
-    node : dict
-        Optional - The node used to run calculations. This is especially useful when running calculations on a Site.
-    """
+def enable_mock(filepath: str, node: dict = None):
     # apply mocks on search results
-    mock_search()
-    # skip fetch bibliography data
-    measurement.include_source = lambda v, *args: v
+    mock_search(filepath)
 
     if node is not None:
+        # skip fetch bibliography data
+        measurement.include_source = lambda v, *args: v
+
         # mock related cycles to return the current node
         fake_node = {'@id': 'fake-cycle', **node}
         site.download_hestia = lambda *args: fake_node

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/mocking/mock_search.py

@@ -1,12 +1,9 @@
-import os
 from inspect import getmembers, isfunction
 import json
+from hestia_earth.utils.tools import flatten
 
-from hestia_earth.models.log import logger
 from hestia_earth.models.utils import term
 
-CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
-RESULTS_PATH = os.path.join(CURRENT_DIR, 'search-results.json')
 IGNORE_FUNC = ['get_lookup_value', 'get_table_value']
 
 
@@ -14,7 +11,7 @@ def _map_results(results):
     # returning the whole term
     return [results] if isinstance(results, dict) else (
         {'@type': 'Term', '@id': results} if isinstance(results, str) else
-        list(map(_map_results, results)) if isinstance(results, list) else
+        flatten(map(_map_results, results)) if isinstance(results, list) else
         None
     )
 
@@ -48,24 +45,27 @@ def create_search_results():
     return list(map(_create_search_result, funcs))
 
 
-def _load_results():
-    with open(RESULTS_PATH) as f:
+def _load_results(filepath: str):
+    with open(filepath) as f:
         return json.load(f)
 
 
-def _find_search_result(query: dict):
-    search_results = _load_results()
+def _find_search_result(filepath: str, query: dict):
+    search_results = _load_results(filepath)
     res = next((n for n in search_results if n['query'] == query), {})
-    logger.debug('mocking search result: %s', res)
     return res.get('results', [])
 
 
-def _fake_search(query: dict, *_a, **_b): return _find_search_result(query)
+def _fake_search(filepath: str):
+    def mock(query: dict, *_a, **_b): return _find_search_result(filepath, query)
+    return mock
 
 
-def _fake_find_node(_n, query: dict, *_a, **_b): return _find_search_result(query)
+def _fake_find_node(filepath: str):
+    def mock(_n, query: dict, *_a, **_b): return _find_search_result(filepath, query)
+    return mock
 
 
-def mock():
-    term.search = _fake_search
-    term.find_node = _fake_find_node
+def mock(filepath: str):
+    term.search = _fake_search(filepath)
+    term.find_node = _fake_find_node(filepath)

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/mocking/search-results.json

@@ -1113,26 +1113,22 @@
       }
     },
     "results": [
-      [
-        {
-          "@type": "Term",
-          "name": "Electricity, grid, renewable mix",
-          "termType": "electricity",
-          "@id": "electricityGridRenewableMix",
-          "units": "kWh",
-          "_score": 27.711746
-        }
-      ],
-      [
-        {
-          "@type": "Term",
-          "name": "Electricity, grid, market mix",
-          "termType": "electricity",
-          "@id": "electricityGridMarketMix",
-          "units": "kWh",
-          "_score": 27.711746
-        }
-      ]
+      {
+        "@type": "Term",
+        "name": "Electricity, grid, renewable mix",
+        "termType": "electricity",
+        "@id": "electricityGridRenewableMix",
+        "units": "kWh",
+        "_score": 27.711746
+      },
+      {
+        "@type": "Term",
+        "name": "Electricity, grid, market mix",
+        "termType": "electricity",
+        "@id": "electricityGridMarketMix",
+        "units": "kWh",
+        "_score": 27.711746
+      }
     ]
   },
   {
@@ -1394,7 +1390,7 @@
         "@type": "Term",
         "name": "Generic crop, seed",
         "@id": "genericCropSeed",
-        "_score": 25.694489
+        "_score": 25.694498
       }
     ]
   },

hestia-earth-models-0.61.6/hestia_earth/models/preload_requests.py

@@ -0,0 +1,32 @@
+"""
+Preload all search requests to avoid making the same searches many times while running models.
+"""
+import json
+
+from .log import logger
+from .mocking.mock_search import create_search_results
+from .mocking import RESULTS_PATH, enable_mock as _mock
+
+
+def enable_preload(filepath: str = RESULTS_PATH, node: dict = None):
+    """
+    Prefetch calls to Hestia API in a local file.
+
+    Parameters
+    ----------
+    filepath : str
+        The path of the file containing the search results. Defaults to current library folder.
+    node : dict
+        Optional - The node used to run calculations. This is especially useful when running calculations on a Site.
+    """
+    logger.debug('Preloading search results and storing in %s', filepath)
+
+    # build the search results
+    data = create_search_results()
+
+    # store in file
+    with open(filepath, 'w') as f:
+        f.write(json.dumps(data, indent=2, ensure_ascii=False))
+
+    # enable mock search results from file
+    _mock(filepath=filepath, node=node)

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/site/management.py

@@ -198,7 +198,7 @@ def _get_relevant_inputs(cycles: List[dict]) -> List:
 
 def _should_run(site: dict):
     # Only get related cycles once.
-    cycles = related_cycles(site.get("@id"))
+    cycles = related_cycles(site)
 
     products_land_cover = [
         _extract_node_value(

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth/models/utils/site.py

@@ -44,7 +44,7 @@ def region_level_1_id(term_id: str):
 def is_site(site: dict): return site.get('@type', site.get('type')) == SchemaType.SITE.value
 
 
-def related_cycles(site_id: str):
+def related_cycles(site: dict):
     """
     Get the list of `Cycle` related to the `Site`.
     Gets the `recalculated` data if available, else `original`.
@@ -59,8 +59,9 @@ def related_cycles(site_id: str):
     list[dict]
         The related `Cycle`s as `dict`.
     """
-    nodes = find_related(SchemaType.SITE, site_id, SchemaType.CYCLE)
-    return non_empty_list(map(lambda node: _load_calculated_node(node, SchemaType.CYCLE), nodes or []))
+    cached_nodes = [n for n in cached_value(site, 'related', []) if n.get('@type') == SchemaType.CYCLE.value]
+    related_nodes = cached_nodes or find_related(SchemaType.SITE, site.get('@id'), SchemaType.CYCLE) or []
+    return non_empty_list(map(lambda node: _load_calculated_node(node, SchemaType.CYCLE), related_nodes))
 
 
 def _cycle_year(cycle: dict, key: str):
@@ -73,7 +74,7 @@ def related_years(site: dict):
         sorted(non_empty_list(set(flatten([
             _cycle_year(cycle, 'startDate'),
             _cycle_year(cycle, 'endDate')
-        ] for cycle in related_cycles(site.get('@id'))))))
+        ] for cycle in related_cycles(site)))))
     )
 
 

hestia-earth-models-0.61.6/hestia_earth/models/version.py

@@ -0,0 +1 @@
+VERSION = '0.61.6'

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6/hestia_earth_models.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.61.4
+Version: 0.61.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
@@ -46,6 +46,13 @@ from hestia_earth.models.pooreNemecek2018 import run
 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:

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth_models.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ hestia_earth/__init__.py
 hestia_earth/models/__init__.py
 hestia_earth/models/cache_sites.py
 hestia_earth/models/log.py
+hestia_earth/models/preload_requests.py
 hestia_earth/models/requirements.py
 hestia_earth/models/version.py
 hestia_earth/models/agribalyse2016/__init__.py

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/hestia_earth_models.egg-info/requires.txt

@@ -1,5 +1,5 @@
 hestia_earth.schema==28.*
-hestia_earth.utils>=0.12.6
+hestia_earth.utils>=0.13.0
 python-dateutil>=2.8.1
 CurrencyConverter==0.16.8
 haversine>=2.7.0

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/tests/models/test_ecoinventV3AndEmberClimate.py

@@ -10,8 +10,8 @@ from hestia_earth.models.ecoinventV3AndEmberClimate import MODEL, _should_run_em
 class_path = f"hestia_earth.models.{MODEL}"
 fixtures_folder = f"{fixtures_path}/{MODEL}"
 
-cycle_with_country = {"site": {"country": {"@type": "Term", "termType": "region"}}}
-cycle_without_country = {"site": {"country": {}}}
+cycle_with_country = {"endDate": "2010", "site": {"country": {"@type": "Term", "termType": "region"}}}
+cycle_without_country = {"endDate": "2010", "site": {"country": {}}}
 ELECTRICITY_TERMS = [
     {"@type": "Term", "@id": "electricityGridMarketMix"},
     {"@type": "Term", "@id": "electricityGridRenewableMix"}

{hestia-earth-models-0.61.4 → hestia-earth-models-0.61.6}/tests/models/utils/test_site.py

@@ -21,7 +21,7 @@ def test_region_level_1_id():
 @patch(f"{class_path}.find_related", return_value=[CYCLE])
 @patch(f"{class_path}._load_calculated_node", return_value=CYCLE)
 def test_related_cycles(*args):
-    assert related_cycles('id') == [CYCLE]
+    assert related_cycles({'@id': 'id'}) == [CYCLE]
 
 
 def test_valid_site_type():

hestia-earth-models-0.61.4/hestia_earth/models/version.py

@@ -1 +0,0 @@
-VERSION = '0.61.4'