narwhals-dev__narwhals-2864

The user is reporting a bug in `ArrowSeries.scatter` where it raises an "out of bound" error when `indices` is not 0 and not the full length of the series.

Looking at the provided reproduction code:
```python
import narwhals as nw
import pyarrow as pa

tbl = pa.table({"a": [1, 2, 3], "b": [142, 124, 132]})
frame = nw.from_native(tbl, eager_only=True)
ser = frame["a"]

try:
    result = ser.scatter(1, 999)
except Exception as exc:
    print(exc)


try:
    result = ser.scatter([0, 2], [999, 888])
except Exception as exc:
    print(exc)
```
The errors are `Index 1 out of bounds` and `Index 2 out of bounds`.

I need to find where `scatter` is implemented for Arrow-backed series.
Based on the workspace layout, `narwhals/_arrow/series.py` seems like a good place to start.

Let's search for `scatter` in `narwhals/_arrow/series.py`.

{
  "command": "grep -rn --include=\"*.py\" \"def scatter\" narwhals/"
}

{
  "status": "ok",
  "stdout": "narwhals/_compliant/series.py:251:    def scatter(self, indices: int | Sequence[int], values: Any) -> Self: ...\nnarwhals/series.py:238:    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:\nnarwhals/_pandas_like/series.py:273:    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:\nnarwhals/_arrow/series.py:440:    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:\nnarwhals/_polars/series.py:432:    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:\n",
  "stderr": "",
  "exit_code": 0
}

Okay, so `scatter` is implemented in several places. The issue specifically mentions `ArrowSeries.scatter`, which corresponds to `narwhals/_arrow/series.py`.

Let's examine the implementation of `scatter` in `narwhals/_arrow/series.py`.

{
  "end_line": 460,
  "filepath": "narwhals/_arrow/series.py",
  "start_line": 420
}

{
  "status": "ok",
  "filepath": "narwhals/_arrow/series.py",
  "content": "\n    def _gather(self, rows: SizedMultiIndexSelector[ChunkedArrayAny]) -> Self:\n        if len(rows) == 0:\n            return self._with_native(self.native.slice(0, 0))\n        if self._backend_version < (18,) and isinstance(rows, tuple):\n            rows = list(rows)\n        return self._with_native(self.native.take(rows))\n\n    def _gather_slice(self, rows: _SliceIndex | range) -> Self:\n        start = rows.start or 0\n        stop = rows.stop if rows.stop is not None else len(self.native)\n        if start < 0:\n            start = len(self.native) + start\n        if stop < 0:\n            stop = len(self.native) + stop\n        if rows.step is not None and rows.step != 1:\n            msg = \"Slicing with step is not supported on PyArrow tables\"\n            raise NotImplementedError(msg)\n        return self._with_native(self.native.slice(start, stop - start))\n\n    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:\n        import numpy as np  # ignore-banned-import\n\n        values_native: ArrayAny\n        if isinstance(indices, int):\n            indices_native = pa.array([indices])\n            values_native = pa.array([values])\n        else:\n            # TODO(unassigned): we may also want to let `indices` be a Series.\n            # https://github.com/narwhals-dev/narwhals/issues/2155\n            indices_native = pa.array(indices)\n            if isinstance(values, self.__class__):\n                values_native = values.native.combine_chunks()\n            else:\n                # NOTE: Requires fixes in https://github.com/zen-xu/pyarrow-stubs/pull/209\n                pa_array: Incomplete = pa.array\n                values_native = pa_array(values)\n\n        sorting_indices = pc.sort_indices(indices_native)\n        indices_native = indices_native.take(sorting_indices)\n        values_native = values_native.take(sorting_indices)",
  "start_line": 420,
  "end_line": 460,
  "total_lines": 1170,
  "is_truncated": false
}

Wait, the `read_file` output for `narwhals/_arrow/series.py` seems to be cut off. The `scatter` method starts at line 440 and ends at line 460 in the output, but the method obviously continues.

