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

tests/models/stehfestBouwman2006GisImplementation/test_noxToAirInorganicFertiliser.py

@@ -1,20 +0,0 @@
-from unittest.mock import patch
-import json
-from tests.utils import fixtures_path, fake_new_emission
-
-from hestia_earth.models.stehfestBouwman2006GisImplementation.noxToAirInorganicFertiliser import MODEL, TERM_ID, run
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-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/stehfestBouwman2006GisImplementation/test_noxToAirOrganicFertiliser.py

@@ -1,20 +0,0 @@
-from unittest.mock import patch
-import json
-from tests.utils import fixtures_path, fake_new_emission
-
-from hestia_earth.models.stehfestBouwman2006GisImplementation.noxToAirOrganicFertiliser import MODEL, TERM_ID, run
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-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_cache_nodes.py

@@ -1,31 +0,0 @@
-import json
-from unittest.mock import patch
-from tests.utils import fixtures_path
-
-from hestia_earth.models.cache_nodes import _cache_related_nodes, _cache_sources
-
-class_path = 'hestia_earth.models.cache_nodes'
-fixtures_folder = f"{fixtures_path}/cache_nodes"
-
-
-def test_cache_related_nodes():
-    with open(f"{fixtures_folder}/nodes.json_no_validate", encoding='utf-8') as f:
-        data = json.load(f)
-
-    with open(f"{fixtures_folder}/cache_related_nodes/result.json_no_validate", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    result = _cache_related_nodes(data.get('nodes'))
-    assert result == expected
-
-
-@patch(f"{class_path}.find_sources", return_value=['source1'])
-def test_cache_sources(*args):
-    with open(f"{fixtures_folder}/nodes.json_no_validate", encoding='utf-8') as f:
-        data = json.load(f)
-
-    with open(f"{fixtures_folder}/cache_sources/result.json_no_validate", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    result = _cache_sources(data.get('nodes'))
-    assert result == expected

tests/models/test_cache_sites.py

@@ -1,93 +0,0 @@
-import os
-from unittest.mock import patch, call
-import json
-from tests.utils import fixtures_path
-
-from hestia_earth.models.cache_sites import run
-
-class_path = 'hestia_earth.models.cache_sites'
-fixtures_folder = os.path.join(fixtures_path, 'cache_sites')
-coordinates = [{"latitude": 46.47, "longitude": 2.94}]
-
-
-@patch(f"{class_path}._run_query")
-def test_run(mock_run_query, *args):
-    with open(f"{fixtures_folder}/data.json", encoding='utf-8') as f:
-        data = json.load(f)
-    with open(f"{fixtures_folder}/cache.json", encoding='utf-8') as f:
-        cache = json.load(f)
-
-    with open(f"{fixtures_folder}/rasters-no-years.json", encoding='utf-8') as f:
-        rasters_no_years = json.load(f)
-    with open(f"{fixtures_folder}/rasters-years.json", encoding='utf-8') as f:
-        rasters_years = json.load(f)
-    with open(f"{fixtures_folder}/vectors.json", encoding='utf-8') as f:
-        vectors = json.load(f)
-
-    mock_run_query.side_effect = [
-        [10] * len(rasters_no_years),
-        [10] * len(vectors),
-        [10] * len(rasters_years)
-    ]
-
-    sites = run(sites=data.get('nodes', []), years=[2019, 2020])
-
-    mock_run_query.assert_has_calls([
-        call({
-            "ee_type": "raster",
-            "collections": rasters_no_years,
-            "coordinates": coordinates
-        }),
-        call({
-            "ee_type": "vector",
-            "collections": vectors,
-            "coordinates": coordinates
-        }),
-        call({
-            "ee_type": "raster",
-            "collections": rasters_years,
-            "coordinates": coordinates
-        })
-    ])
-
-    expected = [site | {'_cache': cache} for site in data.get('nodes', [])]
-    assert sites == expected
-
-
-@patch(f"{class_path}._run_query")
-def test_run_include_region(mock_run_query, *args):
-    with open(f"{fixtures_folder}/data.json", encoding='utf-8') as f:
-        data = json.load(f)
-
-    with open(f"{fixtures_folder}/rasters-no-years.json", encoding='utf-8') as f:
-        rasters_no_years = json.load(f)
-    with open(f"{fixtures_folder}/rasters-years.json", encoding='utf-8') as f:
-        rasters_years = json.load(f)
-    with open(f"{fixtures_folder}/vectors-with-regions.json", encoding='utf-8') as f:
-        vectors_with_regions = json.load(f)
-
-    mock_run_query.side_effect = [
-        [10] * len(rasters_no_years),
-        [10] * len(vectors_with_regions),
-        [10] * len(rasters_years)
-    ]
-
-    run(sites=data.get('nodes', []), years=[2019, 2020])
-
-    mock_run_query.assert_has_calls([
-        call({
-            "ee_type": "raster",
-            "collections": rasters_no_years,
-            "coordinates": coordinates
-        }),
-        call({
-            "ee_type": "vector",
-            "collections": vectors_with_regions,
-            "coordinates": coordinates
-        }),
-        call({
-            "ee_type": "raster",
-            "collections": rasters_years,
-            "coordinates": coordinates
-        })
-    ])

tests/models/test_config.py

@@ -1,170 +0,0 @@
-import importlib
-
-import pytest
-from hestia_earth.utils.tools import flatten
-
-from hestia_earth.models.config import (
-    load_config,
-    config_max_stage,
-    _is_aggregated_model,
-    _remove_aggregated,
-    _use_aware_1,
-    load_run_config,
-    load_trigger_config,
-    get_max_stage,
-    AWARE_VERSION
-)
-
-_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_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_config_use_aware_v1_site():
-    node_type = 'Site'
-    v1_models = load_config(node_type, use_aware_version=AWARE_VERSION.V1).get('models')
-    v2_models = load_config(node_type, use_aware_version=AWARE_VERSION.V2).get('models')
-    assert v1_models != v2_models
-
-
-def test_load_config_use_aware_v1_impact_assessment():
-    node_type = 'ImpactAssessment'
-    v1_models = load_config(node_type, use_aware_version=AWARE_VERSION.V1).get('models')
-    v2_models = load_config(node_type, use_aware_version=AWARE_VERSION.V2).get('models')
-    assert v1_models != v2_models
-
-
-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_use_aware_1():
-    scarcity_model = {
-        "model": "aware2-0",
-        "value": "scarcityWeightedWaterUse"
-    }
-    basinid_model = {
-        "model": "geospatialDatabase",
-        "value": "awareWaterBasinId"
-    }
-    models = [
-        [scarcity_model],
-        basinid_model
-    ]
-    assert _use_aware_1(models) == [
-        [{
-            "model": "aware",
-            "value": "scarcityWeightedWaterUse"
-        }],
-        {
-            "model": "geospatialDatabase",
-            "value": "awareWaterBasinId_v1"
-        }
-    ]
-
-
-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').replace('-', '_')
-    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: str):
-    paths = _get_models_paths(node_type)
-
-    for path in paths:
-        run = importlib.import_module(path).run
-        assert run is not None, path
-
-
-@pytest.mark.parametrize(
-    'node_type, max_stage',
-    [('Cycle', 2), ('Site', 2), ('ImpactAssessment', 1)]
-)
-def test_get_max_stage(node_type: str, max_stage: int):
-    assert get_max_stage(node_type) == max_stage, node_type

tests/models/test_emissionNotRelevant.py

@@ -1,32 +0,0 @@
-from unittest.mock import patch
-import json
-from tests.utils import fixtures_path, fake_new_emission
-
-from hestia_earth.models.emissionNotRelevant import MODEL, run
-
-class_path = f"hestia_earth.models.{MODEL}"
-fixtures_folder = f"{fixtures_path}/{MODEL}"
-
-
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-def test_run_cropland(*args):
-    with open(f"{fixtures_folder}/cropland/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/cropland/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    result = run('all', cycle)
-    assert result == expected
-
-
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
-def test_run_pond(*args):
-    with open(f"{fixtures_folder}/pond/cycle.jsonld", encoding='utf-8') as f:
-        cycle = json.load(f)
-
-    with open(f"{fixtures_folder}/pond/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    result = run('all', cycle)
-    assert result == expected

tests/models/test_log.py

@@ -1,128 +0,0 @@
-from enum import Enum
-from numpy import array
-from pytest import mark
-
-from hestia_earth.models.log import (
-    format_bool, format_decimal_percentage, format_enum, format_float, format_int, format_nd_array, format_str
-)
-
-
-@mark.parametrize(
-    "value, kwargs, expected",
-    [
-        (True, {}, "True"),
-        (False, {}, "False"),
-        ([], {}, "None"),
-        ("str", {}, "None"),
-        (None, {}, "None"),
-        (None, {"default": "Override"}, "Override")
-    ],
-    ids=["True", "False", "list", "str", "None", "None w/ default"]
-)
-def test_format_bool(value, kwargs, expected):
-    assert format_bool(value, **kwargs) == expected
-
-
-@mark.parametrize(
-    "value, kwargs, expected",
-    [
-        (3.141592653, {}, "314.159 pct"),
-        (0, {}, "0 pct"),
-        ("20", {}, "None"),
-        (None, {}, "None"),
-        (3.141592653, {"unit": "kg"}, "314.159 kg"),
-        (3.141592653, {"ndigits": 4}, "314.1593 pct"),
-        (None, {"default": "Override"}, "Override"),
-    ],
-    ids=["float", "zero", "str", "None", "float w/ unit", "float w/ ndigits", "None w/ default"]
-)
-def test_format_decimal_percentage(value, kwargs, expected):
-    assert format_decimal_percentage(value, **kwargs) == expected
-
-
-class TestEnum(Enum):
-    WITH_LEGAL_CHARS = "with legal chars"
-    WITH_RESERVED_CHARS = "with_reserved_chars"
-
-
-@mark.parametrize(
-    "value, kwargs, expected",
-    [
-        (TestEnum.WITH_LEGAL_CHARS, {}, TestEnum.WITH_LEGAL_CHARS.value),
-        (TestEnum.WITH_RESERVED_CHARS, {}, "with-reserved-chars"),
-        ("str", {}, "None"),
-        (None, {}, "None"),
-        (None, {"default": "Override"}, "Override")
-    ],
-    ids=["Enum w/ legal chars", "Enum w/ illegal chars", "str", "None", "None w/ default"]
-)
-def test_format_enum(value, kwargs, expected):
-    assert format_enum(value, **kwargs) == expected
-
-
-@mark.parametrize(
-    "value, kwargs, expected",
-    [
-        (3.141592653, {}, "3.142"),
-        (0, {}, "0"),
-        ("20", {}, "None"),
-        (None, {}, "None"),
-        (3.141592653, {"unit": "kg"}, "3.142 kg"),
-        (3.141592653, {"ndigits": 4}, "3.1416"),
-        (None, {"default": "Override"}, "Override"),
-    ],
-    ids=["float", "zero", "str", "None", "float w/ unit", "float w/ ndigits", "None w/ default"]
-)
-def test_format_float(value, kwargs, expected):
-    assert format_float(value, **kwargs) == expected
-
-
-@mark.parametrize(
-    "value, kwargs, expected",
-    [
-        (3.141592653, {}, "3"),
-        (0, {}, "0"),
-        ("20", {}, "None"),
-        (None, {}, "None"),
-        (3.141592653, {"unit": "kg"}, "3 kg"),
-        (None, {"default": "Override"}, "Override")
-    ],
-    ids=["float", "zero", "str", "None", "float w/ unit", "None w/ default"]
-)
-def test_format_int(value, kwargs, expected):
-    assert format_int(value, **kwargs) == expected
-
-
-@mark.parametrize(
-    "value, kwargs, expected",
-    [
-        (array(3.141592653), {}, "3.142 ± 0.0"),
-        (array([1, 2, 3, 4]), {}, "2.5 ± 1.118"),
-        (array([[11, 12, 13, 14], [21, 22, 23, 24]]), {}, "17.5 ± 5.123"),
-        (3.141592653, {}, "3.142"),
-        (0, {}, "0"),
-        ("20", {}, "None"),
-        (None, {}, "None"),
-        (array(3.141592653), {"unit": "kg"}, "3.142 ± 0.0 kg"),
-        (array(3.141592653), {"ndigits": 4}, "3.1416 ± 0.0"),
-        (None, {"default": "Override"}, "Override"),
-    ],
-    ids=["scalar", "1d", "2d", "float", "zero", "str", "None", "float w/ unit", "float w/ ndigits", "None w/ default"]
-)
-def test_format_nd_array(value, kwargs, expected):
-    assert format_nd_array(value, **kwargs) == expected
-
-
-@mark.parametrize(
-    "value, kwargs, expected",
-    [
-        ("string", {}, "string"),
-        ("some_reserved:chars,get=replaced", {}, "some-reserved-chars-get-replaced"),
-        ([], {}, "None"),
-        (None, {}, "None"),
-        (None, {"default": "Override"}, "Override")
-    ],
-    ids=["legal chars", "illegal chars", "list", "None", "None w/ default"]
-)
-def test_format_str(value, kwargs, expected):
-    assert format_str(value, **kwargs) == expected

tests/models/test_resourceUseNotRelevant.py

@@ -1,27 +0,0 @@
-import os
-import json
-import pytest
-from unittest.mock import Mock, patch
-from tests.utils import fixtures_path, fake_new_indicator
-
-from hestia_earth.models.resourceUseNotRelevant import MODEL, run
-
-class_path = f"hestia_earth.models.{MODEL}"
-fixtures_folder = f"{fixtures_path}/{MODEL}"
-_folders = [d for d in os.listdir(fixtures_folder) if os.path.isdir(os.path.join(fixtures_folder, d))]
-
-
-@pytest.mark.parametrize('folder', _folders)
-@patch(f"{class_path}.get_land_cover_term_id")
-@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
-def test_run_forest(mock_new_indicator: Mock, mock_land_cover: Mock, folder: str):
-    mock_land_cover.return_value = folder
-
-    with open(f"{fixtures_folder}/{folder}/impact.jsonld", encoding='utf-8') as f:
-        impact = json.load(f)
-
-    with open(f"{fixtures_folder}/{folder}/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    result = run('all', impact)
-    assert result == expected, folder

tests/models/test_utils.py

@@ -1,6 +0,0 @@
-from hestia_earth.models.utils import current_date, max_date
-
-
-def test_max_date():
-    assert max_date('2100-01-01') == current_date()
-    assert max_date('2000-01-01') == '2000-01-01'

tests/models/transformation/input/test_excreta.py

@@ -1,49 +0,0 @@
-from unittest.mock import patch
-import json
-from hestia_earth.schema import TermTermType
-from tests.utils import fixtures_path, fake_new_input
-
-from hestia_earth.models.transformation.input.excreta import (
-    MODEL, MODEL_KEY, run, _should_run, _should_run_transformation
-)
-
-class_path = f"hestia_earth.models.{MODEL}.input.{MODEL_KEY}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/input/{MODEL_KEY}"
-
-
-def test_should_run():
-    # not a cycle => no run
-    data = {'@type': 'Transformation'}
-    assert not _should_run(data)
-
-    # as a cycle and no transformations => no run
-    data = {'@type': 'Cycle', 'transformations': []}
-    assert not _should_run(data)
-
-    # with a transformation => run
-    data['transformations'] = [{}]
-    assert _should_run(data) is True
-
-
-def test_should_run_transformation():
-    transformation = {'term': {}}
-
-    # not an excreta management => no run
-    transformation['term']['termType'] = TermTermType.ANIMALMANAGEMENT.value
-    assert not _should_run_transformation(transformation)
-
-    # is an excreta management => no run
-    transformation['term']['termType'] = TermTermType.EXCRETAMANAGEMENT.value
-    assert _should_run_transformation(transformation) is True
-
-
-@patch(f"{class_path}._new_input", side_effect=fake_new_input)
-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)
-
-    result = run(cycle)
-    assert result == expected

tests/models/transformation/input/test_max.py

@@ -1,34 +0,0 @@
-import json
-from tests.utils import fixtures_path
-
-from hestia_earth.models.transformation.input.max import (
-    MODEL, MODEL_KEY, run, _should_run
-)
-
-class_path = f"hestia_earth.models.{MODEL}.input.{MODEL_KEY}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/input/{MODEL_KEY}"
-
-
-def test_should_run():
-    # not a cycle => no run
-    data = {'@type': 'Transformation'}
-    assert not _should_run(data)
-
-    # as a cycle and no transformations => no run
-    data = {'@type': 'Cycle', 'transformations': []}
-    assert not _should_run(data)
-
-    # with a transformation => run
-    data['transformations'] = [{}]
-    assert _should_run(data) is True
-
-
-def test_run():
-    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)
-
-    result = run(cycle)
-    assert result == expected

tests/models/transformation/input/test_min.py

@@ -1,34 +0,0 @@
-import json
-from tests.utils import fixtures_path
-
-from hestia_earth.models.transformation.input.min import (
-    MODEL, MODEL_KEY, run, _should_run
-)
-
-class_path = f"hestia_earth.models.{MODEL}.input.{MODEL_KEY}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/input/{MODEL_KEY}"
-
-
-def test_should_run():
-    # not a cycle => no run
-    data = {'@type': 'Transformation'}
-    assert not _should_run(data)
-
-    # as a cycle and no transformations => no run
-    data = {'@type': 'Cycle', 'transformations': []}
-    assert not _should_run(data)
-
-    # with a transformation => run
-    data['transformations'] = [{}]
-    assert _should_run(data) is True
-
-
-def test_run():
-    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)
-
-    result = run(cycle)
-    assert result == expected