fixed coverage

Author: forman

tests/config/test_attrs.py

@@ -4,12 +4,14 @@
 
 import json
 import unittest
+from datetime import datetime
 
 import numpy as np
 import pytest
 
 from zappend.config.attrs import ConfigAttrsUserFunctions
 from zappend.config.attrs import eval_dyn_config_attrs
+from zappend.config.attrs import eval_expr
 from zappend.config.attrs import get_dyn_config_attrs_env
 from zappend.config.attrs import has_dyn_config_attrs
 from ..helpers import make_test_dataset
@@ -19,7 +21,7 @@ class EvalDynConfigAttrsTest(unittest.TestCase):
     def setUp(self):
         ds = make_test_dataset()
         ds.attrs["title"] = "Ocean Colour"
-        self.env = dict(ds=ds, N=10)
+        self.env = get_dyn_config_attrs_env(ds, N=10)
 
     def test_zero(self):
         self.assertEqual(
@@ -69,7 +71,7 @@ def test_x_min_max(self):
         )
         self.assertEqual(attrs, json.loads(json.dumps(attrs)))
 
-    def test_x_min_max_corr(self):
+    def test_x_min_max_center(self):
         attrs = eval_dyn_config_attrs(
             {
                 "x_min": "{{ ds.x[0] - (ds.x[1]-ds.x[0])/2 }}",
@@ -81,6 +83,18 @@ def test_x_min_max_corr(self):
         self.assertAlmostEqual(1.0, attrs.get("x_max"))
         self.assertEqual(attrs, json.loads(json.dumps(attrs)))
 
+    def test_x_bounds_center(self):
+        attrs = eval_dyn_config_attrs(
+            {
+                "x_min": "{{ lower_bound(ds.x, ref='center') }}",
+                "x_max": "{{ upper_bound(ds.x, ref='center') }}",
+            },
+            self.env,
+        )
+        self.assertAlmostEqual(0.0, attrs.get("x_min"))
+        self.assertAlmostEqual(1.0, attrs.get("x_max"))
+        self.assertEqual(attrs, json.loads(json.dumps(attrs)))
+
     def test_time_min_max(self):
         attrs = eval_dyn_config_attrs(
             {"time_min": "{{ ds.time[0] }}", "time_max": "{{ ds.time[-1] }}"}, self.env
@@ -91,6 +105,20 @@ def test_time_min_max(self):
         )
         self.assertEqual(attrs, json.loads(json.dumps(attrs)))
 
+    def test_time_bounds(self):
+        attrs = eval_dyn_config_attrs(
+            {
+                "time_min": "{{ lower_bound(ds.time) }}",
+                "time_max": "{{ upper_bound(ds.time) }}",
+            },
+            self.env,
+        )
+        self.assertEqual(
+            {"time_min": "2024-01-01T00:00:00", "time_max": "2024-01-04T00:00:00"},
+            attrs,
+        )
+        self.assertEqual(attrs, json.loads(json.dumps(attrs)))
+
 
 class HasDynConfigAttrsTest(unittest.TestCase):
     def test_no(self):
@@ -119,6 +147,56 @@ def test_yes(self):
         )
 
 
+class EvalExprTest(unittest.TestCase):
+    def test_all_cases(self):
+        self.assertEqual(True, eval_expr("True", {}))
+        self.assertEqual(13, eval_expr("13", {}))
+        self.assertEqual(0.5, eval_expr("0.5", {}))
+        self.assertEqual("ABC", eval_expr("'ABC'", {}))
+
+        switches = np.array([True, False])
+        self.assertEqual(
+            True,
+            eval_expr("switches[0]", {"switches": switches}),
+        )
+
+        levels = [3, 4, 5]
+        self.assertIs(
+            levels,
+            eval_expr("levels", {"levels": levels}),
+        )
+
+        levels = np.array([3, 4, 5])
+        self.assertEqual(
+            3,
+            eval_expr("levels[0]", {"levels": levels}),
+        )
+
+        lon = np.array([11.05, 11.15, 11.25])
+        self.assertIs(
+            lon,
+            eval_expr("lon", {"lon": lon}),
+        )
+
+        lon = np.array([11.05, 11.15, 11.25])
+        self.assertEqual(
+            11.05,
+            eval_expr("lon[0]", {"lon": lon}),
+        )
+
+        names = np.array(["A", "B"])
+        self.assertEqual(
+            "A",
+            eval_expr("names[0]", {"names": names}),
+        )
+
+        time = datetime.fromisoformat("2024-01-02T10:20:30")
+        self.assertEqual(
+            "2024-01-02T10:20:30",
+            eval_expr("time", {"time": time}),
+        )
+
+
 class GetDynConfigAttrsEnvTest(unittest.TestCase):
     def test_env(self):
         ds = make_test_dataset()
@@ -207,6 +285,7 @@ def _assert_bound_func_ok(
 
     def test_upper_lower_bounds_fail_for_wrong_shape(self):
         self._assert_upper_lower_bounds_fail(np.array(3))
+        self._assert_upper_lower_bounds_fail(np.array([]))
         self._assert_upper_lower_bounds_fail(np.array([[1, 2], [3, 4]]))
 
     # noinspection PyMethodMayBeStatic

zappend/config/attrs.py

@@ -64,29 +64,35 @@ def eval_attr_value(attr_value: Any, env: dict[str, Any]) -> Any:
 
 def eval_expr(expr: str, env: dict[str, Any]) -> Any:
     value = eval(expr, env)
+    if isinstance(value, (bool, int, float, str, type(None))):
+        return value
     if isinstance(value, datetime.datetime):
         return value.replace(microsecond=0).isoformat()
     try:
-        if np.ndim(value) == 0:
-            if np.issubdtype(value, int):
+        if value.ndim == 0:
+            if np.issubdtype(value.dtype, np.bool_):
+                return bool(value)
+            if np.issubdtype(value.dtype, np.integer):
                 return int(value)
-            if np.issubdtype(value, float):
+            if np.issubdtype(value.dtype, np.floating):
                 return float(value)
-            if np.issubdtype(value, np.datetime64):
+            if np.issubdtype(value.dtype, np.datetime64):
                 return np.datetime_as_string(value, unit="s")
-    except (TypeError, ValueError):
+    except AttributeError:
         pass
+    # TODO: this is not right, handle remaining cases or raise
     return value
 
 
-def get_dyn_config_attrs_env(ds: xr.Dataset):
+def get_dyn_config_attrs_env(ds: xr.Dataset, **kwargs):
     return dict(
         ds=ds,
         **{
             k: v
             for k, v in ConfigAttrsUserFunctions.__dict__.items()
             if not k.startswith("_")
         },
+        **kwargs,
     )