narwhals-dev__narwhals-2864

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

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)
```
Output:
`Index 1 out of bounds`
`Index 2 out of bounds`

I need to find where `scatter` is implemented for the Arrow series. Looking at the workspace layout, `narwhals/_arrow/series.py` seems like a good place.

Let's start by reproducing the bug.

{
  "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\nprint(\"Testing scarcer(1, 999)\")\ntry:\n    result = ser.scatter(1, 999)\n    print(\"Result:\", result)\nexcept Exception as exc:\n    print(f\"Error: {exc}\")\n\nprint(\"\\nTesting scatter([0, 2], [999, 888])\")\ntry:\n    result = ser.scatter([0, 2], [999, 888])\n    print(\"Result:\", result)\nexcept Exception as exc:\n    print(f\"Error: {exc}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Testing scarcer(1, 999)\nError: Index 1 out of bounds\n\nTesting scatter([0, 2], [999, 888])\nError: Index 2 out of bounds\n",
  "stderr": "",
  "exit_code": 0
}

The bug is reproduced. Now I need to find where `scatter` is implemented. I'll search for `scatter` in `narwhals/_arrow/series.py` and other relevant files.

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

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

It's implemented in several places. For Arrow, it's in `narwhals/_arrow/series.py`. Let's examine that implementation.

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

{
  "status": "ok",
  "filepath": "narwhals/_arrow/series.py",
  "content": "        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": 430,
  "end_line": 460,
  "total_lines": 1170,
  "is_truncated": false
}

Wait, the `read_file` output stops at line 460, and it seems the `scatter` implementation is incomplete in the `read_file` output. Let me read more of `narwhals/_arrow/series.py` from line 430 onwards.

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

{
  "status": "ok",
  "filepath": "narwhals/_arrow/series.py",
  "content": "        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)\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": 430,
  "end_line": 500,
  "total_lines": 1170,
  "is_truncated": false
}

Looking at the `scatter` implementation:

```python
    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:
        import numpy as np  # ignore-banned-import

        values_native: ArrayAny
        if isinstance(indices, int):
            indices_native = pa.array([indices])
            values_native = pa.array([values])
        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)
            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)

        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
        # NOTE: Multiple issues
        # - Missing `values` type
        # - `mask` accepts a `np.ndarray`, but not mentioned in stubs
        # - Missing `replacements` type
        # - Missing `return type`
        pc_replace_with_mask: Incomplete = pc.replace_with_mask
        return self._with_native(
            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))
        )