Let's read more lines from `narwhals/_arrow/series.py`.

{
  "end_line": 500,
  "filepath": "narwhals/_arrow/series.py",
  "start_line": 460
}

{
  "status": "ok",
  "filepath": "narwhals/_arrow/series.py",
  "content": "        values_native = values_native.take(sorting_indices)\n\n        mask: _1DArray = np.zeros(self.len(), dtype=bool)\n        mask[indices_native] = True\n        # NOTE: Multiple issues\n        # - Missing `values` type\n        # - `mask` accepts a `np.ndarray`, but not mentioned in stubs\n        # - Missing `replacements` type\n        # - Missing return type\n        pc_replace_with_mask: Incomplete = pc.replace_with_mask\n        return self._with_native(\n            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))\n        )\n\n    def to_list(self) -> list[Any]:\n        return self.native.to_pylist()\n\n    def __array__(self, dtype: Any = None, *, copy: bool | None = None) -> _1DArray:\n        return self.native.__array__(dtype=dtype, copy=copy)\n\n    def to_numpy(self, dtype: Any = None, *, copy: bool | None = None) -> _1DArray:\n        return self.native.to_numpy()\n\n    def alias(self, name: str) -> Self:\n        result = self.__class__(self.native, name=name, version=self._version)\n        result._broadcast = self._broadcast\n        return result\n\n    @property\n    def dtype(self) -> DType:\n        return native_to_narwhals_dtype(self.native.type, self._version)\n\n    def abs(self) -> Self:\n        return self._with_native(pc.abs(self.native))\n\n    def cum_sum(self, *, reverse: bool) -> Self:\n        cum_sum = pc.cumulative_sum\n        result = (\n            cum_sum(self.native, skip_nulls=True)\n            if not reverse\n            else cum_sum(self.native[::-1], skip_nulls=True)[::-1]",
  "start_line": 460,
  "end_line": 500,
  "total_lines": 1170,
  "is_truncated": false
}

I see the bug now!

```python
        mask: _1DArray = np.zeros(self.len(), dtype=bool)
        mask[indices_native] = True
        # ...
        return self._with_native(
            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))
        )
```

The problematic line is `mask[indices_native] = True`.
`indices_native` is a PyArrow array. NumPy doesn't always handle PyArrow arrays as indices the way we expect, or rather, `mask[indices_native]` might be doing something unexpected if `indices_native` is not a NumPy array.

Actually, `indices_native` is a `pa.Array`. When you use it to index a NumPy array, it might be causing issues if it's not converted to NumPy first.

Wait, the error reported was `Index 1 out of bounds`. This sounds like a PyArrow error, not a NumPy error.
PyArrow's `take` method can raise `Index out of bounds` if the indices provided are out of range.

In `scatter`:
```python
        sorting_indices = pc.sort_indices(indices_native)
        indices_native = indices_native.take(sorting_indices)
        values_native = values_native.take(sorting_indices)
        
        # ...
        
        return self._with_native(
            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))
        )
```

Look at `values_native.take(indices_native)`.
`values_native` has the same size as `indices_native`.
`indices_native` contains the actual indices in the original series.
If the original series has 3 elements, and we want to scatter at index 1 and 2, `indices_native` will be `[1, 2]`.
Then `values_native.take([1, 2])` will try to take elements at index 1 and 2 from `values_native`.
But `values_native` only has 2 elements (at indices 0 and 1).
So `values_native.take([1, 2])` will raise `Index 2 out of bounds`.

That's exactly it!

`values_native` already contains the values that should be placed at `indices_native`.
The `pc_replace_with_mask` function expects the replacement values in the order that matches the `True` values in the `mask`.

Since the `mask` is constructed as:
```python
        mask: _1DArray = np.zeros(self.len(), dtype=bool)
        mask[indices_native] = True
```
(And we sorted `indices_native` and `values_native` together), the `True` values in the `mask` appear at positions `indices_native`.

So `pc_replace_with_mask(self.native, mask, values_native)` should work if `values_native` is already sorted to match the mask's `True` positions.

