hestia-earth-models 0.61.7__py3-none-any.whl → 0.62.0__py3-none-any.whl

tests/models/utils/test_descriptive_stats.py

@@ -0,0 +1,134 @@
+from numpy import array, inf
+from numpy.testing import assert_almost_equal
+from pytest import mark
+
+from hestia_earth.schema import MeasurementStatsDefinition
+
+from hestia_earth.models.utils.descriptive_stats import (
+    _calc_confidence_level, calc_confidence_level_monte_carlo, calc_descriptive_stats, calc_precision_monte_carlo,
+    calc_required_iterations_monte_carlo, calc_z_critical
+)
+
+# confidence_level, n_sided, z_critical
+CONFIDENCE_INTERVAL_PARAMS = [
+    # 1 sided
+    (0, 1, -inf),
+    (50, 1, 0),
+    (80, 1, 0.8416),
+    (90, 1, 1.2816),
+    (95, 1, 1.6449),
+    (99, 1, 2.3263),
+    (100, 1, inf),
+    # 2 sided
+    (0, 2, 0),
+    (50, 2, 0.6745),
+    (80, 2, 1.2816),
+    (90, 2, 1.6449),
+    (95, 2, 1.9600),
+    (99, 2, 2.5758),
+    (100, 2, inf)
+]
+
+
+@mark.parametrize(
+    "confidence_level, n_sided, z_critical",
+    CONFIDENCE_INTERVAL_PARAMS,
+    ids=[f"z={z}, n={n}" for _, n, z in CONFIDENCE_INTERVAL_PARAMS]
+)
+def test_calc_confidence_level(confidence_level, n_sided, z_critical):
+    result = _calc_confidence_level(z_critical, n_sided=n_sided)
+    assert_almost_equal(result, confidence_level, decimal=2)
+
+
+@mark.parametrize(
+    "confidence_level, n_sided, z_critical",
+    CONFIDENCE_INTERVAL_PARAMS,
+    ids=[f"conf={conf}, n={n}" for conf, n, _ in CONFIDENCE_INTERVAL_PARAMS]
+)
+def test_calc_z_critical(confidence_level, n_sided, z_critical):
+    result = calc_z_critical(confidence_level, n_sided=n_sided)
+    assert_almost_equal(result, z_critical, decimal=4)
+
+
+# confidence_level, n_iterations, precision, sd
+MONTE_CARLO_PARAMS = [
+    (95, 80767, 0.01, 1.45),
+    (95, 1110, 0.01, 0.17),
+    (99, 1917, 0.01, 0.17),
+    (50, 102, 100.18, 1500)
+]
+
+
+@mark.parametrize(
+    "confidence_level, n_iterations, precision, sd",
+    MONTE_CARLO_PARAMS,
+    ids=[f"n={n}, prec={prec}, sd={sd}" for _, n, prec, sd in MONTE_CARLO_PARAMS]
+)
+def test_calc_confidence_level_monte_carlo(confidence_level, n_iterations, precision, sd):
+    result = calc_confidence_level_monte_carlo(n_iterations, precision, sd,)
+    assert_almost_equal(result, confidence_level, decimal=2)
+
+
+@mark.parametrize(
+    "confidence_level, n_iterations, precision, sd",
+    MONTE_CARLO_PARAMS,
+    ids=[f"conf={conf}, prec={prec}, sd={sd}" for conf, _, prec, sd in MONTE_CARLO_PARAMS]
+)
+def test_calc_required_iterations_monte_carlo(confidence_level, n_iterations, precision, sd):
+    result = calc_required_iterations_monte_carlo(confidence_level, precision, sd)
+    assert result == n_iterations
+
+
+@mark.parametrize(
+    "confidence_level, n_iterations, precision, sd",
+    MONTE_CARLO_PARAMS,
+    ids=[f"conf={conf}, n={n}, sd={sd}" for conf, n, _, sd in MONTE_CARLO_PARAMS]
+)
+def test_calc_precision_monte_carlo(confidence_level, n_iterations, precision, sd):
+    result = calc_precision_monte_carlo(confidence_level, n_iterations, sd)
+    assert_almost_equal(result, precision, decimal=2)
+
+
+EXPECTED_FLATTENED = {
+    "value": [5],
+    "sd": [2.581989],
+    "min": [1],
+    "max": [9],
+    "statsDefinition": "simulated",
+    "observations": [9]
+}
+
+EXPECTED_COLUMNWISE = {
+    "value": [4, 5, 6],
+    "sd": [2.44949, 2.44949, 2.44949],
+    "min": [1, 2, 3],
+    "max": [7, 8, 9],
+    "statsDefinition": "simulated",
+    "observations": [3, 3, 3]
+}
+
+EXPECTED_ROWWISE = {
+    "value": [2, 5, 8],
+    "sd": [0.816497, 0.816497, 0.816497],
+    "min": [1, 4, 7],
+    "max": [3, 6, 9],
+    "statsDefinition": "simulated",
+    "observations": [3, 3, 3]
+}
+
+
+@mark.parametrize(
+    "axis, expected",
+    [(None, EXPECTED_FLATTENED), (0, EXPECTED_COLUMNWISE), (1, EXPECTED_ROWWISE)],
+    ids=["flattened", "columnwise", "rowwise"]
+)
+@mark.parametrize("stats_definition", [MeasurementStatsDefinition.SIMULATED, "simulated"], ids=["Enum", "str"])
+def test_calc_descriptive_stats(stats_definition, axis, expected):
+    ARR = array([
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9]
+    ])
+
+    result = calc_descriptive_stats(ARR, stats_definition, axis=axis)
+    assert result == expected

