hestia-earth-models 0.65.5__py3-none-any.whl → 0.65.7__py3-none-any.whl

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/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/version.py

@@ -1 +1 @@
-VERSION = '0.65.5'
+VERSION = '0.65.7'

hestia_earth/orchestrator/__init__.py

@@ -0,0 +1,40 @@
+from pkgutil import extend_path
+from typing import Union, List
+from hestia_earth.utils.tools import current_time_ms
+
+from .log import logger
+from .models import run as run_models
+
+__path__ = extend_path(__path__, __name__)
+
+
+def _required(message): raise Exception(message)
+
+
+def run(data: dict, configuration: dict, stage: Union[int, List[int]] = None) -> dict:
+    """
+    Runs a set of models on a Node.
+
+    Parameters
+    ----------
+    data : dict
+        Either a `Cycle`, a `Site` or an `ImpactAssessment`.
+    configuration : dict
+        Configuration data which defines the order of the models to run.
+    stage : int | list[int]
+        For multi-stage calculations, will filter models by "stage". Can pass a single or multiple stage.
+
+    Returns
+    -------
+    dict
+        The data with updated content
+    """
+    now = current_time_ms()
+    node_type = data.get('@type', data.get('type'))
+    node_id = data.get('@id', data.get('id'))
+    _required('Please provide an "@type" key in your data.') if node_type is None else None
+    _required('Please provide a valid configuration.') if (configuration or {}).get('models') is None else None
+    logger.info(f"Running models on {node_type}" + f" with id: {node_id}" if node_id else '')
+    data = run_models(data, configuration.get('models', []), stage=stage)
+    logger.info('time=%s, unit=ms', current_time_ms() - now)
+    return data

hestia_earth/orchestrator/log.py

@@ -0,0 +1,62 @@
+import os
+import sys
+import logging
+
+LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')
+
+# disable root logger
+root_logger = logging.getLogger()
+root_logger.disabled = True
+
+# create custom logger
+logger = logging.getLogger('hestia_earth.orchestrator')
+logger.removeHandler(sys.stdout)
+logger.setLevel(logging.getLevelName(LOG_LEVEL))
+
+
+def log_to_file(filepath: str):
+    """
+    By default, all logs are saved into a file with path stored in the env variable `LOG_FILENAME`.
+    If you do not set the environment variable `LOG_FILENAME`, you can use this function with the file path.
+
+    Parameters
+    ----------
+    filepath : str
+        Path of the file.
+    """
+    formatter = logging.Formatter(
+        '{"timestamp": "%(asctime)s", "level": "%(levelname)s", "logger": "%(name)s", '
+        '"filename": "%(filename)s", "message": "%(message)s"}',
+        '%Y-%m-%dT%H:%M:%S%z')
+    handler = logging.FileHandler(filepath, encoding='utf-8')
+    handler.setFormatter(formatter)
+    handler.setLevel(logging.getLevelName(LOG_LEVEL))
+    logger.addHandler(handler)
+
+
+LOG_FILENAME = os.getenv('LOG_FILENAME')
+if LOG_FILENAME is not None:
+    log_to_file(LOG_FILENAME)
+
+
+def _join_args(**kwargs): return ', '.join([f"{key}={value}" for key, value in kwargs.items()])
+
+
+def _log_node_suffix(node: dict = {}):
+    node_type = node.get('@type', node.get('type')) if node else None
+    node_id = node.get('@id', node.get('id', node.get('term', {}).get('@id'))) if node else None
+    return f"{node_type.lower()}={node_id}, " if node_type else ''
+
+
+def debugValues(log_node: dict, **kwargs):
+    logger.debug(_log_node_suffix(log_node) + _join_args(**kwargs))
+
+
+def logShouldRun(log_node: dict, model: str, term: str, should_run: bool, **kwargs):
+    extra = (', ' + _join_args(**kwargs)) if len(kwargs.keys()) > 0 else ''
+    logger.info(_log_node_suffix(log_node) + 'should_run=%s, model=%s, term=%s' + extra, should_run, model, term)
+
+
+def logShouldMerge(log_node: dict, model: str, term: str, should_merge: bool, **kwargs):
+    extra = (', ' + _join_args(**kwargs)) if len(kwargs.keys()) > 0 else ''
+    logger.info(_log_node_suffix(log_node) + 'should_merge=%s, model=%s, term=%s' + extra, should_merge, model, term)