Wait, let's double check how `pc_replace_with_mask` works.
According to PyArrow documentation (if I recall correctly), `replace_with_mask(array, mask, replacements)` replaces the elements of `array` where `mask` is `True` with the elements of `replacements`.

If `mask` has $N$ `True` values, `replacements` should have $N$ elements.

In the code:
```python
        sorting_indices = pc.sort_indices(indices_native)
        indices_native = indices_native.take(sorting_indices)
        values_native = values_native.take(sorting_indices)

        mask: _1DArray = np.zeros(self.len(), dtype=bool)
        mask[indices_native] = True
        
        return self._with_native(
            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))
        )
```

`values_native` is already the sorted array of values to be placed at `indices_native`.
`indices_native` is the sorted array of where they should be placed.
The `mask` has `True` at those sorted positions.
So we just need to pass `values_native` to `pc_replace_with_mask`.

The current code does `values_native.take(indices_native)`, which is wrong.

Let's reproduce this to confirm.

{
  "command": "python3 - <<'PY'\nimport narwhals as nw\nimport pyarrow as pa\n\ntbl = pa.table({\"a\": [1, 2, 3], \"b\": [142, 124, 132]})\nframe = nw.from_native(tbl, eager_only=True)\nser = frame[\"a\"]\n\ntry:\n    print(\"Test 1: scatter(1, 999)\")\n    result = ser.scatter(1, 999)\n    print(result.to_list())\nexcept Exception as exc:\n    print(f\"Caught exception: {exc}\")\n\ntry:\n    print(\"\\nTest 2: scatter([0, 2], [999, 888])\")\n    result = ser.scatter([0, 2], [999, 888])\n    print(result.to_list())\nexcept Exception as exc:\n    print(f\"Caught exception: {exc}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Test 1: scatter(1, 999)\nCaught exception: Index 1 out of bounds\n\nTest 2: scatter([0, 2], [999, 888])\nCaught exception: Index 2 out of bounds\n",
  "stderr": "",
  "exit_code": 0
}

As expected.

Now let's check if we can fix it by removing `.take(indices_native)`.

Wait, I should also double check if `mask[indices_native] = True` works as expected when `indices_native` is a PyArrow array.

```python
        mask: _1DArray = np.zeros(self.len(), dtype=bool)
        mask[indices_native] = True
```

If `indices_native` is a PyArrow array, does NumPy support indexing with it?
PyArrow arrays usually implement `__array__` or are compatible with NumPy.

Let's test this in a script.

{
  "command": "python3 - <<'PY'\nimport numpy as np\nimport pyarrow as pa\nindices_native = pa.array([0, 2])\nmask = np.zeros(3, dtype=bool)\ntry:\n    mask[indices_native] = True\n    print(\"Mask successful:\", mask)\nexcept Exception as e:\n    print(\"Mask failed:\", e)\nPY\n"
}

{
  "status": "ok",
  "stdout": "Mask successful: [ True False  True]\n",
  "stderr": "",
  "exit_code": 0
}

Yes, it works.

So the only issue is `values_native.take(indices_native)`.

Wait, let's check if we need to sort `indices_native` and `values_native`.
`pc_replace_with_mask` replaces elements where mask is true. If the mask is `[True, False, True]`, it will replace index 0 and index 2.
The replacements are taken in order. So the 0th element of replacements goes to the 0th True position in the mask, and the 1st element of replacements goes to the 1st True position in the mask.

If `indices` provided were `[2, 0]` and `values` were `[888, 999]`, we'd want index 2 to be 888 and index 0 to be 999.
`indices_native` would be `[2, 0]`.
`values_native` would be `[888, 999]`.

If we don't sort:
`mask` is `[False, False, False]`.
`mask[indices_native] = True` -> `mask[2] = True`, `mask[0] = True`.
`mask` becomes `[True, False, True]`.
`pc_replace_with_mask(native, mask, values_native)`:
- Index 0 of `native` is replaced by `values_native[0]` (888).
- Index 2 of `native` is replaced by `values_native[1]` (999).
This results in index 0=888, index 2=999.
But we wanted index 2=888, index 0=999.

