Fix InterpolatorKNNBarycentric writability + split-mappings padding

Bugfixes surfaced while integrating InterpolatorKNNBarycentric into the
autolens FitImaging eager numpy path:

- `_mappings_sizes_weights` was returning np.asarray() of jax outputs,
  which gives a read-only view. ConstantSplit's `reg_split_np_from` uses
  in-place assignment and raised "assignment destination is read-only".
  On the numpy path, materialize with np.array() to get a writable buffer.
- `_mappings_sizes_weights_split` returned a k=3 mappings array. The
  ConstantSplit code writes `splitted_mappings[i][j+1]` for the central
  pixel insertion, requiring an extra reserved column. Match
  InterpolatorDelaunay's hstack-append pattern.
- Add `import numpy as np` at module scope (was implicitly available
  through `jax.numpy as jnp` aliasing for Wendland-only paths).
- New regression-guard test confirms numpy-path mappings/weights are
  writable.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: 2 people

autoarray/inversion/mesh/interpolator/knn.py

@@ -1,3 +1,5 @@
+import numpy as np
+
 from autoconf import cached_property
 
 from autoarray.inversion.mesh.interpolator.delaunay import InterpolatorDelaunay
@@ -357,8 +359,16 @@ def _mappings_sizes_weights(self):
             xp=self._xp,
         )
 
-        mappings = self._xp.asarray(mappings)
-        weights = self._xp.asarray(weights)
+        # On the numpy path, materialize with `np.array(...)` so the regularization
+        # code (which uses in-place assignment, e.g. `reg_split_np_from`) gets a
+        # writable buffer rather than a read-only view of a jax.Array. On the jax
+        # path, asarray is the right cast (no copy in a JIT trace).
+        if self._xp is np:
+            mappings = np.array(mappings)
+            weights = np.array(weights)
+        else:
+            mappings = self._xp.asarray(mappings)
+            weights = self._xp.asarray(weights)
 
         sizes = self._xp.full(
             (mappings.shape[0],),
@@ -404,9 +414,20 @@ def _mappings_sizes_weights_split(self):
         mappings = interpolator.mappings
         weights = interpolator.weights
 
+        # `reg_split_np_from` writes `splitted_mappings[i][j+1] = pixel_index`
+        # for the "flag-zero" insertion of the central pixel, so the buffer
+        # must have an extra column reserved past the k=3 mappings — matching
+        # `InterpolatorDelaunay._mappings_sizes_weights_split`'s hstack-append.
+        # `sizes` reports 3 (the actual mappings); `reg_split_np_from` grows it
+        # to 4 in-place when it inserts.
         sizes = self._xp.full(
             (mappings.shape[0],),
             mappings.shape[1],
         )
 
+        pad_int = self._xp.full((mappings.shape[0], 1), -1, dtype=mappings.dtype)
+        pad_float = self._xp.zeros((weights.shape[0], 1), dtype=weights.dtype)
+        mappings = self._xp.hstack((mappings, pad_int))
+        weights = self._xp.hstack((weights, pad_float))
+
         return mappings, sizes, weights

test_autoarray/inversion/pixelization/interpolator/test_knn_barycentric.py

@@ -127,3 +127,44 @@ def test__mesh_class__inherits_knn_knobs():
     assert mesh.radius_scale == 1.5
     assert mesh.areas_factor == 0.5
     assert mesh.split_neighbor_division == 2
+
+
+def test__interpolator__numpy_path_returns_writable_mappings_and_weights():
+    """
+    Regression guard: on the numpy path, `mappings` and `weights` must be
+    writable numpy arrays — not read-only views of jax.Arrays. The
+    `ConstantSplit` / `AdaptSplit` regularization code uses in-place
+    assignment (e.g. `splitted_mappings[i][j+1] = ...` in `reg_split_np_from`),
+    which raises `ValueError: assignment destination is read-only` if the
+    array is a numpy view onto a jax.Array.
+    """
+    import autoarray as aa
+    from autoarray.inversion.mesh.interpolator.knn import (
+        InterpolatorKNNBarycentric,
+    )
+
+    mesh_grid = aa.Grid2D.no_mask(
+        values=[[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [0.5, 0.5], [-0.5, -0.5]],
+        shape_native=(3, 2),
+        pixel_scales=1.0,
+        over_sample_size=1,
+    )
+
+    class _Raw:
+        def __init__(self, arr):
+            self.array = arr
+
+    queries = np.array([[0.3, 0.3], [0.0, 0.0], [1.0, 1.0], [0.5, 0.5]])
+
+    interp = InterpolatorKNNBarycentric(
+        mesh=aa.mesh.KNNBarycentric(pixels=6),
+        mesh_grid=mesh_grid,
+        data_grid=_Raw(queries),
+        xp=np,
+    )
+    mappings, _, weights = interp._mappings_sizes_weights
+
+    assert isinstance(mappings, np.ndarray)
+    assert isinstance(weights, np.ndarray)
+    assert mappings.flags.writeable, "mappings must be writable (regularization mutates it)"
+    assert weights.flags.writeable, "weights must be writable (regularization mutates it)"