```

I see two potential issues that could cause "out of bound" errors:

1. `mask[indices_native] = True`: `indices_native` is a PyArrow array. Numpy indexing with a PyArrow array might not work as expected, or it might be causing the error if the indices are out of bounds for the mask. But the error message says "Index 1 out of bounds" or "Index 2 out of bounds", which looks like it's coming from PyArrow, not Numpy.

Wait, `indices_native` is used as an index to `mask` (a numpy array).

2. `values_native.take(indices_native)`: This is the most likely candidate. `values_native` was created from `values`.
   - If `indices` is an `int`, `values_native` is `pa.array([values])`, so it has length 1.
   - If `indices` is a `Sequence[int]`, `values_native` is created from `values`.

In the case `ser.scatter(1, 999)`:
- `indices = 1`
- `indices_native = pa.array([1])`
- `values_native = pa.array([999])`
- `sorting_indices = pc.sort_indices([1])` -> `[0]`
- `indices_native = [1].take([0])` -> `[1]`
- `values_native = [999].take([0])` -> `[999]`
- `mask` has length 3 (`[False, False, False]`)
- `mask[indices_native] = True` -> `mask[[1]] = True` -> `[False, True, False]`
- `values_native.take(indices_native)`: `[999].take([1])` -> **BINGO!** `values_native` has length 1, but we are trying to `take` at index 1. This will raise "Index 1 out of bounds".

The `values_native` should be shifted/sorted along with indices, but when we call `pc_replace_with_mask`, the third argument is `replacements`. According to PyArrow documentation for `pc.replace_with_mask(array, mask, replacements)`, the `replacements` array must have the same length as `array` (the original series), OR the same length as the number of `True` values in the `mask`.

Wait, let's check `pc.replace_with_mask` docs (or infer them).
If `values_native` is like `[999]`, it's already the values we want to insert.
In `ser.scatter(1, 999)`, we want to put `999` at index `1`.
`mask` is `[False, True, False]`.
`replacements` should be `[999]`.

But the code does `values_native.take(indices_native)`.
In `ser.scatter(1, 999)`, `values_native` is `[999]` and `indices_native` is `[1]`.
`[999].take([1])` fails because index 1 is out of bounds for an array of length 1.

It should be `values_native` (after sorting) if we just want the values.

Let's check the case `ser.scatter([0, 2], [999, 888])`:
- `indices = [0, 2]`
- `indices_native = pa.array([0, 2])`
- `values_native = pa.array([999, 888])`
- `sorting_indices = [0, 1]`
- `indices_native = [0, 2]`
- `values_native = [999, 888]`
- `mask` = `[True, False, True]`
- `values_native.take(indices_native)`: `[999, 888].take([0, 2])` -> **BINGO!** Index 2 is out of bounds for `[999, 888]`.

So `values_native` already contains the values to be scattered, in the order they correspond to `indices`. After sorting `indices_native`, `values_native` is also sorted accordingly.
The `replacements` argument to `pc_replace_with_mask` should just be `values_native`.

Wait, what if `values` was a `Series`?
```python
            if isinstance(values, self.__class__):
                values_native = values.native.combine_chunks()
```
If `values` is a `Series` (and it's probably expected to be the same length as `indices`), then `values_native` is its native PyArrow array.

Let's verify if `values_native` (after sorting) is what we need.

In `ser.scatter(1, 999)`:
`indices_native = [1]`
`values_native = [999]`
`mask = [False, True, False]`
`pc_replace_with_mask(self.native, mask, values_native)` -> should replace index 1 with 999.

In `ser.scatter([0, 2], [999, 888])`:
`indices_native = [0, 2]`
`values_native = [999, 888]`
`mask = [True, False, True]`
`pc_replace_with_mask(self.native, mask, values_native)` -> should replace index 0 with 999 and index 2 with 888.

This seems correct. The `take(indices_native)` call is definitely wrong.

Wait, let me double check what `pc.replace_with_mask` expects.
If I can't check docs, I can try it in the repro script.

{
  "command": "python3 - <<'PY'\nimport pyarrow as pa\nimport pyarrow.compute as pc\nimport numpy as np\n\narr = pa.array([1, 2, 3])\nmask = np.array([True, False, True])\nreplacements = pa.array([999, 888])\n\ntry:\n    res = pc.replace_with_mask(arr, mask, replacements)\n    print(\"Result:\", res)\nexcept Exception as e:\n    print(\"Error:\", e)\n\narr2 = pa.array([1, 2, 3])\nmask2 = np.array([False, True, False])\nreplacements2 = pa.array([999])\ntry:\n    res2 = pc.replace_with_mask(arr2, mask2, replacements2)\n    print(\"Result 2:\", res2)\nexcept Exception as e:\n    print(\"Error 2:\", e)\nPY\n"
}

{
  "status": "ok",
  "stdout": "Result: [\n  999,\n  2,\n  888\n]\nResult 2: [\n  1,\n  999,\n  3\n]\n",
  "stderr": "",
  "exit_code": 0
}

Yes, `pc.replace_with_mask` expects `replacements` to be the values to put in the `True` positions of the `mask`.
And the current implementation was doing `values_native.take(indices_native)`, which is completely wrong because `indices_native` contains the target indices in the original array, not indices into `values_native`.

So I should just use `values_native`.

Wait, let's look at the sorting part:
```python
        sorting_indices = pc.sort_indices(indices_native)
        indices_native = indices_native.take(sorting_indices)
        values_native = values_native.take(sorting_indices)
