hestia-earth-models 0.72.2__py3-none-any.whl → 0.73.0__py3-none-any.whl

tests/models/akagiEtAl2011/test_ch4ToAirCropResidueBurning.py

@@ -0,0 +1,33 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.akagiEtAl2011.utils import MODEL
+from hestia_earth.models.akagiEtAl2011.ch4ToAirCropResidueBurning import TERM_ID, run
+
+class_path_utils = f"hestia_earth.models.{MODEL}.utils"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{class_path_utils}._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
+
+
+@patch(f"{class_path_utils}._new_emission", side_effect=fake_new_emission)
+def test_run_data_complete(*args):
+    with open(f"{fixtures_folder}/no-product-data-complete/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/no-product-data-complete/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/akagiEtAl2011/test_nh3ToAirCropResidueBurning.py

@@ -0,0 +1,33 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.akagiEtAl2011.utils import MODEL
+from hestia_earth.models.akagiEtAl2011.nh3ToAirCropResidueBurning import TERM_ID, run
+
+class_path_utils = f"hestia_earth.models.{MODEL}.utils"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{class_path_utils}._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
+
+
+@patch(f"{class_path_utils}._new_emission", side_effect=fake_new_emission)
+def test_run_data_complete(*args):
+    with open(f"{fixtures_folder}/no-product-data-complete/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/no-product-data-complete/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/{akagiEtAl2011AndIpcc2006 → akagiEtAl2011}/test_noxToAirCropResidueBurning.py

@@ -2,26 +2,14 @@ from unittest.mock import patch
 import json
 from tests.utils import fixtures_path, fake_new_emission
 
-from hestia_earth.models.akagiEtAl2011AndIpcc2006.noxToAirCropResidueBurning import MODEL, TERM_ID, run, _should_run
+from hestia_earth.models.akagiEtAl2011.utils import MODEL
+from hestia_earth.models.akagiEtAl2011.noxToAirCropResidueBurning import TERM_ID, run
 
-class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
+class_path_utils = f"hestia_earth.models.{MODEL}.utils"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 
-@patch(f"{class_path}._get_crop_residue_burnt_value")
-def test_should_run(mock_product_value, *args):
-    # no products => no run
-    mock_product_value.return_value = []
-    should_run, *args = _should_run({})
-    assert not should_run
-
-    # with products => run
-    mock_product_value.return_value = [0]
-    should_run, *args = _should_run({})
-    assert should_run is True
-
-
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+@patch(f"{class_path_utils}._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)
@@ -33,7 +21,7 @@ def test_run(*args):
     assert value == expected
 
 
-@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+@patch(f"{class_path_utils}._new_emission", side_effect=fake_new_emission)
 def test_run_data_complete(*args):
     with open(f"{fixtures_folder}/no-product-data-complete/cycle.jsonld", encoding='utf-8') as f:
         cycle = json.load(f)

tests/models/akagiEtAl2011/test_pm25ToAirCropResidueBurning.py

@@ -0,0 +1,33 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.akagiEtAl2011.utils import MODEL
+from hestia_earth.models.akagiEtAl2011.pm25ToAirCropResidueBurning import TERM_ID, run
+
+class_path_utils = f"hestia_earth.models.{MODEL}.utils"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{class_path_utils}._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
+
+
+@patch(f"{class_path_utils}._new_emission", side_effect=fake_new_emission)
+def test_run_data_complete(*args):
+    with open(f"{fixtures_folder}/no-product-data-complete/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/no-product-data-complete/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/akagiEtAl2011/test_so2ToAirCropResidueBurning.py

@@ -0,0 +1,33 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.akagiEtAl2011.utils import MODEL
+from hestia_earth.models.akagiEtAl2011.so2ToAirCropResidueBurning import TERM_ID, run
+
+class_path_utils = f"hestia_earth.models.{MODEL}.utils"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
+
+
+@patch(f"{class_path_utils}._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
+
+
+@patch(f"{class_path_utils}._new_emission", side_effect=fake_new_emission)
+def test_run_data_complete(*args):
+    with open(f"{fixtures_folder}/no-product-data-complete/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/no-product-data-complete/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/akagiEtAl2011/test_utils.py

@@ -0,0 +1,18 @@
+from unittest.mock import patch
+
+from hestia_earth.models.akagiEtAl2011.utils import MODEL, _should_run
+
+class_path = f"hestia_earth.models.{MODEL}.utils"
+
+
+@patch(f"{class_path}.get_crop_residue_burnt_value")
+def test_should_run(mock_product_value, *args):
+    # no products => no run
+    mock_product_value.return_value = []
+    should_run, *args = _should_run('', {})
+    assert not should_run
+
+    # with products => run
+    mock_product_value.return_value = [0]
+    should_run, *args = _should_run('', {})
+    assert should_run is True

tests/models/cycle/product/test_price.py

@@ -1,22 +1,12 @@
 import json
 from tests.utils import fixtures_path
 
-from hestia_earth.models.cycle.product.price import (
-    MODEL, MODEL_KEY, run, _should_run_product_by_share_0
-)
+from hestia_earth.models.cycle.product.price import MODEL, MODEL_KEY, run
 
 class_path = f"hestia_earth.models.{MODEL}.product.{MODEL_KEY}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/product/{MODEL_KEY}"
 
 
-def test_should_run_product_by_share_0():
-    product = {'term': {'@id': 'citrusFruit', 'termType': 'crop'}}
-    assert not _should_run_product_by_share_0({}, product)
-
-    product = {'term': {'@id': 'nitrogenUptakeEdiblePart', 'termType': 'crop'}}
-    assert _should_run_product_by_share_0({}, product) is True
-
-
 def test_run():
     with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
         cycle = json.load(f)

tests/models/dammgen2009/test_noxToAirExcreta.py

@@ -2,27 +2,47 @@ from unittest.mock import patch
 import json
 from tests.utils import fixtures_path, fake_new_emission
 
-from hestia_earth.models.dammgen2009.noxToAirExcreta import MODEL, TERM_ID, run, _should_run
+from hestia_earth.models.dammgen2009.noxToAirExcreta import MODEL, TERM_ID, run, _should_run, N2O_TERM_ID
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
 
 
-@patch(f"{class_path}.total_excreta", return_value=None)
-@patch(f"{class_path}.get_lookup_factor", return_value=None)
-def test_should_run(mock_get_lookup_factor, mock_excreta):
+def test_should_run():
     # no practice factor => no run
     should_run, *args = _should_run({})
     assert not should_run
 
-    # no excreta => no run
-    mock_get_lookup_factor.return_value = 10
-    should_run, *args = _should_run({})
+    # without N20 term in cycle.emissions => no run
+    should_run, *args = _should_run(
+        {
+            "type": "Cycle",
+            "emissions": [{
+                "@type": "Emission",
+                "term": {
+                    "@id": "ch4ToAirExcreta",
+                    "termType": "emission"
+                },
+                "value": [8.7],
+            }]
+        }
+    )
     assert not should_run
 
-    # with excretaKgN => run
-    mock_excreta.return_value = 10
-    should_run, *args = _should_run({})
+    # with N20 term in cycle => run
+    should_run, *args = _should_run(
+        {
+            "type": "Cycle",
+            "emissions": [{
+                "@type": "Emission",
+                "term": {
+                    "@id": N2O_TERM_ID,
+                    "termType": "emission"
+                },
+                "value": [10.7],
+            }]
+         }
+    )
     assert should_run is True
 
 

tests/models/geospatialDatabase/test_utils.py

@@ -14,7 +14,8 @@ COUNTRY = {
 
 def test_get_region_factor():
     site = {'country': COUNTRY}
-    assert get_region_factor('croppingIntensity', site, TermTermType.LANDUSEMANAGEMENT) == 0.9999775685587958
+    value = get_region_factor('croppingIntensity', site, TermTermType.LANDUSEMANAGEMENT)
+    assert round(value, 5) == 0.99998
 
 
 @patch(f"{class_path}.download_term", return_value={'area': AREA})

tests/models/hestia/test_default_emissions.py

@@ -0,0 +1,25 @@
+import os
+import json
+import pytest
+from unittest.mock import patch
+
+from tests.utils import fixtures_path, fake_new_emission
+from hestia_earth.models.hestia.default_emissions import MODEL, MODEL_KEY, run
+
+class_path = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{MODEL_KEY}"
+_folders = [d for d in os.listdir(fixtures_folder) if os.path.isdir(os.path.join(fixtures_folder, d))]
+
+
+@pytest.mark.parametrize("subfolder", _folders)
+@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+def test_run(mock, subfolder: str):
+    folder = f"{fixtures_folder}/{subfolder}"
+    with open(f"{folder}/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    result = run(cycle)
+    assert result == expected

tests/models/hestia/test_default_resourceUse.py

@@ -0,0 +1,26 @@
+import os
+import json
+import pytest
+from unittest.mock import patch
+
+from tests.utils import fixtures_path, fake_new_indicator
+from hestia_earth.models.hestia.default_resourceUse import MODEL, MODEL_KEY, run
+
+class_path = f"hestia_earth.models.{MODEL}.{MODEL_KEY}"
+fixtures_folder = f"{fixtures_path}/{MODEL}/{MODEL_KEY}"
+_folders = [d for d in os.listdir(fixtures_folder) if os.path.isdir(os.path.join(fixtures_folder, d))]
+
+
+@pytest.mark.parametrize("subfolder", _folders)
+@patch(f"{class_path}._new_indicator", side_effect=fake_new_indicator)
+def test_run(mock, subfolder: str):
+    folder = f"{fixtures_folder}/{subfolder}"
+    with open(f"{folder}/impact.jsonld", encoding='utf-8') as f:
+        impact = json.load(f)
+
+    with open(f"{folder}/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    result = run(impact)
+    print(json.dumps(result, indent=2))
+    assert result == expected

tests/models/hestia/test_landCover.py

@@ -6,7 +6,7 @@ from unittest.mock import patch
 from tests.utils import fixtures_path, fake_new_management
 from hestia_earth.models.faostat2018.utils import MODEL as FAOSTAT_MODEL
 from hestia_earth.models.hestia.landCover import (
-    MODEL, MODEL_KEY, get_changes, _estimate_maximum_forest_change,
+    MODEL, MODEL_KEY, _get_changes, _estimate_maximum_forest_change,
     run, site_area_sum_to_100, _get_sums_of_crop_expansion, _get_sum_for_land_category, scale_values_to_one,
     _get_most_common_or_alphabetically_first
 )
@@ -66,7 +66,7 @@ def test_get_most_common_or_alphabetically_first(terms, expected_output):
 
 
 def test_get_changes():
-    result, missing_values = get_changes(
+    result, missing_values = _get_changes(
         country_id="GADM-AFG",
         end_year=2010
     )

tests/models/ipcc2019/test_ch4ToAirAquacultureSystems.py

@@ -37,14 +37,14 @@ fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
             {
                 'cycleDuration': 150,
                 'functionalUnit': 'relative',
-                'site': {'area': 1000, 'measurements': [{'term': {'@id': 'salineWater'}}]}
+                'site': {'area': 1000, 'measurements': [{'term': {'@id': 'salineWater', 'termType': 'measurement'}}]}
             },
             True
         )
     ]
 )
 def test_should_run(test_name, cycle, expected_should_run):
-    should_run = _should_run(cycle)
+    should_run, *args = _should_run(cycle)
     assert should_run == expected_should_run, test_name
 
 

tests/models/{akagiEtAl2011AndIpcc2006/test_nh3ToAirCropResidueBurning.py → ipcc2019/test_n2OToAirCropResidueBurningDirect.py}

@@ -2,13 +2,13 @@ from unittest.mock import patch
 import json
 from tests.utils import fixtures_path, fake_new_emission
 
-from hestia_earth.models.akagiEtAl2011AndIpcc2006.nh3ToAirCropResidueBurning import MODEL, TERM_ID, run, _should_run
+from hestia_earth.models.ipcc2019.n2OToAirCropResidueBurningDirect 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}._get_crop_residue_burnt_value")
+@patch(f"{class_path}.get_crop_residue_burnt_value")
 def test_should_run(mock_product_value, *args):
     # no products => no run
     mock_product_value.return_value = []

tests/models/test_resourceUseNotRelevant.py

@@ -0,0 +1,27 @@
+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/{akagiEtAl2011AndIpcc2006/test_utils.py → utils/test_cropResidue.py}

@@ -1,26 +1,26 @@
 from unittest.mock import patch
 
-from hestia_earth.models.akagiEtAl2011AndIpcc2006.utils import _get_crop_residue_burnt_value
+from hestia_earth.models.utils.cropResidue import get_crop_residue_burnt_value
 
-class_path = 'hestia_earth.models.akagiEtAl2011AndIpcc2006.utils'
+class_path = 'hestia_earth.models.utils.cropResidue'
 
 
 @patch(f"{class_path}.find_term_match", return_value=None)
 @patch(f"{class_path}._is_term_type_complete", return_value=False)
-def test_get_crop_residue_burnt_value(mock_data_complete, mock_find_product):
+def testget_crop_residue_burnt_value(mock_data_complete, mock_find_product):
     # product not found no data complete
     mock_data_complete.return_value = False
     mock_find_product.return_value = {}
-    value = _get_crop_residue_burnt_value({})
+    value = get_crop_residue_burnt_value({})
     assert value == []
 
     # product not found and data complete
     mock_data_complete.return_value = True
     mock_find_product.return_value = {}
-    value = _get_crop_residue_burnt_value({})
+    value = get_crop_residue_burnt_value({})
     assert value == [0]
 
     # product found
     mock_find_product.return_value = {'value': [100]}
-    value = _get_crop_residue_burnt_value({})
+    value = get_crop_residue_burnt_value({})
     assert value == [100, 100]

hestia_earth/models/akagiEtAl2011AndIpcc2006/ch4ToAirCropResidueBurning.py

@@ -1,57 +0,0 @@
-from hestia_earth.schema import EmissionMethodTier
-
-from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import _get_crop_residue_burnt_value
-from . import MODEL
-
-REQUIREMENTS = {
-    "Cycle": {
-        "or": {
-            "products": [{
-                "@type": "Product",
-                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
-                "value": ""
-            }],
-            "completeness.cropResidue": "True"
-        }
-    }
-}
-RETURNS = {
-    "Emission": [{
-        "value": "",
-        "methodTier": "tier 1"
-    }]
-}
-TERM_ID = 'ch4ToAirCropResidueBurning'
-TIER = EmissionMethodTier.TIER_1.value
-DRY_MATTER_FACTOR_TO_CH4 = 5.82/1000
-
-
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
-def _run(product_value: list):
-    value = sum(product_value)
-    return [_emission(value * DRY_MATTER_FACTOR_TO_CH4)]
-
-
-def _should_run(cycle: dict):
-    crop_residue_burnt_value = _get_crop_residue_burnt_value(cycle)
-    has_crop_residue_burnt = len(crop_residue_burnt_value) > 0
-
-    logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_crop_residue_burnt=has_crop_residue_burnt)
-
-    should_run = all([has_crop_residue_burnt])
-    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, crop_residue_burnt_value
-
-
-def run(cycle: dict):
-    should_run, crop_residue_burnt_value = _should_run(cycle)
-    return _run(crop_residue_burnt_value) if should_run else []

hestia_earth/models/akagiEtAl2011AndIpcc2006/nh3ToAirCropResidueBurning.py

@@ -1,57 +0,0 @@
-from hestia_earth.schema import EmissionMethodTier
-
-from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import _get_crop_residue_burnt_value
-from . import MODEL
-
-REQUIREMENTS = {
-    "Cycle": {
-        "or": {
-            "products": [{
-                "@type": "Product",
-                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
-                "value": ""
-            }],
-            "completeness.cropResidue": "True"
-        }
-    }
-}
-RETURNS = {
-    "Emission": [{
-        "value": "",
-        "methodTier": "tier 1"
-    }]
-}
-TERM_ID = 'nh3ToAirCropResidueBurning'
-TIER = EmissionMethodTier.TIER_1.value
-DRY_MATTER_FACTOR_TO_NH3 = 2.17/1000
-
-
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
-def _run(product_value: list):
-    value = sum(product_value)
-    return [_emission(value * DRY_MATTER_FACTOR_TO_NH3)]
-
-
-def _should_run(cycle: dict):
-    crop_residue_burnt_value = _get_crop_residue_burnt_value(cycle)
-    has_crop_residue_burnt = len(crop_residue_burnt_value) > 0
-
-    logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_crop_residue_burnt=has_crop_residue_burnt)
-
-    should_run = all([has_crop_residue_burnt])
-    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, crop_residue_burnt_value
-
-
-def run(cycle: dict):
-    should_run, crop_residue_burnt_value = _should_run(cycle)
-    return _run(crop_residue_burnt_value) if should_run else []

hestia_earth/models/akagiEtAl2011AndIpcc2006/noxToAirCropResidueBurning.py

@@ -1,57 +0,0 @@
-from hestia_earth.schema import EmissionMethodTier
-
-from hestia_earth.models.log import logRequirements, logShouldRun
-from hestia_earth.models.utils.emission import _new_emission
-from .utils import _get_crop_residue_burnt_value
-from . import MODEL
-
-REQUIREMENTS = {
-    "Cycle": {
-        "or": {
-            "products": [{
-                "@type": "Product",
-                "term.@id": ["aboveGroundCropResidueBurnt", "discardedCropBurnt"],
-                "value": ""
-            }],
-            "completeness.cropResidue": "True"
-        }
-    }
-}
-RETURNS = {
-    "Emission": [{
-        "value": "",
-        "methodTier": "tier 1"
-    }]
-}
-TERM_ID = 'noxToAirCropResidueBurning'
-TIER = EmissionMethodTier.TIER_1.value
-DRY_MATTER_FACTOR_TO_NOX = 3.11/1000
-
-
-def _emission(value: float):
-    emission = _new_emission(TERM_ID, MODEL)
-    emission['value'] = [value]
-    emission['methodTier'] = TIER
-    return emission
-
-
-def _run(product_value: list):
-    value = sum(product_value)
-    return [_emission(value * DRY_MATTER_FACTOR_TO_NOX)]
-
-
-def _should_run(cycle: dict):
-    crop_residue_burnt_value = _get_crop_residue_burnt_value(cycle)
-    has_crop_residue_burnt = len(crop_residue_burnt_value) > 0
-
-    logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    has_crop_residue_burnt=has_crop_residue_burnt)
-
-    should_run = all([has_crop_residue_burnt])
-    logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
-    return should_run, crop_residue_burnt_value
-
-
-def run(cycle: dict):
-    should_run, crop_residue_burnt_value = _should_run(cycle)
-    return _run(crop_residue_burnt_value) if should_run else []

hestia_earth/models/akagiEtAl2011AndIpcc2006/utils.py

@@ -1,15 +0,0 @@
-from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import find_term_match
-from hestia_earth.utils.tools import flatten
-
-from hestia_earth.models.utils.completeness import _is_term_type_complete
-
-
-def _get_crop_residue_burnt_value(cycle: dict):
-    products = cycle.get('products', [])
-    value = flatten([
-        find_term_match(products, 'aboveGroundCropResidueBurnt').get('value', []),
-        find_term_match(products, 'discardedCropBurnt').get('value', [])
-    ])
-    data_complete = _is_term_type_complete(cycle, TermTermType.CROPRESIDUE)
-    return [0] if len(value) == 0 and data_complete else value