hestia-earth-models 0.70.0__py3-none-any.whl → 0.70.2__py3-none-any.whl

tests/models/utils/test_measurement.py

@@ -12,7 +12,7 @@ class_path = 'hestia_earth.models.utils.measurement'
 fixtures_folder = f"{fixtures_path}/utils/measurement"
 
 
-@patch(f"{class_path}.include_methodModel", side_effect=lambda n, **kwargs: n)
+@patch(f"{class_path}.include_method", side_effect=lambda n, **kwargs: n)
 @patch(f"{class_path}.download_term", return_value=TERM)
 def test_new_measurement(*args):
     # with a Term as string

hestia_earth/models/cycle/residueRemoved.py

@@ -1,54 +0,0 @@
-from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import list_sum
-
-from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.completeness import _is_term_type_incomplete
-from hestia_earth.models.utils.practice import _new_practice
-from . import MODEL
-
-REQUIREMENTS = {
-    "Cycle": {
-        "completeness.cropResidue": "False",
-        "products": [
-            {"@type": "Product", "term.@id": "aboveGroundCropResidueTotal", "value": "> 0"},
-            {"@type": "Product", "term.@id": "aboveGroundCropResidueRemoved", "value": "> 0"}
-        ]
-    }
-}
-RETURNS = {
-    "Practice": [{
-        "value": ""
-    }]
-}
-TERM_ID = 'residueRemoved'
-
-
-def _practice(value: float):
-    practice = _new_practice(TERM_ID)
-    practice['value'] = [value]
-    return practice
-
-
-def _should_run(cycle: dict):
-    crop_residue_incomplete = _is_term_type_incomplete(cycle, TermTermType.CROPRESIDUE)
-    products = cycle.get('products', [])
-    aboveGroundCropResidueTotal = list_sum(find_term_match(products, 'aboveGroundCropResidueTotal').get('value', [0]))
-    has_aboveGroundCropResidueTotal = aboveGroundCropResidueTotal > 0
-    aboveGroundCropResidueRemoved = list_sum(
-        find_term_match(products, 'aboveGroundCropResidueRemoved').get('value', [0]))
-    has_aboveGroundCropResidueRemoved = aboveGroundCropResidueRemoved > 0
-
-    logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    term_type_cropResidue_incomplete=crop_residue_incomplete,
-                    has_aboveGroundCropResidueTotal=has_aboveGroundCropResidueTotal,
-                    has_aboveGroundCropResidueRemoved=has_aboveGroundCropResidueRemoved)
-
-    should_run = all([crop_residue_incomplete, has_aboveGroundCropResidueTotal, has_aboveGroundCropResidueRemoved])
-    logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, aboveGroundCropResidueTotal, aboveGroundCropResidueRemoved
-
-
-def run(cycle: dict):
-    should_run, total, value = _should_run(cycle)
-    return [_practice(value / total * 100)] if should_run else []

hestia_earth/models/hestia/nh3ToSurfaceWaterAquacultureSystems.py

@@ -1,64 +0,0 @@
-from hestia_earth.schema import TermTermType, EmissionMethodTier
-from hestia_earth.models.utils.emission import _new_emission
-from hestia_earth.utils.model import filter_list_term_type
-from hestia_earth.models.utils.aquacultureManagement import valid_site_type
-from hestia_earth.models.utils.input import total_excreta_tan
-from . import MODEL
-
-
-REQUIREMENTS = {
-    "Cycle": {
-        "products": [{
-            "@type": "Product",
-            "term.termType": "excreta",
-            "term.@id": "excretaLiquidFishCrustaceansKgN"
-        }]
-    }
-}
-
-RETURNS = {
-    "Emission": [{
-        "value": "",
-        "methodTier": "tier 1"
-    }]
-}
-
-TIER = EmissionMethodTier.TIER_1.value
-TERM_ID = 'nh3ToSurfaceWaterAquacultureSystems'
-_EXCRETA_TERM_ID = 'excretaLiquidFishCrustaceansKgN'
-
-
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [round(value, 7)]
-    emission['methodTier'] = TIER
-    return emission
-
-
-def _run(excreta_products: list):
-    value = total_excreta_tan(excreta_products)
-    return [_emission(value)]
-
-
-def _valid_excreta(cycle: dict):
-    excreta_products = filter_list_term_type(cycle.get('products', []), TermTermType.EXCRETA.value)
-    valid_excreta_products = [
-        product for product in excreta_products if all([
-            product.get('term', {}).get('@id') == _EXCRETA_TERM_ID
-        ])
-    ]
-    return valid_excreta_products
-
-
-def _should_run(cycle: dict):
-    valid_excreta_products = _valid_excreta(cycle)
-    should_run = all([
-        valid_site_type(cycle),
-        bool(valid_excreta_products),
-    ])
-    return should_run, valid_excreta_products
-
-
-def run(cycle: dict):
-    should_run, valid_excreta_products = _should_run(cycle)
-    return _run(valid_excreta_products) if should_run else []

hestia_earth/models/site/utils.py