So sorting is necessary.
`sorting_indices = pc.sort_indices(indices_native)`
`indices_native = indices_native.take(sorting_indices)` -> `[0, 2]`
`values_native = values_native.take(sorting_indices)` -> `[999, 888]`
Now `mask` is `[True, False, True]`.
`pc_replace_with_mask(native, mask, values_native)`:
- Index 0 of `native` replaced by `values_native[0]` (999).
- Index 2 of `native` replaced by `values_native[1]` (888).
This is correct.

So the sorting logic is correct, and the bug is just the extra `.take(indices_native)`.

One more thing: should I check other backends for the same bug?
`narwhals/_pandas_like/series.py` and `narwhals/_polars/series.py` also have `scatter`.

Let's check `narwhals/_polars/series.py`.

{
  "end_line": 450,
  "filepath": "narwhals/_polars/series.py",
  "start_line": 420
}

{
  "status": "ok",
  "filepath": "narwhals/_polars/series.py",
  "content": "    def sort(self, *, descending: bool, nulls_last: bool) -> Self:\n        if self._backend_version < (0, 20, 6):\n            result = self.native.sort(descending=descending)\n\n            if nulls_last:\n                is_null = result.is_null()\n                result = pl.concat([result.filter(~is_null), result.filter(is_null)])\n        else:\n            result = self.native.sort(descending=descending, nulls_last=nulls_last)\n\n        return self._with_native(result)\n\n    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:\n        s = self.native.clone().scatter(indices, extract_native(values))\n        return self._with_native(s)\n\n    def value_counts(\n        self, *, sort: bool, parallel: bool, name: str | None, normalize: bool\n    ) -> PolarsDataFrame:\n        from narwhals._polars.dataframe import PolarsDataFrame\n\n        if self._backend_version < (1, 0, 0):\n            value_name_ = name or (\"proportion\" if normalize else \"count\")\n\n            result = self.native.value_counts(sort=sort, parallel=parallel).select(\n                **{\n                    (self.native.name): pl.col(self.native.name),\n                    value_name_: pl.col(\"count\") / pl.sum(\"count\")\n                    if normalize\n                    else pl.col(\"count\"),\n                }",
  "start_line": 420,
  "end_line": 450,
  "total_lines": 741,
  "is_truncated": false
}

Polars implementation is different:
```python
    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:
        s = self.native.clone().scatter(indices, extract_native(values))
        return self._with_native(s)
```
This relies on Polars' `scatter` method.

Let's check `narwhals/_pandas_like/series.py`.

{
  "end_line": 290,
  "filepath": "narwhals/_pandas_like/series.py",
  "start_line": 260
}

{
  "status": "ok",
  "filepath": "narwhals/_pandas_like/series.py",
  "content": "            else:\n                msg = (\n                    \"cuDF only supports `ewm_mean` when there are no missing values \"\n                    \"or when both `min_period=0` and `ignore_nulls=False`\"\n                )\n                raise NotImplementedError(msg)\n        else:\n            result = ser.ewm(\n                com, span, half_life, alpha, min_samples, adjust, ignore_na=ignore_nulls\n            ).mean()\n        result[mask_na] = None\n        return self._with_native(result)\n\n    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:\n        if isinstance(values, self.__class__):\n            values = set_index(\n                values.native,\n                self.native.index[indices],\n                implementation=self._implementation,\n            )\n        s = self.native.copy(deep=True)\n        s.iloc[indices] = values\n        s.name = self.name\n        return self._with_native(s)\n\n    def _scatter_in_place(self, indices: Self, values: Self) -> None:\n        implementation = self._implementation\n        backend_version = self._backend_version\n        # Scatter, modifying original Series. Use with care!\n        values_native = set_index(\n            values.native,",
  "start_line": 260,
  "end_line": 290,
  "total_lines": 1106,
  "is_truncated": false
}

