Add a converter to/from Double2DArray. (#91)

* Add a converter to/from Double2DArray.

* Fix some variable names and remove a print.

Signed-off-by: Michael Johansen <[email protected]>

* Add set and frozenset tests.

Signed-off-by: Michael Johansen <[email protected]>

* Update the all types example.

Signed-off-by: Michael Johansen <[email protected]>

---------

Signed-off-by: Michael Johansen <[email protected]>
Co-authored-by: Michael Johansen <[email protected]>

Author: mjohanse-emr

examples/all_types/define_types.py

@@ -59,4 +59,9 @@ class MyStrEnum(str, enum.Enum):
     # NI types
     "nitypes_Scalar": Scalar(42, "m"),
     "nitypes_AnalogWaveform": AnalogWaveform.from_array_1d(np.array([1.0, 2.0, 3.0])),
+    # 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)]),
+    "frozenset_frozenset_float": frozenset([frozenset([1.0, 2.0]), frozenset([3.0, 4.0])]),
 }

src/nipanel/_convert.py

@@ -21,7 +21,11 @@
     IntCollectionConverter,
     StrCollectionConverter,
 )
-from nipanel.converters.protobuf_types import DoubleAnalogWaveformConverter, ScalarConverter
+from nipanel.converters.protobuf_types import (
+    Double2DArrayConverter,
+    DoubleAnalogWaveformConverter,
+    ScalarConverter,
+)
 
 _logger = logging.getLogger(__name__)
 
@@ -40,6 +44,7 @@
     IntCollectionConverter(),
     StrCollectionConverter(),
     # Protobuf Types
+    Double2DArrayConverter(),
     DoubleAnalogWaveformConverter(),
     ScalarConverter(),
 ]
@@ -66,25 +71,39 @@ def to_any(python_value: object) -> any_pb2.Any:
 def _get_best_matching_type(python_value: object) -> str:
     underlying_parents = type(python_value).mro()  # This covers enum.IntEnum and similar
 
-    container_type = None
-    value_is_collection = _CONVERTIBLE_COLLECTION_TYPES.intersection(underlying_parents)
-    if value_is_collection:
+    container_types = []
+    value_is_collection = any(_CONVERTIBLE_COLLECTION_TYPES.intersection(underlying_parents))
+    # Variable to use when traversing down through collection types.
+    working_python_value = python_value
+    while value_is_collection:
         # Assume Sized -- Generators not supported, callers must use list(), set(), ... as desired
-        if not isinstance(python_value, Collection):
+        if not isinstance(working_python_value, Collection):
             raise TypeError()
-        if len(python_value) == 0:
+        if len(working_python_value) == 0:
             underlying_parents = type(None).mro()
+            value_is_collection = False
         else:
             # Assume homogenous -- collections of mixed-types not supported
-            visitor = iter(python_value)
-            first_value = next(visitor)
-            underlying_parents = type(first_value).mro()
-        container_type = Collection
+            visitor = iter(working_python_value)
+
+            # Store off the first element. If it's a container, we'll need it in the next while
+            # loop iteration.
+            working_python_value = next(visitor)
+            underlying_parents = type(working_python_value).mro()
+
+            # If this element is a collection, we want to continue traversing. Once we find a
+            # non-collection, underlying_parents will refer to the candidates for the non-
+            # collection type.
+            value_is_collection = any(
+                _CONVERTIBLE_COLLECTION_TYPES.intersection(underlying_parents)
+            )
+        container_types.append(Collection.__name__)
 
     best_matching_type = None
     candidates = [parent.__name__ for parent in underlying_parents]
     for candidate in candidates:
-        python_typename = f"{container_type.__name__}.{candidate}" if container_type else candidate
+        containers_str = ".".join(container_types)
+        python_typename = f"{containers_str}.{candidate}" if containers_str else candidate
         if python_typename not in _SUPPORTED_PYTHON_TYPES:
             continue
         best_matching_type = python_typename
@@ -93,7 +112,8 @@ def _get_best_matching_type(python_value: object) -> str:
     if not best_matching_type:
         payload_type = underlying_parents[0]
         raise TypeError(
-            f"Unsupported type: ({container_type}, {payload_type}) with parents {underlying_parents}. Supported types are: {_SUPPORTED_PYTHON_TYPES}"
+            f"Unsupported type: ({container_types}, {payload_type}) with parents "
+            f"{underlying_parents}. Supported types are: {_SUPPORTED_PYTHON_TYPES}"
         )
     _logger.debug(f"Best matching type for '{repr(python_value)}' resolved to {best_matching_type}")
     return best_matching_type

src/nipanel/converters/protobuf_types.py

@@ -2,14 +2,17 @@
 
 from __future__ import annotations
 
-import collections.abc
 import datetime as dt
+from collections.abc import Collection, Mapping
 from typing import Type, Union
 
 import hightime as ht
 import nitypes.bintime as bt
 import numpy as np
 from ni.protobuf.types import scalar_pb2