@@ -1,93 +0,0 @@
-from functools import reduce
-from hestia_earth.schema import TermTermType
-from hestia_earth.utils.tools import non_empty_list
-from hestia_earth.utils.date import DAY
-
-from hestia_earth.models.utils import _omit, first_day_of_month, last_day_of_month
-from hestia_earth.models.utils.measurement import _new_measurement, measurement_value, has_all_months
-
-
-def copy_measurement(term_id: str, data: dict):
-    measurement = _new_measurement(term_id)
-    return {
-        **_omit(data, ['description', 'methodModel']),
-        **measurement
-    }
-
-
-def _value_func(data: dict, apply_func, key: str = 'value'):
-    values = data.get(key, data.get('value', []))
-    return list(map(apply_func, values))
-
-
-def _slice_by_year(term_id: str, dates: list, values: list):
-    def group_values(group: dict, index: int):
-        try:
-            date = dates[index]
-            value = values[index]
-            month = dates[index][0:4]
-            group[month] = group.get(month, []) + [(date, value)]
-        except IndexError:
-            pass
-        return group
-
-    def iterate_values(data: list):
-        return (
-            measurement_value({
-                'term': {
-                    '@id': term_id,
-                    'termType': TermTermType.MEASUREMENT.value
-                },
-                'value': non_empty_list([v for (_d, v) in data])
-            }, is_larger_unit=True),
-            data[0][0],
-            data[-1][0]
-        ) if has_all_months([d for (d, _v) in data]) else None
-
-    values_by_month = reduce(group_values, range(0, len(dates)), {})
-    return non_empty_list(map(iterate_values, values_by_month.values()))
-
-
-def _extract_year_month(date: str):
-    try:
-        year = int(date[0:4])
-        month = int(date[5:7])
-        return year, month
-    except Exception:
-        return None, None
-
-
-def _group_by_month(term_id: str, dates: list, values: list):
-    def group_values(group: dict, index: int):
-        date = dates[index]
-        value = values[index]
-        month = dates[index][0:7]
-        group[month] = group.get(month, []) + [(date, value)]
-        return group
-
-    def map_to_month(data: list, year: int, month: int):
-        # make sure we got all the necessary days
-        difference = last_day_of_month(year, month) - first_day_of_month(year, month)
-        days_in_month = round(difference.days + difference.seconds / DAY, 1) + 1
-
-        return measurement_value({
-            'term': {
-                '@id': term_id,
-                'termType': TermTermType.MEASUREMENT.value
-            },
-            'value': non_empty_list([v for (_d, v) in data])
-        }, is_larger_unit=True) if len(data) == days_in_month else None
-
-    values_by_month = reduce(group_values, range(0, len(dates)), {}) if len(dates) == len(values) else {}
-
-    values = []
-    dates = []
-    for month, data in values_by_month.items():
-        year, m = _extract_year_month(data[0][0])
-        # date might not contain a year or a month, cannot handle it
-        value = map_to_month(data, year, m) if year and m else None
-        if value is not None:
-            dates.append(month)
-            values.append(value)
-
-    return values, dates

tests/models/cycle/test_residueRemoved.py

@@ -1,37 +0,0 @@
-from unittest.mock import patch
-import json
-from tests.utils import fake_new_practice, fixtures_path
-
-from hestia_earth.models.cycle.residueRemoved import MODEL, TERM_ID, _should_run, run
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-def test_should_run():
-    # no products => no run
-    cycle = {'completeness': {'cropResidue': False}, 'products': []}
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with `aboveGroundCropResidueTotal` => no run
-    cycle['products'].append({'term': {'@id': 'aboveGroundCropResidueTotal'}, 'value': [10]})
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with `aboveGroundCropResidueRemoved` => run
-    cycle['products'].append({'term': {'@id': 'aboveGroundCropResidueRemoved'}, 'value': [10]})
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
-
-
-@patch(f"{class_path}._new_practice", side_effect=fake_new_practice)
-def test_run(*args):
-    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
-        data = json.load(f)
-
-    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
-        expected = json.load(f)
-
-    result = run(data)
-    assert result == expected

tests/models/hestia/test_nh3ToSurfaceWaterAquacultureSystems.py

@@ -1,51 +0,0 @@
-from unittest.mock import patch
-import json
-from tests.utils import fixtures_path, fake_new_emission
-
-from hestia_earth.models.hestia.nh3ToSurfaceWaterAquacultureSystems import MODEL, TERM_ID, run, _should_run
-
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
-fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-
-
-@patch(f"{class_path}.valid_site_type", return_value=True)
-def test_should_run(mock_valid_excreta, *args):
-    cycle = {}
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # without the right type of excreta => no run
-    cycle['products'] = [
-        {
-            'term': {
-                '@id': 'excretaSolidFishCrustaceansKgN',
-                'termType': 'excreta'
-            }
-        }
-    ]
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with fish_excreta_tan => run
-    cycle['products'] = [
-        {
-            'term': {
-                '@id': 'excretaLiquidFishCrustaceansKgN',
-                'termType': 'excreta'
-            }
-        }
-    ]
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
-
-
-@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