Pandas-like implementation uses `iloc[indices] = values`, which is correct.

So only the PyArrow backend needs a fix.

Let's apply the fix to `narwhals/_arrow/series.py`.

{
  "filepath": "narwhals/_arrow/series.py",
  "new_string": "        return self._with_native(\n            pc_replace_with_mask(self.native, mask, values_native)\n        )",
  "old_string": "        return self._with_native(\n            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))\n        )"
}

{
  "status": "ok",
  "filepath": "narwhals/_arrow/series.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/narwhals/_arrow/series.py\n+++ b/narwhals/_arrow/series.py\n@@ -468,7 +468,7 @@\n         # - Missing return type\n         pc_replace_with_mask: Incomplete = pc.replace_with_mask\n         return self._with_native(\n-            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))\n+            pc_replace_with_mask(self.native, mask, values_native)\n         )\n \n     def to_list(self) -> list[Any]:\n",
  "is_truncated": false
}

Now let's verify the fix with the reproduction script.

{
  "command": "python3 - <<'PY'\nimport narwhals as nw\nimport pyarrow as pa\n\ntbl = pa.table({\"a\": [1, 2, 3], \"b\": [142, 124, 132]})\nframe = nw.from_native(tbl, eager_only=True)\nser = frame[\"a\"]\n\ntry:\n    print(\"Test 1: scatter(1, 999)\")\n    result = ser.scatter(1, 999)\n    print(f\"Result: {result.to_list()}\")\n    assert result.to_list() == [1, 999, 3]\nexcept Exception as exc:\n    print(f\"Caught exception: {exc}\")\n    raise\n\ntry:\n    print(\"\\nTest 2: scatter([0, 2], [999, 888])\")\n    result = ser.scatter([0, 2], [999, 888])\n    print(f\"Result: {result.to_list()}\")\n    assert result.to_list() == [999, 2, 888]\nexcept Exception as exc:\n    print(f\"Caught exception: {exc}\")\n    raise\n\ntry:\n    print(\"\\nTest 3: scatter([2, 0], [888, 999])\")\n    result = ser.scatter([2, 0], [888, 999])\n    print(f\"Result: {result.to_list()}\")\n    assert result.to_list() == [999, 2, 888]\nexcept Exception as exc:\n    print(f\"Caught exception: {exc}\")\n    raise\nPY\n"
}

{
  "status": "ok",
  "stdout": "Test 1: scatter(1, 999)\nResult: [1, 999, 3]\n\nTest 2: scatter([0, 2], [999, 888])\nResult: [999, 2, 888]\n\nTest 3: scatter([2, 0], [888, 999])\nResult: [999, 2, 888]\n",
  "stderr": "",
  "exit_code": 0
}

The reproduction scripts pass. Now I should check if there are any existing tests for `scatter` and run them.

Let's search for `scatter` in `tests/`.

{
  "command": "grep -rn \"scatter\" tests/"
}

{
  "status": "ok",
  "stdout": "tests/series_only/scatter_test.py:9:def test_scatter(constructor_eager: ConstructorEager) -> None:\ntests/series_only/scatter_test.py:14:        df[\"a\"].scatter([0, 1], [999, 888]), df[\"b\"].scatter([0, 2, 1], df[\"b\"])\ntests/series_only/scatter_test.py:20:def test_scatter_indices() -> None:\ntests/series_only/scatter_test.py:22:    result = s.scatter([1, 0, 2], s)\ntests/series_only/scatter_test.py:27:def test_scatter_unchanged(constructor_eager: ConstructorEager) -> None:\ntests/series_only/scatter_test.py:32:        df[\"a\"].scatter([0, 1], [999, 888]), df[\"b\"].scatter([0, 2, 1], [142, 124, 132])\ntests/series_only/scatter_test.py:43:    s.scatter([0, 1], [999, 888])\ntests/series_only/scatter_test.py:48:def test_scatter_integer(constructor_eager: ConstructorEager) -> None:\ntests/series_only/scatter_test.py:53:    result = s.scatter(0, 999)\ntests/series_only/scatter_test.py:58:def test_scatter_unordered_indices(constructor_eager: ConstructorEager) -> None:\ntests/series_only/scatter_test.py:62:    result = df[\"a\"].scatter(indices, df[\"a\"])\n",
  "stderr": "",
  "exit_code": 0
}

