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

tests/models/ipcc2019/animal/test_hoursWorkedPerDay.py

@@ -0,0 +1,22 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_property
+
+from hestia_earth.models.ipcc2019 import MODEL
+from hestia_earth.models.ipcc2019.animal.hoursWorkedPerDay import TERM_ID, run
+
+utils_path = '.'.join(['hestia_earth', 'models', MODEL, 'animal', 'utils'])
+class_path = f"hestia_earth.models.{MODEL}.animal.{TERM_ID}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/animal/{TERM_ID}"
+
+
+@patch(f"{utils_path}._new_property", side_effect=fake_new_property)
+def test_run(*args):
+    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/test_config.py

@@ -0,0 +1,115 @@
+import pytest
+import importlib
+from hestia_earth.utils.tools import flatten
+
+from hestia_earth.models.config import (
+    load_config, config_max_stage, _is_aggregated_model, _remove_aggregated, load_run_config, load_trigger_config
+)
+
+
+_aggregated_model = {
+    "value": "input.hestiaAggregatedData"
+}
+_other_model = {
+    "value": "otherModel"
+}
+
+
+def test_load_config():
+    node_type = 'Cycle'
+    config = load_config(node_type)
+    assert config.get('models') is not None
+
+
+def test_load_config_error():
+    node_type = 'Unkown'
+
+    with pytest.raises(Exception, match='Invalid type Unkown.'):
+        load_config(node_type)
+
+
+def test_config_max_stage():
+    node_type = 'Cycle'
+    config = load_config(node_type)
+    assert config_max_stage(config) == 2
+
+
+def test_is_aggregated_model():
+    assert _is_aggregated_model(_aggregated_model) is True
+    assert not _is_aggregated_model(_other_model)
+
+
+def test_remove_aggregated():
+    models = [
+        [_aggregated_model, _other_model],
+        _aggregated_model, _other_model
+    ]
+    assert _remove_aggregated(models) == [[_other_model], _other_model]
+
+
+def test_load_config_skip_aggregated_models():
+    node_type = 'Cycle'
+    all_models = load_config(node_type, skip_aggregated_models=False).get('models')
+    models_no_aggregated = load_config(node_type, skip_aggregated_models=True).get('models')
+    assert all_models != models_no_aggregated
+
+
+def test_load_run_config():
+    assert len(load_run_config(node_type='Site', stage=1)) == 0
+    assert len(load_run_config(node_type='Site', stage=2)) == 1
+
+
+def test_load_run_config_invalid_stage():
+    with pytest.raises(Exception) as e:
+        load_run_config(
+            node_type='ImpactAssessment',
+            stage=2
+        )
+        assert str(e.value) == 'Invalid stage configuration for ImpactAssessment: 2'
+
+
+def test_load_trigger_config_config():
+    assert len(load_trigger_config(node_type='Site', stage=1)) == 1
+    assert len(load_trigger_config(node_type='Site', stage=2)) == 1
+
+
+def test_load_trigger_config_invalid_stage():
+    with pytest.raises(Exception) as e:
+        load_trigger_config(
+            node_type='ImpactAssessment',
+            stage=2
+        )
+        assert str(e.value) == 'Invalid stage configuration for ImpactAssessment: 2'
+
+
+# included in orchestrator
+_ignore_models = ['emissions.deleted', 'transformations']
+_ignore_values = [None, '', 'all']
+
+
+def _model_path(model: dict):
+    name = model.get('model')
+    value = model.get('value')
+    suffix = f"hestia_earth.models.{name}"
+    return f"{suffix}.{value}" if value not in _ignore_values else suffix
+
+
+def _get_models_paths(node_type: str):
+    models = flatten(load_config(node_type).get('models', []))
+    return [
+        _model_path(m)
+        for m in models
+        if m.get('model') not in _ignore_models
+    ]
+
+
+@pytest.mark.parametrize(
+    'node_type',
+    ['Cycle', 'Site', 'ImpactAssessment']
+)
+def test_load_config_cycle(node_type):
+    paths = _get_models_paths(node_type)
+
+    for path in paths:
+        run = importlib.import_module(path).run
+        assert run is not None, path

