hestia-earth-models 0.74.4__py3-none-any.whl → 0.74.6__py3-none-any.whl

hestia_earth/models/hestia/landOccupationDuringCycle.py

@@ -1,4 +1,5 @@
 from functools import reduce
+from itertools import zip_longest
 from typing import NamedTuple
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
@@ -29,9 +30,9 @@ REQUIREMENTS = {
                 "@type": "Site",
                 "country": {"@type": "Term", "termType": "region"}
             },
-            "siteArea": "",
-            "siteDuration": "",
-            "siteUnusedDuration": "",
+            "siteArea": ">= 0",
+            "siteDuration": ">= 0",
+            "siteUnusedDuration": ">= 0",
             "optional": {
                 "@doc": "When `otherSites` are provided, `otherSitesArea`, `otherSitesDuration` and `otherSitesUnusedDuration` are required",  # noqa: E501
                 "otherSites": [{
@@ -111,82 +112,102 @@ def _calc_land_occupation_m2_per_kg(
     return land_occupation_m2_per_ha * economic_value_share * 0.01 / yield_
 
 
-_CYCLE_KEYS = (
-    "site", "siteArea", "siteDuration", "siteUnusedDuration"
-)
+def _extract_site_data(cycle: dict, land_cover_id: dict):
+    site = cycle.get("site", {})
+    site_data = SiteData(
+        id=site.get("@id"),
+        area=cycle.get("siteArea"),
+        duration=cycle.get("siteDuration"),
+        unused_duration=cycle.get("siteUnusedDuration"),
+        country_id=site.get("country", {}).get("@id"),
+        land_cover_id=land_cover_id or get_landCover_term_id_from_site_type(site.get("siteType"))
+    )
 
-_CYCLE_KEY_MAPPING = {
-    field: field.replace("site", "otherSites", 1) for field in _CYCLE_KEYS
-}
+    is_valid = _should_run_site_data(site_data)
 
+    logs = {
+        "site_data": _format_inventory([site_data])
+    }
 
-def _build_inventory(cycle: dict, product: dict):
-    product_land_cover_id = get_landCover_term_id(product.get("term", {}), skip_debug=True)
+    return is_valid, site_data, logs
 
-    cycle_data = {
-        key: [value] + cycle.get(otherSites_key, []) for key, otherSites_key in _CYCLE_KEY_MAPPING.items()
-        if (value := cycle.get(key))
-    }
 
-    n_sites = len(cycle_data.get("site", []))
-    should_build_inventory = n_sites > 0 and all([
-        len(cycle_data.get(key, [])) == n_sites for key in _CYCLE_KEYS[1:]
-    ])
+def _extract_other_sites_data(cycle: dict, land_cover_id: dict):
+    other_sites = cycle.get("otherSites", [])
+    other_sites_area = cycle.get("otherSitesArea", [])
+    other_sites_duration = cycle.get("otherSitesDuration", [])
+    other_sites_unused_duration = cycle.get("otherSitesUnusedDuration", [])
 
-    inventory = [
+    other_sites_data = [
         SiteData(
             id=site.get("@id"),
-            area=cycle_data["siteArea"][i],
-            duration=cycle_data["siteDuration"][i],
-            unused_duration=cycle_data["siteUnusedDuration"][i],
+            area=area,
+            duration=duration,
+            unused_duration=unused_duration,
             country_id=site.get("country", {}).get("@id"),
-            land_cover_id=product_land_cover_id or get_landCover_term_id_from_site_type(site.get("siteType", {}))
-        ) for i, site in enumerate(cycle_data.get("site", []))
-    ] if should_build_inventory else []
+            land_cover_id=land_cover_id or get_landCover_term_id_from_site_type(site.get("siteType"))
+        ) for (
+            site,
+            area,
+            duration,
+            unused_duration
+        ) in zip_longest(
+            other_sites,
+            other_sites_area,
+            other_sites_duration,
+            other_sites_unused_duration
+        )
+    ]
+
+    is_valid = all(_should_run_site_data(other_site) for other_site in other_sites_data)
 
     logs = {
-        "n_sites": n_sites
+        "other_sites_count": len(other_sites),
+        "other_sites_data": _format_inventory(other_sites_data, "Not relevant")
     }
 
-    return inventory, logs
+    return is_valid, other_sites_data, logs
 
 
 def _should_run_site_data(site_data: SiteData) -> bool:
     return all([
-        site_data.area >= 0,
-        site_data.duration >= 0,
-        site_data.unused_duration >= 0,
+        site_data.area or site_data.area == 0,
+        site_data.duration or site_data.duration == 0,
+        site_data.unused_duration or site_data.unused_duration == 0,
         site_data.land_cover_id,
         site_data.country_id
     ])
 
 
-def _format_float(value: float, unit: str = "") -> str:
+def _format_float(value: float, unit: str = "", default: str = "None") -> str:
     return " ".join(
-        string for string in [f"{value:.3g}", unit] if string
-    ) if value else "None"
+        string for string in [f"{value}", unit] if string
+    ) if isinstance(value, (float, int)) else default
 
 
 _INVALID_CHARS = {"_", ":", ",", "="}
 _REPLACEMENT_CHAR = "-"
 
 
-def _format_str(value: str) -> str:
+def _format_str(value: str, default: str = "None") -> str:
     """Format a string for logging in a table. Remove all characters used to render the table on the front end."""
-    return reduce(lambda x, char: x.replace(char, _REPLACEMENT_CHAR), _INVALID_CHARS, str(value))
+    return (
+        reduce(lambda x, char: x.replace(char, _REPLACEMENT_CHAR), _INVALID_CHARS, str(value))
+        if value else default
+    )
 
 
-def _format_inventory(inventory: list[SiteData]) -> str:
+def _format_inventory(inventory: list[SiteData], default: str = "None") -> str:
     return log_as_table(
         {
-            "@id": _format_str(site_data.id),
+            "site-id": _format_str(site_data.id),
             "site-area": _format_float(site_data.area, "ha"),
             "site-duration": _format_float(site_data.duration, "days"),
             "site-unused-duration": _format_float(site_data.unused_duration, "days"),
             "land-cover-id": _format_str(site_data.land_cover_id),
             "country-id": _format_str(site_data.country_id)
         } for site_data in inventory
-    ) if inventory else "None"
+    ) if inventory else default
 
 
 def _should_run(impact_assessment: dict):
@@ -195,13 +216,21 @@ def _should_run(impact_assessment: dict):
     functional_unit = cycle.get("functionalUnit")
 
     product = get_product(impact_assessment)
-    yield_ = sum(product.get("value", []))
+    product_yield = sum(product.get("value", []))
+    product_land_cover_id = get_landCover_term_id(product.get("term", {}), skip_debug=True)
     economic_value_share = (
         100 if functional_unit == CycleFunctionalUnit.RELATIVE.value
         else product.get("economicValueShare")
     )
 
-    inventory, logs = _build_inventory(cycle, product)
+    site_data_is_valid, site_data, site_logs = _extract_site_data(cycle, product_land_cover_id)
+    (
+        other_sites_data_is_valid,
+        other_sites_data,
+        other_sites_logs
+    ) = _extract_other_sites_data(cycle, product_land_cover_id)
+
+    inventory = [site_data] + other_sites_data
 
     valid_inventory = inventory and all(_should_run_site_data(site_data) for site_data in inventory)
 
@@ -210,25 +239,25 @@ def _should_run(impact_assessment: dict):
         model=MODEL,
         term=TERM_ID,
         functional_unit=functional_unit,
-        yield_=_format_float(yield_, product.get("term", {}).get("units")),
+        product_yield=_format_float(product_yield, product.get("term", {}).get("units")),
         economic_value_share=_format_float(economic_value_share, "pct"),
-        site_inventory=_format_inventory(inventory),
         valid_inventory=valid_inventory,
-        **logs
+        site_data_is_valid=site_data_is_valid,
+        **site_logs,
+        other_sites_data_is_valid=other_sites_data_is_valid,
+        **other_sites_logs
     )
 
     should_run = all([
-        yield_ > 0,
-        (
-            economic_value_share is not None
-            and economic_value_share >= 0
-        ),
-        valid_inventory
+        product_yield > 0,
+        economic_value_share or economic_value_share == 0,
+        site_data_is_valid,
+        other_sites_data_is_valid
     ])
 
     logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
 