tests/models/utils/test_emission.py

@@ -1,7 +1,10 @@
+from pytest import mark
 from unittest.mock import patch
 
+from hestia_earth.schema import EmissionMethodTier
+
 from tests.utils import TERM
-from hestia_earth.models.utils.emission import _new_emission, is_in_system_boundary
+from hestia_earth.models.utils.emission import _new_emission, is_in_system_boundary, min_emission_method_tier
 
 class_path = 'hestia_earth.models.utils.emission'
 
@@ -27,3 +30,50 @@ def test_new_emission(*args):
 def test_is_in_system_boundary():
     assert is_in_system_boundary('ch4ToAirCropResidueBurning') is True
     assert is_in_system_boundary('codToWaterInputsProduction') is False
+
+
+@mark.parametrize(
+    "input, expected",
+    [
+        (
+            (
+                EmissionMethodTier.TIER_1,
+                EmissionMethodTier.TIER_2,
+                EmissionMethodTier.TIER_3
+            ),
+            EmissionMethodTier.TIER_1
+        ),
+        (
+            [
+                EmissionMethodTier.TIER_1,
+                EmissionMethodTier.TIER_2,
+                EmissionMethodTier.TIER_3
+            ],
+            EmissionMethodTier.TIER_1
+        ),
+        (
+            [], EmissionMethodTier.NOT_RELEVANT
+        ),
+        (
+            (
+                EmissionMethodTier.TIER_1.value,
+                EmissionMethodTier.TIER_2.value,
+                EmissionMethodTier.TIER_3.value
+            ),
+            EmissionMethodTier.TIER_1
+        ),
+        (
+            [
+                EmissionMethodTier.TIER_1.value,
+                EmissionMethodTier.TIER_2.value,
+                EmissionMethodTier.TIER_3.value
+            ],
+            EmissionMethodTier.TIER_1
+        ),
+
+    ],
+    ids=["Enum", "list[Enum]", "None", "str", "list[str]"]
+)
+def test_min_emission_method_tier(input, expected):
+    result = min_emission_method_tier(input)
+    assert result == expected

tests/models/utils/test_measurement.py

@@ -1,9 +1,14 @@
-from unittest.mock import patch
 import json
+from pytest import mark
+from unittest.mock import patch
+
+from hestia_earth.schema import MeasurementMethodClassification
+
 from tests.utils import fixtures_path, TERM
 
 from hestia_earth.models.utils.measurement import (
-    _new_measurement, most_relevant_measurement_value, _most_recent_measurements, _shallowest_measurement
+    _new_measurement, most_relevant_measurement_value, _most_recent_measurements, _shallowest_measurement,
+    min_measurement_method_classification
 )
 
 class_path = 'hestia_earth.models.utils.measurement'
@@ -83,3 +88,50 @@ def test_shallowest_measurement():
         expected = json.load(f)
 
     assert _shallowest_measurement(measurements) == expected
+
+
+@mark.parametrize(
+    "input, expected",
+    [
+        (
+            (
+                MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+                MeasurementMethodClassification.TIER_2_MODEL,
+                MeasurementMethodClassification.TIER_1_MODEL
+            ),
+            MeasurementMethodClassification.TIER_1_MODEL
+        ),
+        (
+            [
+                MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT,
+                MeasurementMethodClassification.TIER_2_MODEL,
+                MeasurementMethodClassification.TIER_1_MODEL
+            ],
+            MeasurementMethodClassification.TIER_1_MODEL
+        ),
+        (
+            [], MeasurementMethodClassification.UNSOURCED_ASSUMPTION
+        ),
+        (
+            (
+                MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT.value,
+                MeasurementMethodClassification.TIER_2_MODEL.value,
+                MeasurementMethodClassification.TIER_1_MODEL.value
+            ),
+            MeasurementMethodClassification.TIER_1_MODEL
+        ),
+        (
+            [
+                MeasurementMethodClassification.ON_SITE_PHYSICAL_MEASUREMENT.value,
+                MeasurementMethodClassification.TIER_2_MODEL.value,
+                MeasurementMethodClassification.TIER_1_MODEL.value
+            ],
+            MeasurementMethodClassification.TIER_1_MODEL
+        ),
+
+    ],
+    ids=["Enum", "list[Enum]", "None", "str", "list[str]"]
+)
+def test_min_measurement_method_classification(input, expected):
+    result = min_measurement_method_classification(input)
+    assert result == expected