hestia_earth/orchestrator/models/__init__.py

@@ -0,0 +1,118 @@
+import os
+from typing import Union, List
+import importlib
+from functools import reduce
+import concurrent.futures
+from copy import deepcopy
+from hestia_earth.utils.tools import non_empty_list
+
+from hestia_earth.models.version import VERSION
+from ..log import logger
+from ..utils import get_required_model_param, _snakecase
+from ..strategies.run import should_run
+from ..strategies.merge import merge
+
+
+def _max_workers(type: str):
+    try:
+        return int(os.getenv(f"MAX_WORKERS_{type.upper()}"))
+    except Exception:
+        return None
+
+
+def _list_except_item(list, item):
+    idx = list.index(item)
+    return list[:idx] + list[idx+1:]
+
+
+def _filter_models_stage(models: list, stage: Union[int, List[int]] = None):
+    stages = stage if isinstance(stage, list) else [stage] if stage is not None else None
+    return models if stage is None else non_empty_list([
+        (_filter_models_stage(m, stage) if isinstance(m, list) else m) for m in models if (
+            not isinstance(m, dict) or m.get('stage') in stages
+        )
+    ])
+
+
+def _import_model(name: str):
+    # try to load the model from the default hestia engine, fallback to orchestrator model
+    try:
+        return {
+            'run': importlib.import_module(f"hestia_earth.models.{name}").run,
+            'version': importlib.import_module('hestia_earth.models.version').VERSION
+        }
+    except ModuleNotFoundError:
+        # try to load the model from the the models folder, fallback to fully specified name
+        try:
+            return {
+                'run': importlib.import_module(f"hestia_earth.orchestrator.models.{name}").run,
+                'version': importlib.import_module('hestia_earth.orchestrator.version').VERSION
+            }
+        except ModuleNotFoundError:
+            return {
+                'run': importlib.import_module(f"{name}").run,
+                'version': VERSION
+            }
+
+
+def _run_pre_checks(data: dict):
+    node_type = _snakecase(data.get('@type', data.get('type')))
+    try:
+        pre_checks = _import_model('.'.join([node_type, 'pre_checks'])).get('run')
+        logger.info('running pre checks for %s', node_type)
+        return pre_checks(data)
+    except Exception:
+        return data
+
+
+def _run_post_checks(data: dict):
+    node_type = _snakecase(data.get('@type', data.get('type')))
+    try:
+        post_checks = _import_model('.'.join([node_type, 'post_checks'])).get('run')
+        logger.info('running post checks for %s', node_type)
+        return post_checks(data)
+    except Exception:
+        return data
+
+
+def _run_model(data: dict, model: dict, all_models: list):
+    module = _import_model(get_required_model_param(model, 'model'))
+    # if no value is provided, use all the models but this one
+    model_value = model.get('value') or _list_except_item(all_models, model)
+    result = module.get('run')(model_value, data)
+    return {'data': data, 'model': model, 'version': module.get('version'), 'result': result}
+
+
+def _run(data: dict, model: dict, all_models: list):
+    return _run_model(data, model, all_models) if should_run(data, model) else None
+
+
+def _run_serie(data: dict, models: list, stage: Union[int, List[int]] = None):
+    return reduce(
+        lambda prev, m: merge(
+            prev, _run_parallel(prev, m, models) if isinstance(m, list) else [_run(deepcopy(prev), m, models)]
+        ),
+        _filter_models_stage(models, stage=stage),
+        data
+    )
+
+
+def _run_parallel(data: dict, model: list, all_models: list):
+    results = []
+
+    max_workers = _max_workers(data.get('@type', data.get('type')))
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = [executor.submit(_run, deepcopy(data), m, all_models) for m in model]
+
+    for future in concurrent.futures.as_completed(futures):
+        results.append(future.result())
+
+    return results
+
+
+def run(data: dict, models: list, stage: Union[int, List[int]] = None):
+    # run pre-checks if exist
+    data = _run_pre_checks(data)
+    data = _run_serie(data, models, stage=stage)
+    # run post-checks if exist
+    return _run_post_checks(data)

