Enhance enum support in Streamlit panel and tests

- Added MyIntableFlags and MyIntableEnum classes to define new enum types.
- Updated all_types_with_values to include new enum types.
- Modified PanelValueAccessor to allow list values without type matching.
- Improved test coverage for enum types in StreamlitPanel.

Author: Mike Prosser

examples/all_types/all_types_panel.py

@@ -1,6 +1,6 @@
 """A Streamlit visualization panel for the all_types.py example script."""
 
-from enum import Enum
+from enum import Enum, Flag
 from typing import cast
 
 import streamlit as st
@@ -23,16 +23,20 @@
         st.write(name)
 
     with col2:
-        if isinstance(default_value, Enum):
-            nipanel.enum_selectbox(panel, label=name, value=cast(Enum, default_value), key=name)
-        elif isinstance(default_value, bool):
+        if isinstance(default_value, bool):
             st.checkbox(label=name, value=cast(bool, default_value), key=name)
-        elif isinstance(default_value, int):
+        elif isinstance(default_value, Enum) and not isinstance(default_value, Flag):
+            nipanel.enum_selectbox(panel, label=name, value=cast(Enum, default_value), key=name)
+        elif isinstance(default_value, int) and not isinstance(default_value, Flag):
             st.number_input(label=name, value=cast(int, default_value), key=name)
         elif isinstance(default_value, float):
             st.number_input(label=name, value=cast(float, default_value), key=name, format="%.2f")
         elif isinstance(default_value, str):
             st.text_input(label=name, value=cast(str, default_value), key=name)
 
     with col3:
-        st.write(panel.get_value(name))
+        value = panel.get_value(name)
+        value_with_default = panel.get_value(name, default_value=default_value)
+        st.write(value_with_default)
+        if str(value) != str(value_with_default):
+            st.write("(", value, ")")

examples/all_types/define_types.py

@@ -15,6 +15,14 @@ class MyIntFlags(enum.IntFlag):
     VALUE4 = 4
 
 
+class MyIntableFlags(enum.Flag):
+    """Example of an Flag enum with int values."""
+
+    VALUE1 = 1
+    VALUE2 = 2
+    VALUE4 = 4
+
+
 class MyIntEnum(enum.IntEnum):
     """Example of an IntEnum enum."""
 
@@ -23,6 +31,14 @@ class MyIntEnum(enum.IntEnum):
     VALUE30 = 30
 
 
+class MyIntableEnum(enum.Enum):
+    """Example of an enum with int values."""
+
+    VALUE100 = 100
+    VALUE200 = 200
+    VALUE300 = 300
+
+
 class MyStrEnum(str, enum.Enum):
     """Example of a mixin string enum."""
 
@@ -31,6 +47,22 @@ class MyStrEnum(str, enum.Enum):
     VALUE3 = "value3"
 
 
+class MyStringableEnum(enum.Enum):
+    """Example of an enum with string values."""
+
+    VALUE1 = "value1"
+    VALUE2 = "value2"
+    VALUE3 = "value3"
+
+
+class MyMixedEnum(enum.Enum):
+    """Example of an enum with mixed values."""
+
+    VALUE1 = "value1"
+    VALUE2 = 2
+    VALUE3 = 3.0
+
+
 all_types_with_values = {
     # supported scalar types
     "bool": True,
@@ -42,6 +74,10 @@ class MyStrEnum(str, enum.Enum):
     "intflags": MyIntFlags.VALUE1 | MyIntFlags.VALUE4,
     "intenum": MyIntEnum.VALUE20,
     "strenum": MyStrEnum.VALUE3,
+    "intableenum": MyIntableEnum.VALUE200,
+    "intableflags": MyIntableFlags.VALUE1 | MyIntableFlags.VALUE2,
+    "stringableenum": MyStringableEnum.VALUE2,
+    "mixedenum": MyMixedEnum.VALUE2,
     # NI types
     "nitypes_Scalar": Scalar(42, "m"),
     "nitypes_AnalogWaveform": AnalogWaveform.from_array_1d(np.array([1.0, 2.0, 3.0])),
@@ -62,6 +98,6 @@ class MyStrEnum(str, enum.Enum):
     # supported 2D collections
     "list_list_float": [[1.0, 2.0], [3.0, 4.0]],
     "tuple_tuple_float": ((1.0, 2.0), (3.0, 4.0)),
-    "set_list_float": set([(1.0, 2.0), (3.0, 4.0)]),
+    "set_tuple_float": set([(1.0, 2.0), (3.0, 4.0)]),
     "frozenset_frozenset_float": frozenset([frozenset([1.0, 2.0]), frozenset([3.0, 4.0])]),
 }