```
This ensures that `indices_native` is sorted. If it is sorted, then the `True` values in the `mask` will be in the same order as the elements in `values_native`.

Wait, let's test if `pc.replace_with_mask` requires the mask to be sorted or if it just takes `replacements` in the order they appear in the mask.

My test above:
`mask = [True, False, True]`, `replacements = [999, 888]` -> result `[999, 2, 888]`.
So it's in the order of `True` values in the mask.

If `indices` were `[2, 0]` and `values` were `[888, 999]`.
`indices_native` becomes `[2, 0]`.
`values_native` becomes `[888, 999]`.
`sorting_indices` = `[1, 0]` (because index 1 of `[2, 0]` is 0, which is smaller).
`indices_native.take([1, 0])` -> `[0, 2]`.
`values_native.take([1, 0])` -> `[999, 888]`.
`mask` = `[True, False, True]`.
`pc.replace_with_mask(..., mask, [999, 888])` -> results in index 0 getting 999 and index 2 getting 888.
Correct.

So the sorting is necessary because `mask` is created from `indices_native` and used in `pc.replace_with_mask`, but `pc.replace_with_mask` fills based on the order of `True` in `mask`. Since `mask` is created from all `indices_native`, if we want the values to match the indices, they must be sorted.

Actually, if we just did:
```python
        mask: _1DArray = np.zeros(self.len(), dtype=bool)
        mask[indices_native] = True
```
Then `mask` always has `True` values at the specified indices, and their order in `mask` is always increasing.
To make `values_native` match that order, we must sort them based on the values of `indices_native`.
Which is exactly what the sorting code does.

So the only bug is the `take(indices_native)` call.

Let's check other backends to see if they have similar logic. `_pandas_like/series.py`, `_polars/series.py`.

{
  "command": "grep -n \"def scatter\" narwhals/_pandas_like/series.py narwhals/_polars/series.py"
}

{
  "status": "ok",
  "stdout": "narwhals/_pandas_like/series.py:273:    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
}

Let's look at `_pandas_like/series.py`.

{
  "end_line": 300,
  "filepath": "narwhals/_pandas_like/series.py",
  "start_line": 270
}

{
  "status": "ok",
  "filepath": "narwhals/_pandas_like/series.py",
  "content": "        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,\n            self.native.index[indices.native],\n            implementation=implementation,\n        )\n        if implementation is Implementation.PANDAS and parse_version(np) < (2,):\n            values_native = values_native.copy()  # pragma: no cover\n        min_pd_version = (1, 2)\n        if implementation is Implementation.PANDAS and backend_version < min_pd_version:\n            self.native.iloc[indices.native.values] = values_native  # noqa: PD011\n        else:\n            self.native.iloc[indices.native] = values_native",
  "start_line": 270,
  "end_line": 300,
  "total_lines": 1106,
  "is_truncated": false
}

Pandas `iloc[indices] = values` handles everything.

Let's look at `_polars/series.py`.

{
  "end_line": 460,
  "filepath": "narwhals/_polars/series.py",
  "start_line": 430
}

{
  "status": "ok",
  "filepath": "narwhals/_polars/series.py",
  "content": "        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                }\n            )\n        else:\n            result = self.native.value_counts(\n                sort=sort, parallel=parallel, name=name, normalize=normalize\n            )\n        return PolarsDataFrame.from_native(result, context=self)\n\n    def cum_count(self, *, reverse: bool) -> Self:\n        return self._with_native(self.native.cum_count(reverse=reverse))\n",
  "start_line": 430,
  "end_line": 460,
  "total_lines": 741,
  "is_truncated": false
}

Polars has a `scatter` method natively.

The issue is specific to the Arrow implementation in `narwhals/_arrow/series.py`.
The fix is to remove `.take(indices_native)` from `pc_replace_with_mask(self.native, mask, values_native.take(indices_native))`.

Let's double check if there are any other issues in `scatter` for Arrow.
```python
    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:
        import numpy as np  # ignore-banned- υπάρχει-import

        values_native: ArrayAny
        if isinstance(indices, int):
            indices_native = pa.array([indices])
            values_native = pa.array([values])
        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)
            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)

        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
        # NOTE: Multiple issues
        # - Missing `values` type
        # - `mask` accepts a `np.ndarray`, but not mentioned in stubs
        # - Missing `replacements` type
        # - Missing `return type`
        pc_replace_with_mask: Incomplete = pc.replace_with_mask
        return self._with_native(
            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))
        )