tests/orchestrator/models/emissions/test_deleted.py

@@ -0,0 +1,21 @@
+from unittest.mock import patch
+import json
+import os
+
+from tests.utils import fixtures_path
+from hestia_earth.orchestrator.models.emissions.deleted import run
+
+folder_path = os.path.join(fixtures_path, 'orchestrator', 'emissions', 'deleted')
+
+
+@patch('hestia_earth.orchestrator.strategies.merge._merge_version', return_value='0.0.0')
+def test_run(*args):
+    with open(os.path.join(folder_path, 'config.json'), encoding='utf-8') as f:
+        config = json.load(f)
+    with open(os.path.join(folder_path, 'cycle.jsonld'), encoding='utf-8') as f:
+        cycle = json.load(f)
+    with open(os.path.join(folder_path, 'result.jsonld'), encoding='utf-8') as f:
+        expected = json.load(f)
+
+    result = run(config.get('models'), cycle)
+    assert result == expected

tests/orchestrator/models/test_transformations.py

@@ -0,0 +1,29 @@
+from unittest.mock import patch
+import json
+import os
+
+from tests.utils import fixtures_path
+from hestia_earth.orchestrator.models.transformations import run, _include_practice
+
+folder_path = os.path.join(fixtures_path, 'orchestrator', 'transformation')
+
+
+@patch('hestia_earth.orchestrator.strategies.merge._merge_version', return_value='0.0.0')
+def test_run(*args):
+    with open(os.path.join(folder_path, 'config.json'), encoding='utf-8') as f:
+        config = json.load(f)
+    with open(os.path.join(folder_path, 'cycle.jsonld'), encoding='utf-8') as f:
+        cycle = json.load(f)
+    with open(os.path.join(folder_path, 'result.jsonld'), encoding='utf-8') as f:
+        expected = json.load(f)
+
+    result = run(config.get('models'), cycle)
+    assert result == expected
+
+
+def test_include_practice():
+    term = {'@id': 'genericCropProduct', 'termType': 'crop'}
+    assert not _include_practice({'term': term})
+
+    term = {'@id': 'yieldOfPrimaryAquacultureProductLiveweightPerM2', 'termType': 'aquacultureManagement'}
+    assert _include_practice({'term': term}) is True

tests/orchestrator/strategies/merge/test_merge_append.py

@@ -0,0 +1,33 @@
+from unittest.mock import patch
+
+from hestia_earth.orchestrator.strategies.merge.merge_append import merge
+
+class_path = 'hestia_earth.orchestrator.strategies.merge.merge_append'
+
+
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_new_node(*args):
+    node1 = {
+        'term': {'@id': 'term-1'},
+        'value': 1
+    }
+    node2 = {
+        'term': {'@id': 'term-2'},
+        'value': 2
+    }
+    source = [node1]
+    result = merge(source, [node1, node2], '1')
+    result = merge(result, node2, '1')
+    assert result == [node1, node1, node2, node2]
+
+
+def test_merge_list():
+    source = [1]
+    dest = [2, 3]
+    assert merge(source, dest, '1') == [1, 2, 3]
+
+
+def test_merge_el():
+    source = [1]
+    dest = 2
+    assert merge(source, dest, '1') == [1, 2]

tests/orchestrator/strategies/merge/test_merge_default.py

@@ -0,0 +1,7 @@
+from hestia_earth.orchestrator.strategies.merge.merge_default import merge
+
+
+def test_should_merge():
+    source = {'value': [100]}
+    dest = {'value': [50]}
+    assert merge(source, dest) == dest

tests/orchestrator/strategies/merge/test_merge_list.py

