hestia-earth-models 0.59.5__py3-none-any.whl → 0.59.6__py3-none-any.whl

tests/models/faostat2018/test_liveweightPerHead.py

@@ -1,61 +1,125 @@
 from unittest.mock import patch
 import json
 
-from hestia_earth.schema import TermTermType
 from tests.utils import fixtures_path, fake_new_property
 
-from hestia_earth.models.faostat2018.liveweightPerHead import MODEL, TERM_ID, _should_run, run
+from hestia_earth.models.faostat2018.liveweightPerHead import MODEL, TERM_ID, run
 
 class_path = f"hestia_earth.models.{MODEL}.{TERM_ID}"
 fixtures_folder = f"{fixtures_path}/{MODEL}/{TERM_ID}"
-FAO_TERM = {
-    '@id': 'meatChickenReadyToCookWeight',
-    '@type': 'Term',
-    'units': 'kg ready-to-cook weight',
-    'defaultProperties': [{
-        'term': {'@id': 'processingConversionLiveweightToColdCarcassWeight', 'units': '%'},
-        'value': 72.30401869158878
-    }, {
-        'term': {'@id': 'processingConversionColdCarcassWeightToReadyToCookWeight', 'units': '%'},
-        'value': 72.45065789473684
-    }]
-}
-
-
-def test_should_run():
-    cycle = {}
-
-    # no animal products => no run
-    should_run, *args = _should_run(cycle)
-    assert not should_run
-
-    # with animal products => no run
-    cycle['products'] = [
-        {
-            'term': {
-                'termType': TermTermType.ANIMALPRODUCT.value,
-                'units': 'kg liveweight'
+
+
+@patch(f"{class_path}._new_property", side_effect=fake_new_property)
+def test_run_animalProduct(*args):
+    with open(f"{fixtures_folder}/animalProduct/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/animalProduct/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}._new_property", side_effect=fake_new_property)
+@patch(f"{class_path}.download_hestia")
+def test_run_liveAnimal_chicken(mock_download_hestia, *args):
+    with open(f"{fixtures_folder}/liveAnimal/chicken/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/liveAnimal/chicken/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    mock_download_hestia.return_value = {
+        "@id": "meatChickenReadyToCookWeight",
+        "@type": "Term",
+        "units": "kg ready-to-cook weight",
+        "defaultProperties": [
+            {
+                "term": {
+                    "@type": "Term",
+                    "name": "Processing conversion, liveweight to cold carcass weight",
+                    "termType": "property",
+                    "@id": "processingConversionLiveweightToColdCarcassWeight",
+                    "units": "%"
+                },
+                "value": 72.30401869158878,
+                "@type": "Property"
+            },
+            {
+                "term": {
+                    "@type": "Term",
+                    "name": "Processing conversion, cold carcass weight to ready-to-cook weight",
+                    "termType": "property",
+                    "@id": "processingConversionColdCarcassWeightToReadyToCookWeight",
+                    "units": "%"
+                },
+                "value": 72.45065789473684,
+                "@type": "Property"
             }
-        }
-    ]
-    should_run, *args = _should_run(cycle)
-    assert not should_run
+        ]
+    }
+    value = run(cycle)
+    assert value == expected
+
+
+@patch(f"{class_path}._new_property", side_effect=fake_new_property)
+@patch(f"{class_path}.download_hestia")
+def test_run_liveAnimal_pig(mock_download_hestia, *args):
+    with open(f"{fixtures_folder}/liveAnimal/pig/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
 
-    # with an endDate and country => run
-    cycle['endDate'] = '2020'
-    cycle['site'] = {'country': {'@id': 'GADM-GBR'}}
-    should_run, *args = _should_run(cycle)
-    assert should_run is True
+    with open(f"{fixtures_folder}/liveAnimal/pig/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    mock_download_hestia.return_value = {
+        "@id": "meatPigColdDressedCarcassWeight",
+        "@type": "Term",
+        "units": "kg cold dressed carcass weight",
+        "defaultProperties": [
+            {
+                "term": {
+                    "@type": "Term",
+                    "name": "Processing conversion, liveweight to cold carcass weight",
+                    "termType": "property",
+                    "@id": "processingConversionLiveweightToColdCarcassWeight",
+                    "units": "%"
+                },
+                "value": 75.22666597366735,
+                "@type": "Property"
+            }
+        ]
+    }
+    value = run(cycle)
+    assert value == expected
 
 
-@patch(f"hestia_earth.models.{MODEL}.utils.download_hestia", return_value=FAO_TERM)
 @patch(f"{class_path}._new_property", side_effect=fake_new_property)
-def test_run(*args):
-    with open(f"{fixtures_folder}/cycle.jsonld", encoding='utf-8') as f:
+@patch(f"{class_path}.download_hestia")
+def test_run_liveAnimal_sheepLamb(mock_download_hestia, *args):
+    with open(f"{fixtures_folder}/liveAnimal/sheepLamb/cycle.jsonld", encoding='utf-8') as f:
         cycle = json.load(f)
 
-    with open(f"{fixtures_folder}/result.jsonld", encoding='utf-8') as f:
+    with open(f"{fixtures_folder}/liveAnimal/sheepLamb/result.jsonld", encoding='utf-8') as f:
         expected = json.load(f)
 
+    mock_download_hestia.return_value = {
+        "@id": "meatSheepColdDressedCarcassWeight",
+        "@type": "Term",
+        "units": "kg cold dressed carcass weight",
+        "defaultProperties": [
+            {
+                "term": {
+                    "@type": "Term",
+                    "name": "Processing conversion, liveweight to cold carcass weight",
+                    "termType": "property",
+                    "@id": "processingConversionLiveweightToColdCarcassWeight",
+                    "units": "%"
+                },
+                "value": 47.301833667687326,
+                "@type": "Property"
+            }
+        ]
+    }
     value = run(cycle)
     assert value == expected

tests/models/ipcc2019/test_organicCarbonPerHa.py

@@ -106,6 +106,7 @@ def find_term_property_side_effect(term: dict, property: str, *_):
 # subfolder, load_cycles
 RUN_SUBFOLDERS = [
     ("tier-1-and-2/cropland", True),
+    ("tier-1-and-2/with-zero-carbon-input", True),  # Closes issue 777
     ("tier-2/with-generalised-monthly-measurements", True),  # Closes issue 600
     ("tier-2/with-incomplete-climate-data", True),  # Closes issue 599
     ("tier-2/with-initial-soc", True),
@@ -227,6 +228,13 @@ def test_calc_water_factor():
     assert _calc_water_factor(1, 1) == _calc_water_factor(1000, 1000)
 
 
+def test_calc_water_factor_zero():
+    """
+    Closes issue 771. Function should not raise 0 error and should return the maximum water factor.
+    """
+    assert _calc_water_factor(0, 0) == 1.49961875
+
+
 # --- IPCC SOIL CATEGORY TESTS ---
 
 

tests/models/schmidt2007/test_h2SToAirWasteTreatment.py

@@ -0,0 +1,45 @@
+from unittest.mock import patch
+import json
+from tests.utils import fixtures_path, fake_new_emission
+
+from hestia_earth.models.schmidt2007.h2SToAirWasteTreatment 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_waste_values")
+def test_should_run(mock_get_waste_values):
+    # no fuel values => no run
+    mock_get_waste_values.return_value = []
+    should_run, *args = _should_run({})
+    assert not should_run
+
+    # with fuel values => run
+    mock_get_waste_values.return_value = [0]
+    should_run, *args = _should_run({})
+    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
+
+
+@patch(f"{class_path}._new_emission", side_effect=fake_new_emission)
+def test_run_data_complete(*args):
+    with open(f"{fixtures_folder}/no-input-data-complete/cycle.jsonld", encoding='utf-8') as f:
+        cycle = json.load(f)
+
+    with open(f"{fixtures_folder}/no-input-data-complete/result.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+
+    value = run(cycle)
+    assert value == expected

tests/models/utils/test_blank_node.py

@@ -1,8 +1,10 @@
 from datetime import datetime
 import pytest
+from pytest import mark
 from unittest.mock import patch
 
 from hestia_earth.schema import SiteSiteType
+from hestia_earth.utils.tools import parse
 
 from hestia_earth.models.utils.blank_node import (
     _calc_datetime_range_intersection_duration,
@@ -552,13 +554,31 @@ GROUP_NODES_BY_YEAR_SCENARIO_A_CYCLES = [
 ]
 
 
-def test_group_nodes_by_year_scenario_a():
+@mark.parametrize(
+    "system_datetime",
+    [
+        datetime(2024, 5, 1),  # Closes issue 772
+        datetime(2024, 1, 1),  # Jan 1st
+        datetime(2024, 2, 29),  # Leap year
+        datetime(2024, 12, 31),  # Dec 31st
+        # 3 random dates...
+        datetime(2030, 5, 4),
+        datetime(2035, 7, 22),
+        datetime(2047, 8, 14)
+    ],
+    ids=lambda system_datetime: f"system_datetime = {datetime.strftime(system_datetime, r'%Y-%m-%d')}"
+)
+@patch("hestia_earth.utils.tools.parse")
+def test_group_nodes_by_year_scenario_a(mock_parse, system_datetime):
     """
     Datestr in format `YYYY`. Some nodes missing `startDate` field. One multi-year cycle.
 
     Incomplete datestrs are gapfilled by default; with `endDate` datestrs snapping to the end
     of the calendar year, and `startDate` datestrs snapping to the beginning of the calendar
     year.
+
+    A bug used to occur in this function when it was run on the first day of a calendar month (e.g., 2024-04-01). To
+    verify that the bug is fixed we have simulated running the function on a variety of different dates.
     """
 
     EXPECTED = {
@@ -597,6 +617,9 @@ def test_group_nodes_by_year_scenario_a():
         }]
     }
 
+    # As we can't mock builtin method datetime.now(), we have to pass our test system_datetime into the parse function.
+    mock_parse.side_effect = lambda *args, **kwargs: parse(*args, default=system_datetime, **kwargs)
+
     result = group_nodes_by_year(GROUP_NODES_BY_YEAR_SCENARIO_A_CYCLES)
     assert result == EXPECTED
 
@@ -965,7 +988,26 @@ def test_group_nodes_by_year_missing_dates():
     assert result == EXPECTED
 
 
-def test_group_nodes_by_year_multiple_values_and_dates():
+@mark.parametrize(
+    "system_datetime",
+    [
+        datetime(2024, 5, 1),  # Closes issue 772
+        datetime(2024, 1, 1),  # Jan 1st
+        datetime(2024, 2, 29),  # Leap year
+        datetime(2024, 12, 31),  # Dec 31st
+        # 3 random dates...
+        datetime(2026, 5, 14),
+        datetime(2032, 10, 10),
+        datetime(2043, 8, 22)
+    ],
+    ids=lambda system_datetime: f"system_datetime = {datetime.strftime(system_datetime, r'%Y-%m-%d')}"
+)
+@patch("hestia_earth.utils.tools.parse")
+def test_group_nodes_by_year_multiple_values_and_dates(mock_parse, system_datetime):
+    """
+    A bug used to occur in this function when it was run on the first day of a calendar month (e.g., 2024-04-01). To
+    verify that the bug is fixed we have simulated running the function on a variety of different dates.
+    """
 
     NODES = [{
         "value": [1, 2, 3, 4, 5],
@@ -1005,11 +1047,34 @@ def test_group_nodes_by_year_multiple_values_and_dates():
         }]
     }
 
+    # As we can't mock builtin method datetime.now(), we have to pass our test system_datetime into the parse function.
+    mock_parse.side_effect = lambda *args, **kwargs: parse(*args, default=system_datetime, **kwargs)
+
     result = group_nodes_by_year(NODES, mode=GroupNodesByYearMode.DATES)
     assert result == EXPECTED
 
 
-def test_group_nodes_by_year_and_month():
+@mark.parametrize(
+    "system_datetime",
+    [
+        datetime(2024, 5, 1),  # Closes issue 772
+        datetime(2024, 1, 1),  # Jan 1st
+        datetime(2024, 2, 29),  # Leap year
+        datetime(2024, 12, 31),  # Dec 31st
+        # 3 random dates...
+        datetime(2026, 4, 6),
+        datetime(2034, 7, 24),
+        datetime(2049, 10, 10)
+    ],
+    ids=lambda system_datetime: f"system_datetime = {datetime.strftime(system_datetime, r'%Y-%m-%d')}"
+)
+@patch("hestia_earth.utils.tools.parse")
+def test_group_nodes_by_year_and_month(mock_parse, system_datetime):
+    """
+    A bug used to occur in this function when it was run on the first day of a calendar month (e.g., 2024-04-01). To
+    verify that the bug is fixed we have simulated running the function on a variety of different dates.
+    """
+
     MANAGEMENT = [
         {
             "term.@id": "fullTillage",
@@ -1064,5 +1129,8 @@ def test_group_nodes_by_year_and_month():
         }
     }
 
+    # As we can't mock builtin method datetime.now(), we have to pass our test system date into the parse function.
+    mock_parse.side_effect = lambda *args, **kwargs: parse(*args, default=system_datetime, **kwargs)
+
     result = group_nodes_by_year_and_month(MANAGEMENT)
     assert result == EXPECTED

hestia_earth/models/cycle/pre_checks/startDate.py

@@ -1,52 +0,0 @@
-"""
-Pre Checks Start Date
-
-This model calculates the
-[startDate](https://hestia.earth/schema/Cycle#startDate) from the
-[endDate](https://hestia.earth/schema/Cycle#endDate) and
-[cycleDuration](https://hestia.earth/schema/Cycle#cycleDuration).
-"""
-from dateutil.relativedelta import relativedelta
-from hestia_earth.utils.date import is_in_days
-from hestia_earth.utils.tools import safe_parse_date
-
-from hestia_earth.models.log import logRequirements, logShouldRun
-from .. import MODEL
-
-REQUIREMENTS = {
-    "Cycle": {
-        "endDate": "",
-        "cycleDuration": ""
-    }
-}
-RETURNS = {
-    "Cycle": {
-        "startDate": ""
-    }
-}
-MODEL_KEY = 'startDate'
-
-
-def _run(cycle: dict):
-    days = -float(cycle.get('cycleDuration'))
-    return (safe_parse_date(cycle.get('endDate')) + relativedelta(days=days)).strftime('%Y-%m-%d')
-
-
-def _should_run(cycle: dict):
-    has_full_date = is_in_days(cycle.get('endDate'))
-    cycleDuration = cycle.get('cycleDuration')
-
-    logRequirements(cycle, model=MODEL, key=MODEL_KEY,
-                    has_full_date=has_full_date,
-                    cycleDuration=cycleDuration)
-
-    should_run = all([
-        has_full_date,
-        cycleDuration is not None,
-        cycle.get(MODEL_KEY) is None
-    ])
-    logShouldRun(cycle, MODEL, None, should_run, key=MODEL_KEY)
-    return should_run
-
-
-def run(cycle: dict): return {**cycle, MODEL_KEY: _run(cycle)} if _should_run(cycle) else cycle

tests/models/cycle/pre_checks/test_startDate.py

@@ -1,44 +0,0 @@
-import json
-from tests.utils import fixtures_path
-
-from hestia_earth.models.cycle.pre_checks.startDate import run, _should_run
-
-fixtures_folder = f"{fixtures_path}/cycle/pre_checks/startDate"
-
-
-def test_should_run():
-    cycle = {}
-
-    # no endDate => no run
-    cycle['endDate'] = None
-    assert not _should_run(cycle)
-
-    cycle['endDate'] = '2010'
-    # no cycleDuration => no run
-    cycle['cycleDuration'] = None
-    assert not _should_run(cycle)
-
-    cycle['cycleDuration'] = 120
-    # with a startDate => no run
-    cycle['startDate'] = '2010'
-    assert not _should_run(cycle)
-
-    cycle['startDate'] = None
-    # endDate not precise enough => no run
-    cycle['endDate'] = '2020-01'
-    assert not _should_run(cycle)
-
-    # endDate is precise enough => run
-    cycle['endDate'] = '2020-01-01'
-    assert _should_run(cycle) 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)
-
-    value = run(cycle)
-    assert value == expected