```

Wait, `mask[indices_native] = True`. `indices_native` is a PyArrow array. Does numpy support this?
Yes, `np.ndarray.__setitem__` supports PyArrow arrays if they implement the array protocol. PyArrow arrays do.

Let's verify:

{
  "command": "python3 - <<'PY'\nimport numpy as np\nimport pyarrow as pa\nmask = np.zeros(5, dtype=bool)\nindices = pa.array([1, 3])\nmask[indices] = True\nprint(mask)\nPY\n"
}

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

Yes, that works.

So the fix is just:
```python
-            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))
+            pc_replace_with_mask(self.native, mask, values_native)
```

Wait, I should also check if `values` could be a scalar in the `else` block (i.e. `indices` is a sequence but `values` is a scalar).
The type hint says `values: Any`.
If `indices` is `[0, 2]` and `values` is `999`.
`isinstance(indices, int)` is False.
`indices_native = pa.array([0, 2])`.
`isinstance(values, self.__class__)` (which is `ArrowSeries`) is False.
`values_native = pa.array(999)`?
Actually `pa.array(999)` would fail if it expects a sequence. Let's check.

{
  "command": "python3 - <<'PY'\nimport pyarrow as pa\ntry:\n    print(pa.array(999))\nexcept Exception as e:\n    print(e)\nPY\n"
}

{
  "status": "ok",
  "stdout": "'int' object is not iterable\n",
  "stderr": "",
  "exit_code": 0
}

So if `indices` is a sequence and `values` is a scalar, `pa.array(values)` will fail.
But the problem description says:
`result = ser.scatter(1, 999)` -> `indices` is an int. This is handled:
```python
        if isinstance(indices, int):
            indices_native = pa.array([indices])
            values_native = pa.array([values])
```
What about `ser.scatter([0, 2], 999)`?
The code would do:
```python
        else:
            indices_native = pa.array(indices) # [0, 2]
            if isinstance(values, self.__class__):
                ...
            else:
                values_native = pa.array(values) # pa.array(999) -> BOOM