src/nipanel/_panel_value_accessor.py

@@ -72,9 +72,11 @@ def get_value(self, value_id: str, default_value: _T | None = None) -> _T | obje
                 enum_type = type(default_value)
                 return enum_type(value)
 
-            raise TypeError(
-                f"Value type {type(value).__name__} does not match default value type {type(default_value).__name__}."
-            )
+            # lists are allowed to not match, since sets and tuples are converted to lists
+            if not isinstance(value, list):
+                raise TypeError(
+                    f"Value type {type(value).__name__} does not match default value type {type(default_value).__name__}."
+                )
 
         return value
 
@@ -85,6 +87,9 @@ def set_value(self, value_id: str, value: object) -> None:
             value_id: The id of the value
             value: The value
         """
+        if isinstance(value, enum.Enum):
+            value = value.value
+
         self._panel_client.set_value(
             self._panel_id, value_id, value, notify=self._notify_on_set_value
         )

tests/types.py

@@ -21,6 +21,14 @@ class MyIntFlags(enum.IntFlag):
     VALUE4 = 4
 
 
+class MyIntableFlags(enum.Flag):
+    """Example of a simple flag with int values."""
+
+    VALUE8 = 8
+    VALUE16 = 16
+    VALUE32 = 32
+
+
 class MyIntEnum(enum.IntEnum):
     """Example of an IntEnum enum."""
 
@@ -53,17 +61,25 @@ class MixinStrEnum(str, enum.Enum):
     VALUE33 = "value33"
 
 
-class MyEnum(enum.Enum):
-    """Example of a simple enum."""
+class MyIntableEnum(enum.Enum):
+    """Example of a simple enum with int values."""
 
     VALUE100 = 100
     VALUE200 = 200
     VALUE300 = 300
 
 
-class MyFlags(enum.Flag):
-    """Example of a simple flag."""
+class MyStringableEnum(StrEnum):
+    """Example of a simple enum with str values."""
 
-    VALUE8 = 8
-    VALUE16 = 16
-    VALUE32 = 32
+    VALUE1 = "value10"
+    VALUE2 = "value20"
+    VALUE3 = "value30"
+
+
+class MyMixedEnum(enum.Enum):
+    """Example of an enum with mixed values."""
+
+    VALUE1 = "value1"
+    VALUE2 = 2
+    VALUE3 = 3.0

tests/unit/test_streamlit_panel.py

@@ -1,5 +1,7 @@
+import enum
 import grpc
 import pytest
+from datetime import datetime
 from typing_extensions import assert_type
 
 import tests.types as test_types
@@ -261,31 +263,63 @@ def test___set_string_enum_type___get_value_with_int_enum_default___raises_excep
         3.14,
         True,
         b"robotext",
+    ],
+)
+def test___builtin_scalar_type___set_value___gets_same_value(
+    fake_panel_channel: grpc.Channel,
+    value_payload: object,
+) -> None:
+    """Test that set_value() and get_value() work for builtin scalar types."""
+    panel = StreamlitPanel("my_panel", "path/to/script", grpc_channel=fake_panel_channel)
+
+    value_id = "test_id"
+    panel.set_value(value_id, value_payload)
+
+    assert panel.get_value(value_id) == value_payload
+
+
+@pytest.mark.parametrize(
+    "value_payload",
+    [
         test_types.MyIntFlags.VALUE1 | test_types.MyIntFlags.VALUE4,
+        test_types.MyIntableFlags.VALUE16 | test_types.MyIntableFlags.VALUE32,
         test_types.MyIntEnum.VALUE20,
+        test_types.MyIntableEnum.VALUE200,
         test_types.MyStrEnum.VALUE3,
+        test_types.MyStringableEnum.VALUE2,
         test_types.MixinIntEnum.VALUE33,
         test_types.MixinStrEnum.VALUE11,
+        test_types.MyMixedEnum.VALUE2,
     ],
 )
-def test___builtin_scalar_type___set_value___gets_same_value(
+def test___enum_type___set_value___gets_same_value(
     fake_panel_channel: grpc.Channel,
-    value_payload: object,
+    value_payload: enum.Enum,
 ) -> None:
     """Test that set_value() and get_value() work for builtin scalar types."""
     panel = StreamlitPanel("my_panel", "path/to/script", grpc_channel=fake_panel_channel)
 
     value_id = "test_id"
     panel.set_value(value_id, value_payload)
 
-    assert panel.get_value(value_id) == value_payload
+    # without providing a default value, get_value will return the raw value, not the enum
+    assert panel.get_value(value_id) == value_payload.value
 
 
 @pytest.mark.parametrize(
     "value_payload",
     [
-        test_types.MyEnum.VALUE300,
-        test_types.MyFlags.VALUE8 | test_types.MyFlags.VALUE16,
+        datetime.now(),
+        lambda x: x + 1,
+        [1, "string"],
+        ["string", []],
+        (42, "hello", 3.14, b"bytes"),
+        set([1, "mixed", True]),
+        (i for i in range(5)),
+        {
+            "key1": [1, 2, 3],
+            "key2": {"nested": True, "values": [4.5, 6.7]},
+        },
     ],
 )
 def test___unsupported_type___set_value___raises(
@@ -368,6 +402,22 @@ def test___set_int_enum_value___get_value___returns_int_enum(
     assert retrieved_value.name == enum_value.name
 
 
+def test___set_intable_enum_value___get_value___returns_enum(
+    fake_panel_channel: grpc.Channel,
+) -> None:
+    panel = StreamlitPanel("my_panel", "path/to/script", grpc_channel=fake_panel_channel)
+    value_id = "test_id"
+    enum_value = test_types.MyIntableEnum.VALUE200
+    panel.set_value(value_id, enum_value)
+
+    retrieved_value = panel.get_value(value_id, test_types.MyIntableEnum.VALUE100)
+
+    assert_type(retrieved_value, test_types.MyIntableEnum)
+    assert retrieved_value is test_types.MyIntableEnum.VALUE200
+    assert retrieved_value.value == enum_value.value
+    assert retrieved_value.name == enum_value.name
+
+
 def test___set_string_enum_value___get_value___returns_string_enum(
     fake_panel_channel: grpc.Channel,
 ) -> None:
@@ -384,6 +434,38 @@ def test___set_string_enum_value___get_value___returns_string_enum(
     assert retrieved_value.name == enum_value.name
 
 
+def test___set_stringable_enum_value___get_value___returns_enum(
+    fake_panel_channel: grpc.Channel,
+) -> None:
+    panel = StreamlitPanel("my_panel", "path/to/script", grpc_channel=fake_panel_channel)
+    value_id = "test_id"
+    enum_value = test_types.MyStringableEnum.VALUE3
+    panel.set_value(value_id, enum_value)
+
+    retrieved_value = panel.get_value(value_id, test_types.MyStringableEnum.VALUE1)
+
+    assert_type(retrieved_value, test_types.MyStringableEnum)
+    assert retrieved_value is test_types.MyStringableEnum.VALUE3
+    assert retrieved_value.value == enum_value.value
+    assert retrieved_value.name == enum_value.name
+
+
+def test___set_mixed_enum_value___get_value___returns_enum(
+    fake_panel_channel: grpc.Channel,
+) -> None:
+    panel = StreamlitPanel("my_panel", "path/to/script", grpc_channel=fake_panel_channel)
+    value_id = "test_id"
+    enum_value = test_types.MyMixedEnum.VALUE2
+    panel.set_value(value_id, enum_value)
+
+    retrieved_value = panel.get_value(value_id, test_types.MyMixedEnum.VALUE1)
+
+    assert_type(retrieved_value, test_types.MyMixedEnum)
+    assert retrieved_value is test_types.MyMixedEnum.VALUE2
+    assert retrieved_value.value == enum_value.value
+    assert retrieved_value.name == enum_value.name
+
+
 def test___set_int_flags_value___get_value___returns_int_flags(
     fake_panel_channel: grpc.Channel,
 ) -> None:
@@ -399,6 +481,22 @@ def test___set_int_flags_value___get_value___returns_int_flags(
     assert retrieved_value.value == flags_value.value
 
 
+def test___set_intable_flags_value___get_value___returns_flags(
+    fake_panel_channel: grpc.Channel,
+) -> None:
+    panel = StreamlitPanel("my_panel", "path/to/script", grpc_channel=fake_panel_channel)
+    value_id = "test_id"
+    flags_value = test_types.MyIntableFlags.VALUE16 | test_types.MyIntableFlags.VALUE32
+    panel.set_value(value_id, flags_value)
+
+    retrieved_value = panel.get_value(value_id, test_types.MyIntableFlags.VALUE8)
+
+    assert_type(retrieved_value, test_types.MyIntableFlags)
+    assert retrieved_value is test_types.MyIntableFlags.VALUE16 | test_types.MyIntableFlags.VALUE32
+    assert retrieved_value.value == flags_value.value
+    assert retrieved_value.name == flags_value.name
+
+
 def test___panel___panel_is_running_and_in_memory(
     fake_panel_channel: grpc.Channel,
 ) -> None: