turn expressions into tendencies too

Replace DerivedWaveform with an ExpressionTendency on the single Waveform
class, integrated with develop's import/static waveforms. Bare scalars are
now classified by content: a number is a constant, a string that references
another waveform or uses an operator/function is an expression, and a plain
word is a literal string constant. Explicit {value:}/{expression:} override
the heuristic. Example config uses the compact bare form.

Author: DaanVanVugt

tests/test_configuration.py

@@ -255,6 +255,7 @@ def test_dump_comments():
 
     yaml_str = dedent("""
     globals:
+      version: 2
       dd_version: 3.42.0
       imports:
         ec_launchers: imas:hdf5?path=test_md
@@ -284,6 +285,7 @@ def test_dump_globals():
     dumped_yaml = config.dump()
     expected_dump = dedent("""
     globals:
+      version: 2
       dd_version: 3.41.0
       imports:
         ec_launchers: imas:mdsplus?path=test

tests/test_derived_waveform.py

@@ -0,0 +1,109 @@
+import numpy as np
+import pytest
+
+from waveform_editor.configuration import WaveformConfiguration
+from waveform_editor.waveform import Waveform
+
+
+@pytest.fixture
+def config():
+    config = WaveformConfiguration()
+    config.add_group("root_group", [])
+    return config
+
+
+@pytest.fixture
+def filled_config(config):
+    waveform_list = [
+        {
+            "user_type": "linear",
+            "user_from": 10,
+            "user_to": 20,
+            "user_start": 5,
+            "user_end": 15,
+            "line_number": 1,
+        }
+    ]
+    waveform = Waveform(waveform=waveform_list, name="waveform/1")
+    config.add_waveform(waveform, ["root_group"])
+    return config
+
+
+def make_expression(config, name, expr, add=True):
+    """Create an expression waveform bound to ``config``."""
+    waveform = Waveform(
+        waveform=[{"user_expression": expr, "line_number": 0}],
+        name=name,
+        config=config,
+    )
+    if add:
+        config.add_waveform(waveform, ["root_group"])
+    return waveform
+
+
+def test_constant_expression(config):
+    waveform = make_expression(config, "waveform/1", "3")
+    assert waveform.is_expression
+    assert not waveform.is_categorical
+    assert waveform.dependencies == set()
+    _, value = waveform.get_value(np.linspace(0, 100, 101))
+    assert np.all(value == 3)
+
+
+def test_dependent_waveform(filled_config):
+    waveform = make_expression(filled_config, "waveform/2", '"waveform/1"')
+    assert waveform.dependencies == {"waveform/1"}
+    time, value = waveform.get_value()
+    assert time[0] == 5
+    assert time[-1] == 15
+    assert value[0] == 10
+    assert value[-1] == 20
+    _, value = waveform.get_value(np.array([0, 5, 10, 15, 20]))
+    assert np.all(value == [10, 10, 15, 20, 20])
+
+
+def test_dependent_waveform_calc(filled_config):
+    waveform = make_expression(filled_config, "waveform/2", '"waveform/1" * 10')
+    assert waveform.dependencies == {"waveform/1"}
+    _, value = waveform.get_value(np.array([0, 5, 10, 15, 20]))
+    assert np.all(value == [100, 100, 150, 200, 200])
+
+
+def test_dependent_waveform_numpy(filled_config):
+    waveform = make_expression(
+        filled_config, "waveform/2", 'maximum("waveform/1" * 10, 150)'
+    )
+    assert waveform.dependencies == {"waveform/1"}
+    _, value = waveform.get_value(np.array([0, 5, 10, 15, 20]))
+    assert np.all(value == [150, 150, 150, 200, 200])
+
+
+def test_rename_dependency(filled_config):
+    waveform = make_expression(filled_config, "waveform/2", '"waveform/1"', add=False)
+    assert waveform.dependencies == {"waveform/1"}
+    waveform.rename_dependency("waveform/1", "waveform/3")
+    assert waveform.dependencies == {"waveform/3"}
+
+
+def test_function_access_control(filled_config):
+    test_exprs = [
+        ('max("waveform/1")', False),
+        ('sum("waveform/1")', False),
+        ('eval("waveform/1")', False),
+        ('dot("waveform/1", "waveform/1")', False),
+        ('linalg.norm("waveform/1")', False),
+        ('linalg.inv("waveform/1")', False),
+        ('sin("waveform/1")', True),
+        ('log("waveform/1" + 1)', True),
+        ('maximum("waveform/1", 10)', True),
+    ]
+
+    time = np.linspace(filled_config.start, filled_config.end, 100)
+    for expr, allowed in test_exprs:
+        waveform = make_expression(filled_config, "waveform/2", expr, add=False)
+        if allowed:
+            _, result = waveform.get_value(time)
+            assert result is not None
+        else:
+            with pytest.raises(NameError):
+                waveform.get_value(time)

tests/test_expression.py

@@ -1,4 +1,5 @@
 globals:
+  version: 2
   dd_version: 4.0.0
   imports: {}
 dummy_waveform:

tests/test_yaml/example.yaml

@@ -2,7 +2,7 @@
 from pytest import approx
 
 from waveform_editor.configuration import WaveformConfiguration
-from waveform_editor.derived_waveform import DerivedWaveform
+from waveform_editor.static_waveform import StaticWaveform
 from waveform_editor.tendencies.constant import ConstantTendency
 from waveform_editor.tendencies.linear import LinearTendency
 from waveform_editor.tendencies.periodic.sawtooth_wave import SawtoothWaveTendency
@@ -132,19 +132,47 @@ def test_scientific_notation(yaml_parser):
 
 
 def test_constant_shorthand_notation(yaml_parser):
-    """Test if shorthand notation is parsed correctly."""
+    """A bare scalar is shorthand for a single constant tendency."""
 
     waveforms = {"waveform: 5": 5, "waveform: 1.23": 1.23}
 
-    for waveform, expected_value in waveforms.items():
-        waveform = yaml_parser.parse_waveform(waveform)
-        assert isinstance(waveform, DerivedWaveform)
-        assert waveform.yaml == expected_value
-        assert not waveform.annotations
+    for waveform_str, expected_value in waveforms.items():
+        waveform = yaml_parser.parse_waveform(waveform_str)
+        assert isinstance(waveform, Waveform)
+        assert not waveform.is_expression
         assert waveform.dependencies == set()
+        assert waveform.tendencies[0].value == expected_value
+        assert not waveform.annotations
         assert not yaml_parser.parse_errors
 
 
+def test_bare_word_is_literal_string(yaml_parser):
+    """A bare plain word is a literal string constant, not an expression."""
+    waveform = yaml_parser.parse_waveform("waveform: total")
+    assert isinstance(waveform, StaticWaveform)
+    assert not waveform.is_expression
+    assert waveform.value == "total"
+    assert not yaml_parser.parse_errors
+
+
+def test_bare_number_is_constant(yaml_parser):
+    """A bare number is a constant tendency, not an expression."""
+    waveform = yaml_parser.parse_waveform("waveform: 3.5")
+    assert isinstance(waveform, Waveform)
+    assert not waveform.is_expression
+    assert waveform.tendencies[0].value == 3.5
+    assert not yaml_parser.parse_errors
+
+
+def test_bare_reference_is_expression(yaml_parser):
+    """A bare string that references another waveform (quoted) is an expression."""
+    waveform = yaml_parser.parse_waveform('waveform: \'"other/1" * 2\'')
+    assert isinstance(waveform, Waveform)
+    assert waveform.is_expression
+    assert waveform.dependencies == {"other/1"}
+    assert not yaml_parser.parse_errors
+
+
 def test_load_yaml(config):
     """Test if yaml is loaded correctly."""
     yaml_str = """

tests/test_yaml_parser.py

@@ -28,6 +28,23 @@ def get_value(
     def get_yaml_string(self) -> str:
         raise NotImplementedError
 
+    @property
+    def dependencies(self):
+        """Names of other waveforms this waveform depends on. Empty unless the waveform
+        contains expressions (overridden by :class:`Waveform`)."""
+        return set()
+
+    @property
+    def is_expression(self):
+        """Whether this waveform is computed from an expression. False by default."""
+        return False
+
+    def prepare_expression(self):  # noqa: B027
+        """Re-parse expression tendencies. No-op for waveforms without expressions."""
+
+    def rename_dependency(self, old_name, new_name):  # noqa: B027
+        """Rename a referenced waveform. No-op for waveforms without expressions."""
+
     def get_metadata(self, dd_version):
         """Parses the name of the waveform and returns the IDS metadata for this
         waveform. The name must be formatted as follows: ``<IDS-Name>/<IDS-path>``