@@ -0,0 +1,327 @@
+from unittest.mock import patch
+import pydash
+
+from hestia_earth.orchestrator.strategies.merge.merge_list import merge
+
+class_path = 'hestia_earth.orchestrator.strategies.merge.merge_list'
+version = '1'
+
+
+def _default_merge(a, b, *args): return pydash.objects.merge({}, a, b)
+
+
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_new_node(*args):
+    old_node = {
+        'term': {'@id': 'old-term'},
+        'value': 1
+    }
+    new_node = {
+        'term': {'@id': 'new-term'},
+        'value': 2
+    }
+    result = merge([old_node], [new_node], version)
+    assert result == [old_node, new_node]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_existing_node(*args):
+    term = {'@id': 'term'}
+
+    node_type = 'Site'
+    model = {'key': 'measurements'}
+
+    # with different value => should merge
+    old_node = {
+        'term': term,
+        'value': 1
+    }
+    new_node = {
+        'term': term,
+        'value': 2
+    }
+    result = merge([old_node], [new_node], version, model=model, node_type=node_type)
+    assert len(result) == 1
+
+    # with different depths => should not merge
+    result = merge([{
+        **old_node,
+        'depthUpper': 100
+    }, {
+        **old_node,
+        'depthUpper': 150
+    }], [{
+        **new_node,
+        'depthUpper': 50
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 3
+
+    node_type = 'Cycle'
+    model = {'key': 'emissions'}
+
+    # with same inputs => should merge
+    result = merge([{
+        **old_node,
+        'inputs': [{'@id': 'input-1'}]
+    }], [{
+        **new_node,
+        'inputs': [{'@id': 'input-1'}]
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 1
+
+    # with different inputs => should not merge
+    result = merge([{
+        **old_node,
+        'inputs': [{'@id': 'input-1'}]
+    }], [{
+        **new_node,
+        'inputs': [{'@id': 'input-2'}]
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 2
+
+    result = merge([{
+        **old_node,
+        'inputs': [{'@id': 'input-1'}]
+    }], [{
+        **new_node,
+        'inputs': [{'@id': 'input-1'}, {'@id': 'input-2'}]
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 2
+
+    # with no inputs => should not merge
+    result = merge([old_node], [{
+        **new_node,
+        'inputs': [{'@id': 'input-2'}]
+    }], version, model=model, node_type=node_type)
+    assert len(result) == 2
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_existing_node_skip_same_term(*args):
+    term = {'@id': 'term'}
+    node_type = 'Site'
+    model = {'key': 'measurements'}
+
+    old_node = {
+        'term': term,
+        'value': 1
+    }
+    new_node = {
+        'term': term,
+        'value': 2
+    }
+    result = merge([old_node], [new_node], version, model, {'skipSameTerm': True}, node_type)
+    assert len(result) == 1
+    assert result[0]['value'] == 1
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_existing_node_new_unique_key(*args):
+    term = {'@id': 'term'}
+    node_type = 'Cycle'
+    model = {'key': 'inputs'}
+
+    old_node = {
+        'term': term,
+        'value': 1
+    }
+    new_node = {
+        'term': term,
+        'value': 1,
+        'impactAssessment': {'@id': 'ia-1'}
+    }
+    result = merge([old_node], [new_node], version, model, {}, node_type)
+    assert len(result) == 1
+    assert result[0]['impactAssessment'] == {'@id': 'ia-1'}
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_authors(*args):
+    node_type = 'Bibliography'
+    model = {'key': 'authors'}
+
+    old_node = {
+        'lastName': 'name 1'
+    }
+    new_node = {
+        'lastName': 'name 2'
+    }
+    result = merge([old_node], [new_node], version, model, {}, node_type)
+    # no unique keys, should just append data
+    assert result == [old_node, new_node]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_different_terms_same_unique_properties(*args):
+    method = {'@id': 'method1'}
+    operation = {'@id': 'operation1'}
+    inputs = [{'@id': 'input1'}, {'@id': 'input2'}]
+    node_type = 'ImpactAssessment'
+    model = {'key': 'emissionsResourceUse'}
+
+    node1 = {
+        'term': {'@id': 'term1'},
+        'value': 1,
+        'methodModel': method,
+        'operation': operation,
+        'inputs': inputs
+    }
+    node2 = {
+        'term': {'@id': 'term2'},
+        'value': 2,
+        'methodModel': method,
+        'operation': operation,
+        'inputs': inputs
+    }
+    node3 = {
+        'term': {'@id': 'term3'},
+        'value': 3,
+        'inputs': inputs
+    }
+    node4 = {
+        'term': {'@id': 'term1'},
+        'value': 2,
+        'methodModel': method,
+        'operation': operation,
+        'inputs': inputs
+    }
+    # different term should not merge
+    assert merge([node1], [node2], version, model, {'sameMethodModel': True}, node_type) == [node1, node2]
+    assert merge([node1, node2], [node3], version, model, {'sameMethodModel': True}, node_type) == [node1, node2, node3]
+    assert merge([node1], [node2, node3], version, model, {}, node_type) == [node1, node2, node3]
+    # same term, methodModel, operation and inputs should merge
+    assert merge([node1], [node4], version, model, {}, node_type) == [node4]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_multiple_identical_terms(*args):
+    term1 = {'@id': 'term1'}
+    node_type = 'Cycle'
+    model = {'key': 'inputs'}
+
+    node1 = {
+        'term': term1,
+        'value': 1
+    }
+    node2 = {
+        'term': term1,
+        'value': 2,
+        'impactAssessment': {'id': 'ia-1'}
+    }
+    # merging the same unique nodes should make no changes
+    result = merge([node1, node2], [node1, node2], version, model, {}, node_type)
+    assert result == [node1, node2]
+
+    # adding the same first node with a new unique key
+    node3 = {
+        'term': term1,
+        'value': 3,
+        'impactAssessment': {'@id': 'ia-1'}
+    }
+    result = merge([node1, node2], [node3], version, model, {}, node_type)
+    assert result == [node3, node2]
+
+    node4 = {
+        'term': term1,
+        'value': 4,
+        'impactAssessment': {'id': 'ia-1'}
+    }
+    result = merge([node1, node2], [node4], version, model, {}, node_type)
+    assert result == [node1, node4]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_animals(*args):
+    term1 = {'@id': 'term1'}
+    node_type = 'Cycle'
+    model = {'key': 'animals'}
+
+    node1 = {
+        'animalId': 'animal-1',
+        'term': term1,
+        'value': 1,
+        'properties': [
+            {
+                'term': {"@id": "liveweightPerHead"},
+                'value': 40
+            }
+        ]
+    }
+    node2 = {
+        'animalId': 'animal-2',
+        'term': term1,
+        'value': 1,
+        'properties': [
+            {
+                'term': {"@id": "liveweightPerHead"},
+                'value': 40
+            },
+            {
+                'term': {"@id": "age"},
+                'value': 10
+            }
+        ]
+    }
+    result = merge([node1], [node2], version, model, {}, node_type)
+    # can not merge as properties is used to determine uniqueness
+    assert result == [node1, node2]
+
+
+@patch(f"{class_path}.merge_node", side_effect=_default_merge)
+@patch(f"{class_path}.update_node_version", side_effect=lambda _v, n: n)
+def test_merge_with_properties(*args):
+    node_type = 'Cycle'
+    model = {'key': 'inputs'}
+
+    node1 = {
+      "term": {
+        "@type": "Term",
+        "@id": "concentrateFeedBlend"
+      },
+      "isAnimalFeed": True,
+      "value": [
+        100
+      ],
+      "impactAssessment": {
+        "@id": "_djxbkdk2wnx",
+        "@type": "ImpactAssessment"
+      },
+      "impactAssessmentIsProxy": False,
+      "@type": "Input"
+    }
+
+    node2 = {
+      "term": {
+        "@type": "Term",
+        "@id": "concentrateFeedBlend"
+      },
+      "isAnimalFeed": True,
+      "value": [
+        200
+      ],
+      "impactAssessment": {
+        "@id": "uug7pcaas6aa",
+        "@type": "ImpactAssessment"
+      },
+      "impactAssessmentIsProxy": False,
+      "@type": "Input"
+    }
+
+    properties = [
+        {
+            'term': {'@id': 'property-1'},
+            'value': 100
+        }
+    ]
+    node3 = node2 | {'properties': properties}
+
+    result = merge([node1, node2], [node3], version, model, {}, node_type)
+    # can not merge as properties is used to determine uniqueness
+    assert result == [node1, node3]

tests/orchestrator/strategies/merge/test_merge_node.py

@@ -0,0 +1,95 @@
+from unittest.mock import patch
+from hestia_earth.schema import EmissionMethodTier
+
+from hestia_earth.orchestrator.strategies.merge.merge_node import merge, _has_threshold_diff, _should_merge_lower_tier
+
+class_path = 'hestia_earth.orchestrator.strategies.merge.merge_node'
+
+
+def test_has_threshold_diff():
+    key = 'key'
+    threshold = 0.1  # 10%
+    source = {}
+    dest = {}
+
+    # key not in source => merge
+    assert _has_threshold_diff(source, dest, key, threshold) is True
+
+    # key not in dest => no merge
+    source[key] = [100]
+    assert not _has_threshold_diff(source, dest, key, threshold)
+
+    dest[key] = [90]
+    assert not _has_threshold_diff(source, dest, key, threshold)
+
+    dest[key] = [89]
+    assert _has_threshold_diff(source, dest, key, threshold) is True
+
+    # edge cases
+    source[key] = [0]
+    dest[key] = [1]
+    assert _has_threshold_diff(source, dest, key, threshold) is True
+
+    source[key] = [0]
+    dest[key] = [0]
+    assert not _has_threshold_diff(source, dest, key, threshold)
+
+    source[key] = [1]
+    dest[key] = [0]
+    assert _has_threshold_diff(source, dest, key, threshold)
+
+
+def test_should_merge_lower_tier():
+    source = {}
+    dest = {}
+
+    # always merge if replacing lower tier
+    assert _should_merge_lower_tier(source, dest, {'replaceLowerTier': True}) is True
+
+    # new value has lower tier
+    source['methodTier'] = EmissionMethodTier.TIER_3.value
+    dest['methodTier'] = EmissionMethodTier.TIER_1.value
+    assert not _should_merge_lower_tier(source, dest, {'replaceLowerTier': False})
+
+    source['methodTier'] = EmissionMethodTier.TIER_1.value
+    dest['methodTier'] = EmissionMethodTier.NOT_RELEVANT.value
+    assert not _should_merge_lower_tier(source, dest, {'replaceLowerTier': False})
+
+    # new value has identical tier
+    source['methodTier'] = EmissionMethodTier.TIER_1.value
+    dest['methodTier'] = EmissionMethodTier.TIER_1.value
+    assert _should_merge_lower_tier(source, dest, {'replaceLowerTier': False}) is True
+
+    # new value has higher tier
+    source['methodTier'] = EmissionMethodTier.TIER_1.value
+    dest['methodTier'] = EmissionMethodTier.TIER_3.value
+    assert _should_merge_lower_tier(source, dest, {'replaceLowerTier': False}) is True
+
+
+@patch(f"{class_path}._has_threshold_diff", return_value=False)
+def test_merge_no_merge(*args):
+    source = {'value': [100]}
+    dest = {'value': [50]}
+    args = {'replaceThreshold': ['value', 50]}
+    # simply return the source
+    assert merge(source, dest, '0', {}, args) == source
+
+
+@patch(f"{class_path}._has_threshold_diff", return_value=True)
+@patch(f"{class_path}.update_node_version", return_value={})
+def test_merge_no_threshold(mock_update, *args):
+    source = {'value': [100]}
+    dest = {'value': [50]}
+    args = {}
+    merge(source, dest, '0', {}, args)
+    mock_update.assert_called_once()
+
+
+@patch(f"{class_path}._has_threshold_diff", return_value=True)
+@patch(f"{class_path}.update_node_version", return_value={})
+def test_merge_with_threshold(mock_update, *args):
+    source = {'value': [100]}
+    dest = {'value': [50]}
+    args = {'replaceThreshold': ['value', 50]}
+    merge(source, dest, '0', {}, args)
+    mock_update.assert_called_once()