```
Is this supported? The problem statement didn't mention it, but typically `scatter` might allow scattering a scalar to multiple indices.
However, if the current code doesn't support it and it's not part of the repro, maybe I should stick to the minimal fix.

Wait, if `indices` is a sequence and `values` is a scalar, it SHOULD probably be supported if the API intends to be like pandas/polars.
But I will focus on fixing the reported bug first.

One more thing: what if `values` is not a sequence and `indices` is a sequence?
If `values` is a scalar, we probably want to broadcast it.

Let's see if I should fix this too.
Actually, the issue is specifically about "out of bound error", and the fix I identified for that is straightforward.

Let's apply the fix and verify with the repro.

{
  "filepath": "narwhals/_arrow/series.py",
  "new_string": "        pc_replace_with_mask: Incomplete = pc.replace_with_mask\n        return self._with_native(\n            pc_replace_with_mask(self.native, mask, values_native)\n        )",
  "old_string": "        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        )"
}

{
  "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 run the repro.

{
  "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\nprint(\"Testing scarcer(1, 999)\")\ntry:\n    result = ser.scatter(1, 999)\n    print(\"Result:\", result)\nexcept Exception as exc:\n    print(f\"Error: {exc}\")\n\nprint(\"\\nTesting scatter([0, 2], [999, 888])\")\ntry:\n    result = ser.scatter([0, 2], [999, 888])\n    print(\"Result:\", result)\nexcept Exception as exc:\n    print(f\"Error: {exc}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Testing scarcer(1, 999)\nResult: ┌───────────────────────────────────────────────────┐\n|                  Narwhals Series                  |\n|---------------------------------------------------|\n|<pyarrow.lib.ChunkedArray object at 0x7d62e78f18a0>|\n|[                                                  |\n|  [                                                |\n|    1,                                             |\n|    999,                                           |\n|    3                                              |\n|  ]                                                |\n|]                                                  |\n└───────────────────────────────────────────────────┘\n\nTesting scatter([0, 2], [999, 888])\nResult: ┌───────────────────────────────────────────────────┐\n|                  Narwhals Series                  |\n|---------------------------------------------------|\n|<pyarrow.lib.ChunkedArray object at 0x7d62e78f1900>|\n|[                                                  |\n|  [                                                |\n|    999,                                           |\n|    2,                                             |\n|    888                                            |\n|  ]                                                |\n|]                                                  |\n└───────────────────────────────────────────────────┘\n",
  "stderr": "",
  "exit_code": 0
}

The repro tests now pass. Now I should check for other similar issues or edge cases.
What if `indices` is a sequence but `values_native` (after sorting) is what we want?
Let's check another case where indices are not sorted.

{
  "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\nprint(\"Testing scatter([2, 0], [888, 999])\")\ntry:\n    result = ser.scatter([2, 0], [888, 999])\n    print(\"Result:\", result)\nexcept Exception as exc:\n    print(f\"Error: {exc}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Testing scatter([2, 0], [888, 999])\nResult: ┌───────────────────────────────────────────────────┐\n|                  Narwhals Series                  |\n|---------------------------------------------------|\n|<pyarrow.lib.ChunkedArray object at 0x7307f58f0f40>|\n|[                                                  |\n|  [                                                |\n|    999,                                           |\n|    2,                                             |\n|    888                                            |\n|  ]                                                |\n|]                                                  |\n└───────────────────────────────────────────────────┘\n",
  "stderr": "",
  "exit_code": 0
}

Correct: index 0 became 999, index 2 became 888.

What if the series is empty?

{
  "command": "python3 - <<'PY'\nimport narwhals as nw\nimport pyarrow as pa\n\ntbl = pa.table({\"a\": [], \"b\": []})\nframe = nw.from_native(tbl, eager_only=True)\nser = frame[\"a\"]\n\nprint(\"Testing scatter(0, 999) on empty series\")\ntry:\n    result = ser.scatter(0, 999)\n    print(\"Result:\", result)\nexcept Exception as exc:\n    print(f\"Error: {exc}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Testing scatter(0, 999) on empty series\nError: index 0 is out of bounds for axis 0 with size 0\n",
  "stderr": "",
  "exit_code": 0
}

This is expected because index 0 is out of bounds for a series of length 0.

Now let's check the `tests/` directory for existing tests for `scatter`.

{
  "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 to make sure I haven't broken anything.

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

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

All tests passed. I'm confident in the fix.
Final check on the file and the diff.

{
  "command": "git status --short && git diff"
}

{
  "status": "ok",
  "stdout": " M narwhals/_arrow/series.py\ndiff --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 is minimal and correct.

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

The issue was that `ArrowSeries.scatter` incorrectly used `.take(indices_native)` on the `values_native` array, causing an "out of bound" error when `indices` didn't match the series' full length. I've removed that call since `values_native` is already aligned with the mask's `True` values after sorting.

Fixed `ArrowSeries.scatter` by removing an incorrect `.take()` call on the values array, which caused out-of-bounds errors when `indices` did not cover the full range of the series. The fix ensures `values_native` is passed directly to `pc.replace_with_mask` after being aligned by sorting.