hestia_earth/orchestrator/models/emissions/deleted.py

@@ -0,0 +1,15 @@
+from hestia_earth.utils.tools import non_empty_list
+from hestia_earth.utils.emission import emissions_in_system_boundary
+
+
+def _run_emission(term_ids: list):
+    def run(emission: dict):
+        term_id = emission.get('term', {}).get('@id')
+        return (emission | {'deleted': True}) if term_id not in term_ids else None
+    return run
+
+
+def run(_models: list, cycle: dict):
+    emission_ids = emissions_in_system_boundary()
+    emissions = cycle.get('emissions', [])
+    return non_empty_list(map(_run_emission(emission_ids), emissions)) if len(emission_ids) > 0 else []

hestia_earth/orchestrator/models/transformations.py

@@ -0,0 +1,103 @@
+from copy import deepcopy
+from functools import reduce
+from hestia_earth.schema import CompletenessJSONLD
+from hestia_earth.utils.lookup import download_lookup, get_table_value, column_name
+from hestia_earth.models.transformation.input.utils import replace_input_field
+from hestia_earth.models.utils.transformation import previous_transformation
+from hestia_earth.models.utils.product import find_by_product
+
+from . import run as run_node, _import_model
+from hestia_earth.orchestrator.utils import new_practice, _filter_by_keys
+
+
+def _full_completeness():
+    completeness = CompletenessJSONLD().to_dict()
+    keys = list(completeness.keys())
+    keys.remove('@type')
+    return {'@type': completeness['@type']} | reduce(lambda prev, curr: prev | {curr: True}, keys, {})
+
+
+def _include_practice(practice: dict):
+    term = practice.get('term', {})
+    term_type = term.get('termType')
+    term_id = term.get('@id')
+    lookup = download_lookup(f"{term_type}.csv")
+    value = get_table_value(lookup, 'termid', term_id, column_name('includeForTransformation'))
+    return False if value is None or value == '' or not value else True
+
+
+def _copy_from_cycle(cycle: dict, transformation: dict, keys: list):
+    data = deepcopy(transformation)
+    for key in keys:
+        value = transformation.get(key.replace('cycle', 'transformation')) or \
+            transformation.get(key) or \
+            cycle.get(key)
+        if value is not None:
+            data[key] = value
+    return data
+
+
+def _convert_transformation(cycle: dict, transformation: dict):
+    data = _copy_from_cycle(cycle, transformation, [
+        'functionalUnit', 'site', 'otherSites', 'cycleDuration', 'startDate', 'endDate'
+    ])
+    data['completeness'] = cycle.get('completeness', _full_completeness())
+    data['practices'] = [
+        new_practice(transformation.get('term'))  # add `term` as a Practice
+    ] + transformation.get('practices', []) + [
+        p for p in cycle.get('practices', []) if _include_practice(p)  # some practices need to be copied over
+    ]
+    return data
+
+
+def _run_models(cycle: dict, transformation: dict, models: list):
+    data = _convert_transformation(cycle, transformation)
+    result = run_node(data, models)
+    return _filter_by_keys(result, [
+        'transformationId', 'term', 'inputs', 'products', 'emissions'
+    ])
+
+
+def _apply_transformation_share(previous: dict, current: dict):
+    share = current.get('transformedShare', 100)
+
+    def replace_value(input: dict):
+        product = find_by_product(previous, input)
+        return {
+            **input,
+            **replace_input_field(previous, None, input, product, share, 'value'),
+            **replace_input_field(previous, None, input, product, share, 'min'),
+            **replace_input_field(previous, None, input, product, share, 'max'),
+            **replace_input_field(previous, None, input, product, share, 'sd')
+        }
+
+    return current | {'inputs': list(map(replace_value, current.get('inputs', [])))}
+
+
+def _add_excreta_inputs(previous: dict, current: dict):
+    run = _import_model('transformation.input.excreta').get('run')
+    cycle = {
+        **previous,
+        '@type': 'Cycle',
+        'transformations': [current]
+    }
+    # model will add the inputs directly in the transformation
+    run(cycle)
+    return current
+
+
+def _run_transformation(cycle: dict, models: list):
+    def run(transformations: list, transformation: dict):
+        previous = previous_transformation(cycle, transformations, transformation)
+        transformation = _apply_transformation_share(previous, transformation)
+        # add missing excreta Input when relevant and apply the value share as well
+        transformation = _add_excreta_inputs(previous, transformation)
+        transformation = _apply_transformation_share(previous, transformation)
+        transformation = _run_models(cycle, transformation, models)
+        return transformations + [transformation]
+    return run
+
+
+def run(models: list, cycle: dict):
+    transformations = cycle.get('transformations', [])
+    return reduce(_run_transformation(cycle, models), transformations, [])