+from ni_measurement_plugin_sdk_service._internal.stubs.ni.protobuf.types.array_pb2 import (
+    Double2DArray,
+)
 from ni_measurement_plugin_sdk_service._internal.stubs.ni.protobuf.types.precision_timestamp_pb2 import (
     PrecisionTimestamp,
 )
@@ -39,6 +42,51 @@
 }
 
 
+class Double2DArrayConverter(Converter[Collection[Collection[float]], Double2DArray]):
+    """A converter between Collection[Collection[float]] and Double2DArray."""
+
+    @property
+    def python_typename(self) -> str:
+        """The Python type that this converter handles."""
+        return f"{Collection.__name__}.{Collection.__name__}.{float.__name__}"
+
+    @property
+    def protobuf_message(self) -> Type[Double2DArray]:
+        """The type-specific protobuf message for the Python type."""
+        return Double2DArray
+
+    def to_protobuf_message(self, python_value: Collection[Collection[float]]) -> Double2DArray:
+        """Convert the Python Collection[Collection[float]] to a protobuf Double2DArray."""
+        rows = len(python_value)
+        if rows:
+            visitor = iter(python_value)
+            first_subcollection = next(visitor)
+            columns = len(first_subcollection)
+        else:
+            columns = 0
+        if not all(len(subcollection) == columns for subcollection in python_value):
+            raise ValueError("All subcollections must have the same length.")
+
+        # Create a flat list in row major order.
+        flat_list = [item for subcollection in python_value for item in subcollection]
+        return Double2DArray(rows=rows, columns=columns, data=flat_list)
+
+    def to_python_value(self, protobuf_message: Double2DArray) -> Collection[Collection[float]]:
+        """Convert the protobuf Double2DArray to a Python Collection[Collection[float]]."""
+        if not protobuf_message.data:
+            return []
+        if len(protobuf_message.data) % protobuf_message.columns != 0:
+            raise ValueError("The length of the data list must be divisible by num columns.")
+
+        # Convert from a flat list in row major order into a list of lists.
+        list_of_lists = []
+        for i in range(0, len(protobuf_message.data), protobuf_message.columns):
+            row = protobuf_message.data[i : i + protobuf_message.columns]
+            list_of_lists.append(row)
+
+        return list_of_lists
+
+
 class DoubleAnalogWaveformConverter(Converter[AnalogWaveform[np.float64], DoubleAnalogWaveform]):
     """A converter for AnalogWaveform types with scaled data (double)."""
 
@@ -81,7 +129,7 @@ def to_protobuf_message(self, python_value: AnalogWaveform[np.float64]) -> Doubl
     def _extended_properties_to_attributes(
         self,
         extended_properties: ExtendedPropertyDictionary,
-    ) -> collections.abc.Mapping[str, WaveformAttributeValue]:
+    ) -> Mapping[str, WaveformAttributeValue]:
         return {key: self._value_to_attribute(value) for key, value in extended_properties.items()}
 
     def _value_to_attribute(self, value: ExtendedPropertyValue) -> WaveformAttributeValue:

tests/unit/test_convert.py

@@ -1,11 +1,14 @@
-from typing import Any, Union
+from typing import Any, Collection, Union
 
 import numpy as np
 import pytest
 from google.protobuf import any_pb2, wrappers_pb2
 from google.protobuf.message import Message
 from ni.protobuf.types.scalar_pb2 import ScalarData
 from ni.pythonpanel.v1 import python_panel_types_pb2
+from ni_measurement_plugin_sdk_service._internal.stubs.ni.protobuf.types.array_pb2 import (
+    Double2DArray,
+)
 from ni_measurement_plugin_sdk_service._internal.stubs.ni.protobuf.types.waveform_pb2 import (
     DoubleAnalogWaveform,
 )
@@ -14,6 +17,7 @@
 from typing_extensions import TypeAlias
 
 import nipanel._convert
