fix: wrap dtw_distance/dtw_distance_missing to accept lists and numpy

The pointer-based refactor changed the C++ binding to require
nb::ndarray (numpy arrays). All existing tests and user code pass
Python lists. Added Python wrappers that auto-convert via np.asarray().

114/114 Python tests pass.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ElektrikAkar

python/dtwcpp/__init__.py

@@ -1,5 +1,7 @@
 """DTWC++ — Fast Dynamic Time Warping and Clustering."""
 
+import numpy as _np
+
 from dtwcpp._dtwcpp_core import (
     # Enums
     Method,
@@ -14,14 +16,14 @@
     Data,
     # Classes
     Problem,
-    # DTW functions
-    dtw_distance,
+    # DTW functions (raw C++ bindings — require numpy arrays)
+    dtw_distance as _dtw_distance_raw,
     ddtw_distance,
     wdtw_distance,
     adtw_distance,
     soft_dtw_distance,
     soft_dtw_gradient,
-    dtw_distance_missing,
+    dtw_distance_missing as _dtw_distance_missing_raw,
     # Algorithms
     fast_pam,
     fast_clara,
@@ -42,6 +44,31 @@
 
 __version__ = "1.0.0"
 
+
+# Wrappers that accept both lists and numpy arrays (the C++ nb::ndarray
+# binding only accepts numpy arrays; these auto-convert for convenience).
+def dtw_distance(x, y, band=-1, metric="l1"):
+    """Compute DTW distance between two time series.
+
+    Accepts lists or numpy arrays. metric: 'l1' (default) or 'squared_euclidean'.
+    band=-1 for full DTW, band>0 for Sakoe-Chiba banded DTW.
+    """
+    return _dtw_distance_raw(
+        _np.asarray(x, dtype=_np.float64),
+        _np.asarray(y, dtype=_np.float64),
+        band, metric)
+
+
+def dtw_distance_missing(x, y, band=-1, metric="l1"):
+    """DTW distance with missing data support (NaN = missing).
+
+    Accepts lists or numpy arrays. NaN values contribute zero cost.
+    """
+    return _dtw_distance_missing_raw(
+        _np.asarray(x, dtype=_np.float64),
+        _np.asarray(y, dtype=_np.float64),
+        band, metric)
+
 # Pure-Python sklearn-compatible layer
 from dtwcpp._clustering import DTWClustering