hestia_earth/orchestrator/strategies/merge/__init__.py

@@ -0,0 +1,42 @@
+from functools import reduce
+import pydash
+
+from hestia_earth.orchestrator.utils import _non_empty, _non_empty_list, update_node_version
+from . import merge_append
+from . import merge_default
+from . import merge_list
+from . import merge_node
+
+
+def _non_empty_results(results: list):
+    return list(filter(lambda value: _non_empty(value) and _non_empty_list(value.get('result')), results))
+
+
+def _merge_version(data: dict): return data.get('version')  # set as a function to patch it for testing
+
+
+_STRATEGIES = {
+    'list': merge_list.merge,
+    'append': merge_append.merge,
+    'node': merge_node.merge,
+    'default': merge_default.merge
+}
+
+
+def _merge_result(data: dict, result: dict):
+    model = result.get('model')
+    key = model.get('key')
+    values = result.get('result')
+    version = _merge_version(result)
+    merge_type = model.get('mergeStrategy', 'default')
+    merge_args = model.get('mergeArgs', {})
+    current = data.get(key)
+    node_type = data.get('type', data.get('@type'))
+    values = [values] if not isinstance(values, list) and merge_type == 'list' else values
+    new_value = _STRATEGIES[merge_type](current, values, version, model, merge_args, node_type)
+    new_data = pydash.objects.merge({}, data, {key: new_value})
+    return update_node_version(version, new_data, data)
+
+
+def merge(data: dict, results: list):
+    return reduce(_merge_result, _non_empty_results(results), data)

hestia_earth/orchestrator/strategies/merge/merge_append.py

@@ -0,0 +1,29 @@
+from functools import reduce
+from hestia_earth.orchestrator.utils import _non_empty_list, update_node_version
+
+from hestia_earth.orchestrator.log import logger
+
+
+def _merge_node(dest: dict, version: str):
+    term_id = dest.get('term', {}).get('@id', dest.get('@id'))
+    logger.debug('append %s with value: %s', term_id, dest.get('value'))
+    return [update_node_version(version, dest)]
+
+
+_MERGE_BY_TYPE = {
+    'dict': _merge_node,
+    'list': lambda dest, *args: dest
+}
+
+
+def _merge_el(version: str):
+    def merge(source: list, dest: dict):
+        ntype = type(dest).__name__
+        return source + _MERGE_BY_TYPE.get(ntype, lambda *args: [dest])(dest, version)
+    return merge
+
+
+def merge(source: list, dest, version: str, *args):
+    source = source if source is not None else []
+    nodes = _non_empty_list(dest if isinstance(dest, list) else [dest])
+    return reduce(_merge_el(version), nodes, source)

hestia_earth/orchestrator/strategies/merge/merge_default.py

@@ -0,0 +1 @@
+def merge(_source, dest, *args): return dest