-    return should_run, yield_, economic_value_share, inventory
+    return should_run, product_yield, economic_value_share, inventory
 
 
 def _run(

hestia_earth/models/hestia/landTransformation100YearAverageDuringCycle.py

@@ -17,7 +17,13 @@ REQUIREMENTS = {
                 "value": ">=0"
             }
         ],
-        "endDate": ""
+        "endDate": "",
+        "none": {
+            "cycle": {
+                "@type": "Cycle",
+                "otherSites": []
+            }
+        }
     }
 }
 RETURNS = {

hestia_earth/models/hestia/landTransformation20YearAverageDuringCycle.py

@@ -17,7 +17,13 @@ REQUIREMENTS = {
                 "value": ">=0"
             }
         ],
-        "endDate": ""
+        "endDate": "",
+        "none": {
+            "cycle": {
+                "@type": "Cycle",
+                "otherSites": []
+            }
+        }
     }
 }
 RETURNS = {

hestia_earth/models/hestia/resourceUse_utils.py

@@ -1,16 +1,13 @@
 from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.tools import to_precision
+from hestia_earth.utils.tools import to_precision, list_sum
 
-from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
 from hestia_earth.models.utils.blank_node import _gapfill_datestr, DatestrGapfillMode, DatestrFormat, _str_dates_match
 from hestia_earth.models.utils.impact_assessment import get_site
 from hestia_earth.models.utils.indicator import _new_indicator
-from .utils import (
-    LAND_USE_TERMS_FOR_TRANSFORMATION,
-    crop_ipcc_land_use_category,
-)
+from .utils import LAND_USE_TERMS_FOR_TRANSFORMATION, crop_ipcc_land_use_category
 from . import MODEL
 
 _MAXIMUM_OFFSET_DAYS = 365 * 2
@@ -41,7 +38,7 @@ def _gap_filled_date_obj(date_str: str) -> datetime:
     )
 
 
