hestia-earth-models 0.74.17__py3-none-any.whl → 0.75.0__py3-none-any.whl

tests/orchestrator/models/test_transformations.py

@@ -1,32 +0,0 @@
-from unittest.mock import patch
-import json
-import os
-
-from tests.utils import fixtures_path, fake_new_emission, fake_new_product, fake_new_input
-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')
-@patch('hestia_earth.models.transformation.input.excreta._new_input', side_effect=fake_new_input)
-@patch('hestia_earth.models.transformation.product.excreta._new_product', side_effect=fake_new_product)
-@patch('hestia_earth.models.ipcc2019.n2OToAirExcretaDirect._new_emission', side_effect=fake_new_emission)
-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

@@ -1,33 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,342 +0,0 @@
-from unittest.mock import patch
-import pydash
-
-from hestia_earth.orchestrator.utils import reset_index
-from hestia_earth.orchestrator.strategies.merge.merge_list import merge, _get_value
-
-class_path = 'hestia_earth.orchestrator.strategies.merge.merge_list'
-version = '1'
-
-
-def test_get_value():
-    assert _get_value({'startDate': '2020-01-01'}, 'startDate', {}) == '2020-01-01'
-    assert _get_value({'startDate': '2020-01-01'}, 'startDate', {'matchDatesFormat': '%Y'}) == '2020'
-    assert _get_value({'startDate': '2020-01-01'}, 'startDate', {'matchDatesFormat': '%Y-%m'}) == '2020-01'
-    assert _get_value({'startDate': '2020-01-01'}, 'startDate', {'matchDatesFormat': '%Y-%m-%d'}) == '2020-01-01'
-    assert _get_value({'value': 500}, 'value') == 500
-    assert _get_value({'value': 500}, 'value', {'matchDatesFormat': '%Y-%m-%d'}) == 500
-    assert _get_value({'value': 'test'}, 'value') == 'test'
-
-
-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
-    reset_index()
-
-    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
-    reset_index()
-
-    # 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
-    reset_index()
-
-    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
-    reset_index()
-
-    # 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

@@ -1,95 +0,0 @@
-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()

tests/orchestrator/strategies/run/test_add_blank_node_if_missing.py

@@ -1,109 +0,0 @@
-from unittest.mock import patch
-
-from hestia_earth.orchestrator.strategies.run.add_blank_node_if_missing import should_run
-
-class_path = 'hestia_earth.orchestrator.strategies.run.add_blank_node_if_missing'
-FAKE_EMISSION = {'@id': 'n2OToAirCropResidueDecompositionIndirect', 'termType': 'emission'}
-
-
-@patch(f"{class_path}.get_required_model_param", return_value='')
-@patch(f"{class_path}.find_term_match")
-def test_should_run(mock_node_exists, *args):
-    data = {}
-    model = {}
-
-    # node does not exists => run
-    mock_node_exists.return_value = None
-    assert should_run(data, model) is True
-
-    # node exists but no value => run
-    mock_node_exists.return_value = {}
-    assert should_run(data, model) is True
-
-    # node exists with value + no params => no run
-    node = {'value': 10}
-    mock_node_exists.return_value = node
-    assert not should_run(data, model)
-
-    # node exists with added value `0` and `Emission` => run
-    node = {'@type': 'Emission', 'value': [0], 'added': ['value'], 'methodTier': 'not relevant'}
-    mock_node_exists.return_value = node
-    assert should_run(data, model) is True
-
-
-@patch(f"{class_path}.get_required_model_param", return_value='')
-@patch(f"{class_path}.find_term_match")
-def test_should_run_skipEmptyValue(mock_node_exists, *args):
-    data = {}
-
-    # no value and not skip => run
-    mock_node_exists.return_value = {}
-    model = {'runArgs': {'skipEmptyValue': False}}
-    assert should_run(data, model) is True
-
-    # no value and skip => no run
-    mock_node_exists.return_value = {}
-    model = {'runArgs': {'skipEmptyValue': True}}
-    assert not should_run(data, model)
-
-
-@patch(f"{class_path}.get_required_model_param", return_value='')
-def test_should_run_skipAggregated(*args):
-    data = {}
-    model = {'runArgs': {'skipAggregated': True}}
-
-    # not aggregated => run
-    data = {'aggregated': False}
-    assert should_run(data, model) is True
-
-    # aggregated => no run
-    data = {'aggregated': True}
-    assert not should_run(data, model)
-
-
-@patch(f"{class_path}.get_required_model_param", return_value='')
-@patch(f"{class_path}.find_term_match")
-def test_should_run_runNonAddedTerm(mock_node_exists, *args):
-    data = {}
-    node = {'value': 10}
-    mock_node_exists.return_value = node
-    model = {'runArgs': {'runNonAddedTerm': True}}
-
-    # term has been added => no run
-    node['added'] = ['term']
-    assert not should_run(data, model)
-
-    # term has not been added => run
-    node['added'] = []
-    assert should_run(data, model) is True
-
-
-@patch(f"{class_path}.get_required_model_param", return_value='')
-@patch(f"{class_path}.find_term_match")
-def test_should_run_runNonMeasured(mock_node_exists, *args):
-    data = {}
-    node = {'value': 10}
-    mock_node_exists.return_value = node
-    model = {'runArgs': {'runNonMeasured': True}}
-
-    # term measured => no run
-    node['methodTier'] = 'measured'
-    assert not should_run(data, model)
-
-    # term not measured => run
-    node['methodTier'] = 'background'
-    assert should_run(data, model) is True
-
-
-@patch(f"{class_path}.get_required_model_param", return_value=FAKE_EMISSION.get('@id'))
-@patch(f"{class_path}.find_term_match")
-def test_should_run_check_typeAllowed(mock_node_exists, *args):
-    node = {'term': FAKE_EMISSION}
-    mock_node_exists.return_value = node
-    model = {}
-
-    # type is not allowed => no run
-    assert not should_run({'type': 'Transformation'}, model)
-
-    # type is allowed => run
-    assert should_run({'type': 'Cycle'}, model) is True

tests/orchestrator/strategies/run/test_add_key_if_missing.py

@@ -1,14 +0,0 @@
-from hestia_earth.orchestrator.strategies.run.add_key_if_missing import should_run
-
-
-def test_should_run():
-    data = {}
-    key = 'model-key'
-    model = {'key': key}
-
-    # key not in data => run
-    assert should_run(data, model) is True
-
-    # key in data => no run
-    data[key] = 10
-    assert not should_run(data, model)

tests/orchestrator/strategies/run/test_always.py

@@ -1,5 +0,0 @@
-from hestia_earth.orchestrator.strategies.run.always import should_run
-
-
-def test_should_run():
-    assert should_run({}, {}) is True