+import tests.types
 
 
 _AnyWrappersPb2: TypeAlias = Union[
@@ -44,6 +48,11 @@
         (456.2, "float"),
         (123, "int"),
         ("mystr", "str"),
+        (tests.types.MyIntFlags.VALUE1, "int"),
+        (tests.types.MyIntEnum.VALUE10, "int"),
+        (tests.types.MixinIntEnum.VALUE11, "int"),
+        (tests.types.MyStrEnum.VALUE1, "str"),
+        (tests.types.MixinStrEnum.VALUE11, "str"),
         ([False, False], "Collection.bool"),
         ([b"mystr", b"mystr"], "Collection.bytes"),
         ([456.2, 1.0], "Collection.float"),
@@ -69,6 +78,18 @@
         (frozenset([456.2, 1.0]), "Collection.float"),
         (frozenset([123, 456]), "Collection.int"),
         (frozenset(["mystr", "mystr2"]), "Collection.str"),
+        ([[1.0, 2.0], [1.0, 2.0]], "Collection.Collection.float"),
+        ([(1.0, 2.0), (3.0, 4.0)], "Collection.Collection.float"),
+        ([set([1.0, 2.0]), set([3.0, 4.0])], "Collection.Collection.float"),
+        ([frozenset([1.0, 2.0]), frozenset([3.0, 4.0])], "Collection.Collection.float"),
+        (([1.0, 2.0], [3.0, 4.0]), "Collection.Collection.float"),
+        (((1.0, 2.0), (3.0, 4.0)), "Collection.Collection.float"),
+        ((set([1.0, 2.0]), set([3.0, 4.0])), "Collection.Collection.float"),
+        ((frozenset([1.0, 2.0]), frozenset([3.0, 4.0])), "Collection.Collection.float"),
+        (set([(1.0, 2.0), (3.0, 4.0)]), "Collection.Collection.float"),
+        (set([frozenset([1.0, 2.0]), frozenset([3.0, 4.0])]), "Collection.Collection.float"),
+        (frozenset([(1.0, 2.0), (3.0, 4.0)]), "Collection.Collection.float"),
+        (frozenset([frozenset([1.0, 2.0]), frozenset([3.0, 4.0])]), "Collection.Collection.float"),
     ],
 )
 def test___various_python_objects___get_best_matching_type___returns_correct_type_string(
@@ -194,6 +215,63 @@ def test___python_analog_waveform___to_any___valid_double_analog_waveform() -> N
     assert list(unpack_dest.y_data) == [0.0, 0.0, 0.0]
 
 
+@pytest.mark.parametrize(
+    "python_value",
+    [
+        # lists of collections
+        ([[1.0, 2.0], [3.0, 4.0]]),
+        ([(1.0, 2.0), (3.0, 4.0)]),
+        ([set([1.0, 2.0]), set([3.0, 4.0])]),
+        ([frozenset([1.0, 2.0]), frozenset([3.0, 4.0])]),
+        # tuples of collections
+        (([1.0, 2.0], [3.0, 4.0])),
+        (((1.0, 2.0), (3.0, 4.0))),
+        ((set([1.0, 2.0]), set([3.0, 4.0]))),
+        ((frozenset([1.0, 2.0]), frozenset([3.0, 4.0]))),
+    ],
+)
+def test___python_2dcollection_of_float___to_any___valid_double2darray(
+    python_value: Collection[Collection[float]],
+) -> None:
+    expected_data = [1.0, 2.0, 3.0, 4.0]
+    expected_rows = 2
+    expected_columns = 2
+    result = nipanel._convert.to_any(python_value)
+    unpack_dest = Double2DArray()
+    _assert_any_and_unpack(result, unpack_dest)
+
+    assert isinstance(unpack_dest, Double2DArray)
+    assert unpack_dest.rows == expected_rows
+    assert unpack_dest.columns == expected_columns
+    assert unpack_dest.data == expected_data
+
+
+@pytest.mark.parametrize(
+    "python_value",
+    [
+        (set([(1.0, 2.0), (3.0, 4.0)])),
+        (set([frozenset([1.0, 2.0]), frozenset([3.0, 4.0])])),
+        (frozenset([(1.0, 2.0), (3.0, 4.0)])),
+        (frozenset([frozenset([1.0, 2.0]), frozenset([3.0, 4.0])])),
+    ],
+)
+def test___python_set_of_collection_of_float___to_any___valid_double2darray(
+    python_value: Collection[Collection[float]],
+) -> None:
+    expected_data = [1.0, 2.0, 3.0, 4.0]
+    expected_rows = 2
+    expected_columns = 2
+    result = nipanel._convert.to_any(python_value)
+    unpack_dest = Double2DArray()
+    _assert_any_and_unpack(result, unpack_dest)
+
+    assert isinstance(unpack_dest, Double2DArray)
+    assert unpack_dest.rows == expected_rows
+    assert unpack_dest.columns == expected_columns
+    # Sets and frozensets don't maintain order, so sort before comparing.
+    assert sorted(unpack_dest.data) == sorted(expected_data)
+
+
 # ========================================================
 # Protobuf Types: Protobuf to Python
 # ========================================================
@@ -219,6 +297,17 @@ def test___double_analog_waveform___from_any___valid_python_analog_waveform() ->
     assert result.dtype == np.float64
 
 
+def test___double2darray___from_any___valid_python_2dcollection() -> None:
+    pb_value = Double2DArray(data=[1.0, 2.0, 3.0, 4.0], rows=2, columns=2)
+    packed_any = _pack_into_any(pb_value)
+
+    result = nipanel._convert.from_any(packed_any)
+
+    expected_value = [[1.0, 2.0], [3.0, 4.0]]
+    assert isinstance(result, type(expected_value))
+    assert result == expected_value
+
+
 # ========================================================
 # Pack/Unpack Helpers
 # ========================================================