-def _find_closest_node(
+def _find_closest_node_date(
     ia_date_str: str,
     management_nodes: list,
     historic_date_offset: int,
@@ -62,32 +59,22 @@ def _find_closest_node(
     return filtered_dates[min(filtered_dates.keys())] if filtered_dates else ""
 
 
-def should_run(
-    impact_assessment: dict,
-    site: dict,
-    term_id: str,
-    historic_date_offset: int
-) -> tuple[bool, dict, str, str]:
-    relevant_emission_resource_use = [
-        node for node in impact_assessment.get("emissionsResourceUse", [])
-        if node.get("term", {}).get("@id", "") == _RESOURCE_USE_TERM_ID and node.get("value", -1) >= 0
-    ]
+def should_run(impact_assessment: dict, term_id: str, historic_date_offset: int) -> tuple[bool, dict, str, str]:
+    cycle = impact_assessment.get('cycle', {})
+    has_otherSites = len(cycle.get('otherSites') or []) != 0
+
+    site = get_site(impact_assessment)
     filtered_management_nodes = [
         node for node in site.get("management", [])
-        if node.get("value", -1) >= 0 and node.get("term", {}).get("termType", "") == TermTermType.LANDCOVER.value
+        if node.get("value", -1) >= 0 and node.get("term", {}).get("termType") == TermTermType.LANDCOVER.value
     ]
-    land_occupation_during_cycle_found = any(
-        node.get("term", {}).get("@id") in
-        {node.get("landCover", {}).get("@id") for node in relevant_emission_resource_use}
-        for node in filtered_management_nodes
-    )
     match_mode = (
         DatestrGapfillMode.START if impact_assessment.get("cycle", {}).get("aggregated") is True
         else DatestrGapfillMode.END
     )
     match_date = "startDate" if match_mode == DatestrGapfillMode.START else "endDate"
 
-    closest_date = _find_closest_node(
+    closest_date = _find_closest_node_date(
         ia_date_str=impact_assessment.get(match_date, ""),
         management_nodes=filtered_management_nodes,
         historic_date_offset=historic_date_offset,
@@ -104,98 +91,53 @@ def should_run(
         None
     )
     current_node = filtered_management_nodes.pop(current_node_index) if current_node_index is not None else None
+    landCover_term_id = (current_node or {}).get('term', {}).get('@id')
 
-    logRequirements(impact_assessment, model=MODEL, term=term_id,
-                    closest_end_date=closest_end_date,
-                    closest_start_date=closest_start_date,
-                    has_landOccupationDuringCycle=land_occupation_during_cycle_found,
-                    landCover_term_id=(current_node or {}).get('term', {}).get('@id'))
-
-    should_run_result = all([
-        relevant_emission_resource_use,
-        land_occupation_during_cycle_found,
-        current_node,
-        closest_end_date or closest_start_date
-    ])
-    logShouldRun(impact_assessment, MODEL, term=term_id, should_run=should_run_result)
-
-    return should_run_result, current_node, closest_end_date, closest_start_date
+    prior_management_nodes = [
+        node for node in filtered_management_nodes
+        if _str_dates_match(node.get("endDate", ""), closest_end_date) or
+        _str_dates_match(node.get("startDate", ""), closest_start_date)
+    ]
 
+    ipcc_land_use_category = crop_ipcc_land_use_category(landCover_term_id)
 
-def _get_land_occupation_for_land_use_type(impact_assessment: dict, ipcc_land_use_category: str) -> float:
-    """
-    Returns the sum of all land occupation for the specified land_use_category.
-    """
-    return sum(
-        node.get("value", 0) for node in impact_assessment.get("emissionsResourceUse", [])
+    total_landOccupationDuringCycle = list_sum([
+        node.get("value") for node in impact_assessment.get("emissionsResourceUse", [])
         if node.get("term", {}).get("@id", "") == _RESOURCE_USE_TERM_ID
         and crop_ipcc_land_use_category(node.get("landCover", {}).get("@id", "")) == ipcc_land_use_category
-    )
-
-
-def _calculate_indicator_value(
-    impact_assessment: dict,
-    term_id: str,
-    management_nodes: list,
-    ipcc_land_use_category: str,
-    previous_land_cover_id: str,
-    historic_date_offset: int
-) -> float:
-    """
-    Land transformation from [land type] previous management nodes
-     = (Land occupation, during Cycle * Historic Site Percentage Area [land type] / 100) / HISTORIC_DATE_OFFSET
-    """
-    land_occupation_for_cycle = _get_land_occupation_for_land_use_type(
-        impact_assessment=impact_assessment,
-        ipcc_land_use_category=ipcc_land_use_category
-    )
-    historical_land_use = sum(
-        node.get("value", 0) for node in management_nodes
-        if node.get("term", {}).get("@id", "") == previous_land_cover_id
-    )
-
-    debugValues(impact_assessment, model=MODEL, term=term_id,
-                ipcc_land_use_category=ipcc_land_use_category,
-                land_occupation_for_cycle=land_occupation_for_cycle,
-                historical_land_use=historical_land_use,
-                historic_date_offset=historic_date_offset)
+    ], default=None)
 
-    return ((land_occupation_for_cycle * historical_land_use) / 100) / historic_date_offset
+    indicators = [
+        {
+            'landCover-id': landCover_term_id,
+            'previous-landCover-id': previous_land_cover_id,
+            'landOccupationDuringCycle': total_landOccupationDuringCycle,
+            'historical-landUse-change': list_sum([
+                node.get("value") for node in prior_management_nodes
+                if node.get("term", {}).get("@id") == previous_land_cover_id
+            ], default=None),
+        }
+        for previous_land_cover_id in [t[0] for t in LAND_USE_TERMS_FOR_TRANSFORMATION.values()]
+    ] if landCover_term_id else []
+    valid_indicators = [indicator for indicator in indicators if indicator['historical-landUse-change'] is not None]
 
+    logRequirements(impact_assessment, model=MODEL, term=term_id,
+                    has_otherSites=has_otherSites,
+                    closest_end_date=closest_end_date,
+                    closest_start_date=closest_start_date,
+                    landCover_term_id=landCover_term_id,
+                    ipcc_land_use_category=ipcc_land_use_category,
+                    indicators=log_as_table(indicators))
 
-def _run_calculate_transformation(
-    term_id: str,
-    current_node: dict,
-    closest_end_date: str,
-    closest_start_date: str,
-    impact_assessment: dict,
-    site: dict,
-    historic_date_offset: int
-) -> list:
-    """
-    Calculate land transformation for all land use categories.
-    """
-    indicators = [
-        _new_indicator_with_value(
-            term_id=term_id,
-            land_cover_id=current_node.get("term", {}).get("@id"),
-            previous_land_cover_id=previous_land_cover_id,
-            value=_calculate_indicator_value(
-                impact_assessment=impact_assessment,
-                term_id=term_id,
-                management_nodes=[
-                    node for node in site.get("management", [])
-                    if _str_dates_match(node.get("endDate", ""), closest_end_date) or
-                    _str_dates_match(node.get("startDate", ""), closest_start_date)
-                ],
-                ipcc_land_use_category=crop_ipcc_land_use_category(current_node.get("term", {}).get("@id", "")),
-                previous_land_cover_id=previous_land_cover_id,
-                historic_date_offset=historic_date_offset
-            )
-        ) for previous_land_cover_id in [t[0] for t in LAND_USE_TERMS_FOR_TRANSFORMATION.values()]
-    ]
+    should_run_result = all([
+        not has_otherSites,
+        ipcc_land_use_category,
+        total_landOccupationDuringCycle is not None,
+        valid_indicators
+    ])
+    logShouldRun(impact_assessment, MODEL, term=term_id, should_run=should_run_result)
 
-    return indicators
+    return should_run_result, valid_indicators
 
 
 def run_resource_use(
@@ -203,19 +145,16 @@ def run_resource_use(
     historic_date_offset: int,
     term_id: str
 ) -> list:
-    site = get_site(impact_assessment)
-    _should_run, current_node, closest_end_date, closest_start_date = should_run(
+    _should_run, indicators = should_run(
         impact_assessment=impact_assessment,
-        site=site,
         term_id=term_id,
         historic_date_offset=historic_date_offset
     )
-    return _run_calculate_transformation(
-        impact_assessment=impact_assessment,
-        site=site,
-        term_id=term_id,
-        current_node=current_node,
-        closest_end_date=closest_end_date,
-        closest_start_date=closest_start_date,
-        historic_date_offset=historic_date_offset
-    ) if _should_run else []
+    return [
+        _new_indicator_with_value(
+            term_id=term_id,
+            land_cover_id=i['landCover-id'],
+            previous_land_cover_id=i['previous-landCover-id'],
+            value=(i['landOccupationDuringCycle'] * i['historical-landUse-change'] / 100) / historic_date_offset
+        ) for i in indicators
+    ] if _should_run else []

hestia_earth/models/hestia/waterSalinity.py

@@ -4,6 +4,7 @@ from hestia_earth.utils.tools import safe_parse_float, list_average, non_empty_l
 from hestia_earth.utils.blank_node import group_by_keys
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import is_from_model
 from hestia_earth.models.utils.measurement import _new_measurement
 from hestia_earth.models.utils.site import related_cycles
 from hestia_earth.models.utils.term import get_lookup_value
@@ -11,14 +12,21 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Site": {
-        "related": {
-            "Cycle": {
-                "@type": "Cycle",
-                "products": [{
-                    "@type": "Product",
-                    "primary": "True",
-                    "term.termType": "liveAquaticSpecies"
-                }]
+        "optional": {
+            "measurements": [{
+                "@type": "Measurement",
+                "term.@id": ["brackishWater", "salineWater", "freshWater"],
+                "value": "true"
+            }],
+            "related": {
+                "Cycle": {
+                    "@type": "Cycle",
+                    "products": [{
+                        "@type": "Product",
+                        "primary": "True",
+                        "term.termType": "liveAquaticSpecies"
+                    }]
+                }
             }
         }
     }
@@ -35,19 +43,26 @@ LOOKUPS = {
     "liveAquaticSpecies": "defaultSalinity"
 }
 TERM_ID = 'waterSalinity'
+_MEASUREMENT_TERM_IDS = ["brackishWater", "salineWater", "freshWater"]
+_DEFAULT_SALINITY = {
+    'freshWater': 0,
+    'brackishWater': 5000,
+    'salineWater': 32000
+}
 
 
 def _measurement(value: float, start_date: str = None, end_date: str = None):
     data = _new_measurement(TERM_ID, MODEL)
     data['value'] = [value]
-    data['endDate'] = end_date
     if start_date:
         data['startDate'] = start_date
+    if end_date:
+        data['endDate'] = end_date
     data['methodClassification'] = MeasurementMethodClassification.EXPERT_OPINION.value
     return data if value is not None else None
 
 
-def _should_run(site: dict):
+def _should_run_by_products(site: dict):
     cycles = related_cycles(site)
     relevant_products = [
         {
@@ -72,8 +87,8 @@ def _should_run(site: dict):
     return should_run, relevant_products
 
 
-def run(site: dict):
-    should_run, values = _should_run(site)
+def _run_by_products(site: dict):
+    should_run, values = _should_run_by_products(site)
     grouped_values = group_by_keys(values, ['start-date', 'end-date'])
     return non_empty_list([
         _measurement(
@@ -83,3 +98,33 @@ def run(site: dict):
         )
         for value in grouped_values.values()
     ]) if should_run else []
+
+
+def _should_run_by_measurement(site: dict):
+    measurements = [
+        m for m in site.get('measurements', [])
+        if all([
+            m.get('term', {}).get('@id') in _MEASUREMENT_TERM_IDS,
+            not is_from_model(m),
+            m.get('value')
+        ])
+    ]
+
+    logRequirements(site, model=MODEL, term=TERM_ID,
+                    existing_measurements=';'.join([m.get('term', {}).get('@id') for m in measurements]))
+
+    should_run = all([measurements])
+    logShouldRun(site, MODEL, TERM_ID, should_run)
+    return should_run, measurements
+
+
+def _run_by_measurement(site: dict):
+    should_run, measurements = _should_run_by_measurement(site)
+    return [
+        _measurement(_DEFAULT_SALINITY[m.get('term', {}).get('@id')], m.get('startDate'), m.get('endDate'))
+        for m in measurements
+    ] if should_run else []
+
+
+def run(site: dict):
+    return _run_by_measurement(site) or _run_by_products(site)

hestia_earth/models/impact_assessment/post_checks/__init__.py

@@ -2,14 +2,15 @@ from os.path import dirname, abspath
 import sys
 
 from hestia_earth.models.utils import _run_in_serie
-from . import cycle, site
+from . import cycle, site, remove_cache_fields
 
 CURRENT_DIR = dirname(abspath(__file__)) + '/'
 sys.path.append(CURRENT_DIR)
 
 MODELS = [
     cycle.run,
-    site.run
+    site.run,
+    remove_cache_fields.run
 ]
 
 

hestia_earth/models/impact_assessment/post_checks/remove_cache_fields.py

@@ -0,0 +1,9 @@
+def run(impact: dict):
+    cache_keys = [key for key in impact.keys() if key.startswith('cache')]
+    for key in cache_keys:
+        del impact[key]
+        try:
+            impact['added'].remove(key)
+        except Exception:
+            continue
+    return impact

hestia_earth/models/impact_assessment/pre_checks/cache_emissionsResourceUse.py

@@ -0,0 +1,21 @@
+from hestia_earth.utils.blank_node import group_by_keys, get_node_value, ArrayTreatment
+from hestia_earth.utils.tools import non_empty_list
+
+_GROUP_KEYS = ['term', 'methodModel', 'inputs', 'operation', 'country', 'region']
+
+
+def _grouped_blank_node(blank_nodes: list):
+    blank_node = {
+        key: blank_nodes[0].get(key) for key in _GROUP_KEYS if blank_nodes[0].get(key)
+    } | {
+        'value': non_empty_list([v.get('value') for v in blank_nodes])
+    }
+    value = get_node_value(blank_node, default_array_treatment=ArrayTreatment.SUM)
+    return blank_node | {'value': value}
+
+
+def run(impact: dict):
+    blank_nodes = impact.get('emissionsResourceUse', [])
+    grouped_blank_nodes = group_by_keys(blank_nodes, _GROUP_KEYS)
+    grouped_blank_nodes = [_grouped_blank_node(value) for value in grouped_blank_nodes.values()]
+    return grouped_blank_nodes

hestia_earth/models/impact_assessment/pre_checks/cycle.py

@@ -23,6 +23,11 @@ def _run(impact: dict):
     site = _load_calculated_node(cycle.get('site', {}), SchemaType.SITE)
     if site:
         cycle['site'] = site
+
+    # need to download `otherSites` as well
+    if 'otherSites' in cycle:
+        cycle['otherSites'] = [_load_calculated_node(s, SchemaType.SITE) for s in cycle['otherSites']]
+
     return cycle