DRAFT: add validation in python for NormalAccessor

.gitignore

@@ -24,3 +24,5 @@ static
 .pnp.loader.mjs
 node_modules
 *.h5
+.env
+data.json

DEVELOP.md

@@ -64,6 +64,14 @@ Anywidget and its dependency ipywidgets handles the serialization from Python in
 
 Push a new tag to the main branch of the format `v*`. A new version will be published to PyPI automatically.
 
+## Contribute
+
+We run linting and formating on all pull requests. You can perform that operation locally with `pre-commit`.
+```
+pip install -U pre-commit
+pre-commit run --all-files
+```
+
 ## Documentation website
 
 The documentation website is generated with `mkdocs` and [`mkdocs-material`](https://squidfunk.github.io/mkdocs-material). After `poetry install`, you can serve the docs website locally with

lonboard/_serialization.py

@@ -63,6 +63,17 @@ def serialize_float_accessor(data: Union[int, float, NDArray[np.floating]], obj)
     return serialize_pyarrow_column(data, max_chunksize=obj._rows_per_chunk)
 
 
+def serialize_normal_accessor(data: Union[List[Union[int, float]], np.ndarray], obj):
+    if data is None:
+        return None
+
+    if isinstance(data, list):
+        return data
+
+    assert isinstance(data, (pa.ChunkedArray, pa.Array))
+    return serialize_pyarrow_column(data, max_chunksize=obj._rows_per_chunk)
+
+
 def serialize_table(data, obj):
     assert isinstance(data, pa.Table), "expected pyarrow table"
     return serialize_table_to_parquet(data, max_chunksize=obj._rows_per_chunk)
@@ -78,3 +89,4 @@ def infer_rows_per_chunk(table: pa.Table) -> int:
 # TODO: rename as it's used for text as well
 FLOAT_SERIALIZATION = {"to_json": serialize_float_accessor}
 TABLE_SERIALIZATION = {"to_json": serialize_table}
+NORMAL_SERIALIZATION = {"to_json": serialize_normal_accessor}

lonboard/experimental/traits.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
+import warnings
 from typing import Any, List, Tuple, Union
 
 import matplotlib as mpl
 import numpy as np
 import pyarrow as pa
 from traitlets.traitlets import TraitType
 
-from lonboard._serialization import (
-    COLOR_SERIALIZATION,
-)
+from lonboard._serialization import COLOR_SERIALIZATION, NORMAL_SERIALIZATION
 from lonboard.traits import FixedErrorTraitType
 
 
@@ -86,7 +85,7 @@ def validate(
         if isinstance(value, str):
             try:
                 c = mpl.colors.to_rgba(value)  # type: ignore
-            except ValueError:
+            except Exception:
                 self.error(
                     obj,
                     value,
@@ -95,9 +94,104 @@ def validate(
                         "matplotlib.colors.to_rgba."
                     ),
                 )
-                return
 
             return tuple(map(int, (np.array(c) * 255).astype(np.uint8)))
 
         self.error(obj, value)
         assert False
+
+
+class NormalAccessor(FixedErrorTraitType):
+    """
+    A representation of a deck.gl normal accessor
+
+    Acceptable inputs:
+    - A numpy ndarray with two dimensions: The size of the
+    second dimension must be 3 i.e. `(N,3)`
+    - a pyarrow `FixedSizeListArray` or
+    `ChunkedArray` containing `FixedSizeListArray`s
+    where the size of the inner fixed size list 3.
+    """
+
+    default_value = [0, 0, 1]
+    info_text = (
+        "List representing normal of each object, in [nx, ny, nz]. or numpy ndarray or "
+        "pyarrow FixedSizeList representing the normal of each object, in [nx, ny, nz]"
+    )
+
+    def __init__(
+        self: TraitType,
+        *args,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.tag(sync=True, **NORMAL_SERIALIZATION)
+
+    def validate(
+        self, obj, value
+    ) -> Union[Tuple[int, ...], List[int], pa.ChunkedArray, pa.FixedSizeListArray]:
+        """
+        Values in acceptable types must be contiguous
+        (the same length for all values) and of floating point type
+        """
+
+        fixed_list_size = 3
+
+        if isinstance(value, List):
+            if len(value) != 3:
+                self.error("Normal array must have length 3, (x,y,z)")
+
+            if not all(isinstance(item, float) for item in value):
+                self.error("All elements of Normal array must be floating point type")
+
+            return pa.FixedSizeListArray.from_arrays(value, fixed_list_size)
+
+        if isinstance(value, np.ndarray):
+            if value.ndim != 2 or value.shape[1] != 3:
+                self.error(obj, value, info="Normal array must be 2D with shape (N,3)")
+
+            if not np.any(value == 1):
+                self.error(
+                    obj, value, info="One of the normal vector elements must be 1."
+                )
+
+            if not np.issubdtype(value.dtype, np.float32):
+                warnings.warn(
+                    """Warning: Numpy array should be floating point type.
+                    Converting to float32 point pyarrow array"""
+                )
+                value = value.cast(pa.list_(pa.float32()))
+
+            return pa.FixedSizeListArray.from_arrays(value, fixed_list_size)
+
+        if isinstance(value, (pa.ChunkedArray, pa.Array)):
+            if not pa.types.is_fixed_size_list(value.type):
+                self.error(
+                    obj, value, info="Point pyarrow array must be a FixedSizeList."
+                )
+
+            if value.type.list_size != 3:
+                self.error(
+                    obj,
+                    value,
+                    info=(
+                        """Normal pyarrow array must have a
+                        FixedSizeList inner size of 3."""
+                    ),
+                )
+
+            if not pa.types.is_floating(value.type.value_type):
+                try:
+                    value = value.cast(pa.list_(pa.float32()))
+                except Exception:
+                    self.error(
+                        obj,
+                        value,
+                        info="""Failed to convert array
+                        values to floating point type""",
+                    )
+
+                return pa.FixedSizeListArray.from_arrays(value, fixed_list_size)
+
+        self.error(obj, value)
+        assert False