Let's run these tests focusing on PyArrow (if possible) or just run all of them.

The `constructor_eager` likely tests multiple backends. I'll run `tests/series_only/scatter_test.py`.

{
  "command": "pytest tests/series_only/scatter_test.py -q --tb=short --no-header"
}

{
  "status": "ok",
  "stdout": ".....................                                                    [100%]\n21 passed in 0.50s\n",
  "stderr": "",
  "exit_code": 0
}

All tests passed.

I should check if there are other things I need to consider.
The original bug report said:
- indices is not 0
- are not full length of the series

My tests covered indices = 1, and indices = [0, 2] and [2, 0].

Is it possible that `indices` could be a Series?
In `narwhals/_arrow/series.py`:
```python
        else:
            # TODO(unassigned): we may also want to let `indices` be a Series.
            # https://github.com/narwhals-dev/narwhals/issues/2155
            indices_native = pa.array(indices)
```
Currently it's not supported, so I'll leave it as is.

What if `values` is a Series?
```python
            if isinstance(values, self.__class__):
                values_native = values.native.combine_chunks()
            else:
                # NOTE: Requires fixes in https://github.com/zen-xu/pyarrow-stubs/pull/209
                pa_array: Incomplete = pa.array
                values_native = pa_array(values)
```
This handles it by taking the native array. If `values` is a Series, `values.native` is the PyArrow array.

One detail: `values_native.take(sorting_indices)` is used for both cases.

Let's verify the case where `values` is a Series.

{
  "command": "python3 - <<'PY'\nimport narwhals as nw\nimport pyarrow as pa\n\ntbl = pa.table({\"a\": [1, 2, 3], \"b\": [142, 124, 132]})\nframe = nw.from_native(tbl, eager_only=True)\nser = frame[\"a\"]\nval_ser = frame[\"b\"]\n\ntry:\n    print(\"Test 4: scatter with Series values\")\n    result = ser.scatter([0, 2], val_ser)\n    print(f\"Result: {result.to_list()}\")\n    # ser is [1, 2, 3], val_ser is [142, 124, 132]\n    # scatter [0, 2] with [142, 124, 132]\n    # index 0 -> val_ser[0] = 142\n    # index 2 -> val_ser[1] = 124  <-- WAIT!\n    # If values is a Series, the indices in `values` should probably align with the `indices` provided to `scatter`?\n    # Let's check the docstring or implementation.\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "  File \"<stdin>\", line 18\n    # Let's check the docstring or implementation.\nSyntaxError: expected 'except' or 'finally' block\n",
  "details": {
    "stdout": "",
    "stderr": "  File \"<stdin>\", line 18\n    # Let's check the docstring or implementation.\nSyntaxError: expected 'except' or 'finally' block\n",
    "exit_code": 1
  }
}

My bad, I forgot the `except` block.

But let's check the implementation again:
```python
        if isinstance(indices, int):
            indices_native = pa.array([indices])
            values_native = pa.array([values])
        else:
            indices_native = pa.array(indices)
            if isinstance(values, self.__class__):
                values_native = values.native.combine_chunks()
            else:
                pa_array: Incomplete = pa.array
                values_native = pa_array(values)

        sorting_indices = pc.sort_indices(indices_native)
        indices_native = indices_native.take(sorting_indices)
        values_native = values_native.take(sorting_indices)
```

If `values` is a Series, `values_native` starts as the native array of that series.
Then it is sliced using `sorting_indices`.
Wait, `sorting_indices` are indices to sort `indices_native`.
So `values_native` is being reordered to match the sorted `indices_native`.

This implies that the original `values` (if it's a Series) was expected to be aligned with the original `indices`.
That is, `ser.scatter(indices, values)` where `indices` and `values` are both something like arrays/series of the same length.
The `i`-th element of `indices` tells you where to put the `i`-th element of `values`.

So if `indices = [0, 2]` and `values = [142, 132]`, then index 0 gets 142 and index 2 gets 132.

If `values` is a Series, it's treated as an array of values.

Let's verify this alignment.

{
  "command": "python3 - <<'PY'\nimport narwhals as nw\nimport pyarrow as pa\n\ntbl = pa.table({\"a\": [1, 2, 3], \"b\": [142, 124, 132]})\nframe = nw.from_native(tbl, eager_only=True)\nser = frame[\"a\"]\nval_ser = frame[\"b\"]\n\n# Case 1: values as list\nresult1 = ser.scatter([0, 2], [142, 132])\nprint(f\"List values result: {result1.to_list()}\")\n\n# Case 2: values as Series\n# val_ser is [142, 124, 132]. If we scatter at [0, 2], \n# it should take the first 2 elements of val_ser? \n# NO, that's not how it usually works. \n# It should probably use the values in val_ser at the positions 0 and 1.\nresult2 = ser.scatter([0, 2], val_ser)\nprint(f\"Series values result: {result2.to_list()}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "List values result: [142, 2, 132]\nSeries values result: [142, 2, 124]\n",
  "stderr": "",
  "exit_code": 0
}

Interesting. When `values` is a Series, `values_native` is the whole series (length 3).
Then `sorting_indices` for `indices=[0, 2]` is `[0, 1]` (because 0 < 2).
Then `values_native.take([0, 1])` gives `[142, 124]`.
Then `mask` is `[True, False, True]`.
Then `pc_replace_with_mask` replaces index 0 with 142 and index 2 with 124.

So `ser.scatter([0, 2], val_ser)` where `val_ser` is `[142, 124, 132]` results in `[142, 2, 124]`.
This means the first 2 elements of `val_ser` were used.

This is consistent with how `scatter` is usually implemented when taking an array of replacements.

Anyway, the bug report specifically complained about the `out of bound` error, which was caused by `values_native.take(indices_native)`.

I have fixed that. I have verified it with the reproduction cases and the existing tests.

I'll do one final check of the diff.

{
  "command": "git diff"
}

{
  "status": "ok",
  "stdout": "diff --git a/narwhals/_arrow/series.py b/narwhals/_arrow/series.py\nindex e22d20f..a846e50 100644\n--- a/narwhals/_arrow/series.py\n+++ b/narwhals/_arrow/series.py\n@@ -468,7 +468,7 @@ class ArrowSeries(EagerSeries[\"ChunkedArrayAny\"]):\n         # - Missing return type\n         pc_replace_with_mask: Incomplete = pc.replace_with_mask\n         return self._with_native(\n-            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))\n+            pc_replace_with_mask(self.native, mask, values_native)\n         )\n \n     def to_list(self) -> list[Any]:\n",
  "stderr": "",
  "exit_code": 0
}

The diff looks correct and minimal.

{
  "status": "ok",
  "patch_size": 572,
  "files_changed": 1
}

I have resolved the issue. I found that `ArrowSeries.scatter` was incorrectly calling `.take(indices_native)` on the replacement values, which led to an `Index out of bounds` error whenever `indices` contained values larger than the number of replacements. This was fixed by removing the unnecessary `.take(indices_native)` call.

The `ArrowSeries.scatter` method incorrectly applied `.take(indices_native)` to the `values_native` array before passing it to `pc_replace_with_mask`. Since `values_native` is already sorted and aligned to the number of replacement points indicated by the mask, this additional `.take()` call led to `Index out of bounds` errors when any index in `indices` exceeded the number of provided replacement values.

The fix removes the erroneous `.take(indices_native)` call in `narwhals/_arrow/series.py`, ensuring that the correctly sorted `values_native` array is used for the mask-based replacement.