narwhals-dev__narwhals-2864

The user is reporting a bug in `ArrowSeries.scatter` in the `narwhals` library.
Specifically, when the backend is `pyarrow`, calling `scatter` with indices that are not 0 and not the full length of the series raises an "out of bound error".

The reproduction code provided:
```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)
```

Expected output from repro:
`Index 1 out of bounds`
`Index 2 out of bounds`

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

Plan:
1. Reproduce the bug.
2. Locate the `scatter` implementation in `narwhals/_arrow/series.py`.
3. Fix the bug.
4. Verify the fix.

{
  "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(\"Test 1: ser.scatter(1, 999)\")\ntry:\n    result = ser.scatter(1, 999)\n    print(\"Result:\", result)\nexcept Exception as exc:\n    print(\"Caught expected/unexpected exception:\", exc)\n\nprint(\"\\nTest 2: ser.scatter([0, 2], [999, 888])\")\ntry:\n    result = ser.scatter([0, 2], [999, 888])\n    print(\"Result:\", result)\nexcept Exception as exc:\n    print(\"Caught expected/unexpected exception:\", exc)\nPY\n"
}

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

The reproduction confirms the bug.
Now let's find the implementation of `scatter` for Arrow. I'll start by searching for `scatter` in `narwhals/_arrow/series.py`.

{
  "command": "grep -rn \"def scatter\" narwhals/_arrow/series.py"
}

{
  "status": "ok",
  "stdout": "440:    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:\n",
  "stderr": "",
  "exit_code": 0
}

Okay, it's at line 440 of `narwhals/_arrow/series.py`. Let's read the implementation.

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

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

Wait, the `read_file` output stopped at line 460, but it seems I only have the beginning of the `scatter` method. Let me read more.

{
  "end_line": 480,
  "filepath": "narwhals/_arrow/series.py",
  "start_line": 461
}

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

Let's analyze the code:

```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))
        )
```

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

`indices_native` is a PyArrow array. When you use a PyArrow array to index a NumPy array (like `mask`), it might not behave as expected, or PyArrow's `__getitem__` / indexing might be where the "out of bounds" comes from if it's trying to do something internally.

Wait, `mask[indices_native] = True`. If `indices_native` is a PyArrow array, NumPy might be trying to use it as an index.

Let's check what happens if `indices_native` is converted to a NumPy array first.

Actually, let's look at the error again: `Index 1 out of bounds`. This looks like a PyArrow error.

Wait, let's look at `values_native.take(indices_native)`.
If `indices_native` is sorted, then `values_native` is also sorted by the same indices.
Then it calls `pc.replace_with_mask(self.native, mask, values_native.take(indices_native))`.
`values_native.take(indices_native)` takes elements from `values_native` at positions specified by `indices_native`.
But `values_native` was already rearranged by `sorting_indices` to match `indices_native`'s sorted order.
So `values_native` already has the values that should go into `indices_native`'s positions.

Wait:
```python
        sorting_indices = pc.sort_indices(indices_native)
        indices_native = indices_native.take(sorting_indices)
        values_native = values_native.take(sorting_indices)
```
Now `indices_native` is sorted.
Now `mask[indices_native] = True`.
Now `pc.replace_with_mask(self.native, mask, values_native.take(indices_native))`.

If `indices_native` was `[0, 2]` and `values_native` was `[999, 888]`:
`sorting_indices` will be `[0, 1]`.
`indices_native` stays `[0, 2]`.
`values_native` stays `[999, 888]`.
`mask` becomes `[True, False, True]`.
Then it calls `values_native.take(indices_native)`.
`indices_native` is `[0, 2]`.
`values_native` is `[999, 888]`.
`values_native.take([0, 2])` will try to access index 0 and 2 of `values_native`.
But `values_native` only has length 2. Index 2 is out of bounds!

That's the bug! `values_native` should already be the values to be placed at `indices_native`.
Wait, `pc.replace_with_mask` takes the `replacements` array and puts them in the positions where `mask` is True.
And the `replacements` array must have the same length as the number of True values in `mask`.
In this case, the number of True values in `mask` is `len(indices_native)`.
And `values_native` already has length `len(indices_native)`.
And because both were sorted together, `values_native[i]` corresponds to `indices_native[i]`.

So `values_native.take(indices_native)` is definitely wrong. It should just be `values_native`.

Let's verify this.
If `indices_native = [0, 2]` and `values_native = [999, 888]`:
`mask = [True, False, True]`
`pc.replace_with_mask(self.native, mask, [999, 888])`
This should work.

Let's verify this with a pytest or a small script.

{
  "command": "python3 - <<'PY'\nimport pyarrow as pa\nimport pyarrow.compute as pc\nimport numpy as np\n\nser_native = pa.array([1, 2, 3])\nindices_native = pa.array([0, 2])\nvalues_native = pa.array([999, 888])\nmask = np.zeros(ser_native.length(), dtype=bool)\nmask[indices_native] = True\n\nprint(\"Mask:\", mask)\ntry:\n    # This is what the current code does:\n    replacements = values_native.take(indices_native)\n    print(\"Replacements (take):\", replacements)\nexcept Exception as e:\n    print(\"Error in take:\", e)\n\ntry:\n    # This is what I think it should be:\n    result = pc.replace_with_mask(ser_native, mask, values_native)\n    print(\"Result (no take):\", result)\nexcept Exception as e:\n    print(\"Error in replace_with_mask:\", e)\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 8, in <module>\nAttributeError: 'pyarrow.lib.Int64Array' object has no attribute 'length'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 8, in <module>\nAttributeError: 'pyarrow.lib.Int64Array' object has no attribute 'length'\n",
    "exit_code": 1
  }
}

Ah, I used `.length()` instead of `.length` or `len()`. PyArrow arrays use `.length` (property) or `len()`.

{
  "command": "python3 - <<'PY'\nimport pyarrow as pa\nimport pyarrow.compute as pc\nimport numpy as np\n\nser_native = pa.array([1, 2, 3])\nindices_native = pa.array([0, 2])\nvalues_native = pa.array([999, 888])\nmask = np.zeros(len(ser_native), dtype=bool)\nmask[indices_native] = True\n\nprint(\"Mask:\", mask)\ntry:\n    # This is what the current code does:\n    replacements = values_native.take(indices_native)\n    print(\"Replacements (take):\", replacements)\nexcept Exception as e:\n    print(\"Error in take:\", e)\n\ntry:\n    # This is what I think it should be:\n    result = pc.replace_with_mask(ser_native, mask, values_native)\n    print(\"Result (no take):\", result)\nexcept Exception as e:\n    print(\"Error in replace_with_mask:\", e)\nPY\n"
}

{
  "status": "ok",
  "stdout": "Mask: [ True False  True]\nError in take: Index 2 out of bounds\nResult (no take): [\n  999,\n  2,\n  888\n]\n",
  "stderr": "",
  "exit_code": 0
}

Confirmed. `values_native.take(indices_native)` is the cause of the bug. It should be just `values_native`.

Now I should check if this affects other backends. The issue description specifically mentions `pyarrow backed series`.
`narwhals` has multiple backends. I should check if other backends have a similar `scatter` implementation.

I'll search for `def scatter` in all `narwhals` files.

{
  "command": "grep -rn \"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
}

Let's check `narwhals/series.py` first. It's probably the base class.

{
  "end_line": 250,
  "filepath": "narwhals/series.py",
  "start_line": 230
}

{
  "status": "ok",
  "filepath": "narwhals/series.py",
  "content": "            Series: '' [i64]\n            [\n              1\n              2\n            ]\n        \"\"\"\n        return self._compliant_series.native\n\n    def scatter(self, indices: int | Sequence[int], values: Any) -> Self:\n        \"\"\"Set value(s) at given position(s).\n\n        Arguments:\n            indices: Position(s) to set items at.\n            values: Values to set.\n\n        Returns:\n            A new Series with values set at given positions.\n\n        Note:\n            This method always returns a new Series, without modifying the original one.\n            Using this function in a for-loop is an anti-pattern, we recommend building",
  "start_line": 230,
  "end_line": 250,
  "total_lines": 2699,
  "is_truncated": false
}

Wait, `narwhals/series.py` implementation probably just delegates. Let me read more of it.

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

{
  "status": "ok",
  "filepath": "narwhals/series.py",
  "content": "            up your positions and values beforehand and doing an update in one go.\n\n            For example, instead of\n\n            ```python\n            for i in [1, 3, 2]:\n                value = some_function(i)\n                s = s.scatter(i, value)\n            ```\n",
  "start_line": 251,
  "end_line": 260,
  "total_lines": 2699,
  "is_truncated": false
}

I'm reading the docstring. Let me read further to see the implementation.

{
  "end_line": 280,
  "filepath": "narwhals/series.py",
  "start_line": 261
}

{
  "status": "ok",
  "filepath": "narwhals/series.py",
  "content": "            prefer\n\n            ```python\n            positions = [1, 3, 2]\n            values = [some_function(x) for x in positions]\n            s = s.scatter(positions, values)\n            ```\n\n        Examples:\n            >>> import pyarrow as pa\n            >>> import narwhals as nw\n            >>>\n            >>> df_native = pa.table({\"a\": [1, 2, 3], \"b\": [4, 5, 6]})\n            >>> df_nw = nw.from_native(df_native)\n            >>> df_nw.with_columns(df_nw[\"a\"].scatter([0, 1], [999, 888])).to_native()\n            pyarrow.Table\n            a: int64\n            b: int64\n            ----\n            a: [[999,888,3]]",
  "start_line": 261,
  "end_line": 280,
  "total_lines": 2699,
  "is_truncated": false
}

Still docstrings.

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

{
  "status": "ok",
  "filepath": "narwhals/series.py",
  "content": "            b: [[4,5,6]]\n        \"\"\"\n        return self._with_compliant(\n            self._compliant_series.scatter(indices, self._extract_native(values))\n        )\n\n    @property\n    def shape(self) -> tuple[int]:\n        \"\"\"Get the shape of the Series.\n\n        Returns:\n            A tuple containing the length of the Series.\n\n        Examples:\n            >>> import pandas as pd\n            >>> import narwhals as nw\n            >>>\n            >>> s_native = pd.Series([1, 2, 3])\n            >>> nw.from_native(s_native, series_only=True).shape\n            (3,)",
  "start_line": 281,
  "end_line": 300,
  "total_lines": 2699,
  "is_truncated": false
}

Okay, `narwhals/series.py` just calls `self._compliant_series.scatter(indices, self._extract_native(values))`.
Now let's check `narwhals/_compliant/series.py`.

{
  "end_line": 270,
  "filepath": "narwhals/_compliant/series.py",
  "start_line": 240
}

{
  "status": "ok",
  "filepath": "narwhals/_compliant/series.py",
  "content": "        self, window_size: int, *, min_samples: int, center: bool, ddof: int\n    ) -> Self: ...\n    def round(self, decimals: int) -> Self: ...\n    def sample(\n        self,\n        n: int | None,\n        *,\n        fraction: float | None,\n        with_replacement: bool,\n        seed: int | None,\n    ) -> Self: ...\n    def scatter(self, indices: int | Sequence[int], values: Any) -> Self: ...\n    def shift(self, n: int) -> Self: ...\n    def skew(self) -> float | None: ...\n    def sort(self, *, descending: bool, nulls_last: bool) -> Self: ...\n    def std(self, *, ddof: int) -> float: ...\n    def sum(self) -> float: ...\n    def tail(self, n: int) -> Self: ...\n    def to_arrow(self) -> pa.Array[Any]: ...\n    def to_dummies(\n        self, *, separator: str, drop_first: bool\n    ) -> CompliantDataFrame[Self, Any, Any, Any]: ...\n    def to_frame(self) -> CompliantDataFrame[Self, Any, Any, Any]: ...\n    def to_list(self) -> list[Any]: ...\n    def to_pandas(self) -> pd.Series[Any]: ...\n    def to_polars(self) -> pl.Series: ...\n    def unique(self, *, maintain_order: bool) -> Self: ...\n    def value_counts(\n        self, *, sort: bool, parallel: bool, name: str | None, normalize: bool\n    ) -> CompliantDataFrame[Self, Any, Any, Any]: ...\n    def var(self, *, ddof: int) -> float: ...",
  "start_line": 240,
  "end_line": 270,
  "total_lines": 433,
  "is_truncated": false
}

`_compliant/series.py` seems to be just type hints/stubs.

Now 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 uses its own `scatter` method on `self.native` (which is a Polars series). That's likely correct.

Now 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 uses `iloc[indices] = values`, which should be correct.

So the bug is indeed specific to the Arrow implementation.

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

```python
<<<<
        return self._with_native(
            pc_replace_with_mask(self.native, mask, values_native.take(indices_native))
        )
====
        return self._with_native(
            pc_replace_with_mask(self.native, mask, values_native)
        )
>>>>
```

Wait, before I submit, I should consider if there are any other issues.
The original 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))
        )
```
Wait, `indices_native` is now sorted.
`values_native` was taken using `sorting_indices`, so it's also sorted to match `indices_native`.

If `indices_native` starts as `[2, 0]` and `values_native` starts as `[888, 999]`.
`sorting_indices` = `[1, 0]`.
`indices_native` becomes `[0, 2]`.
`values_native` becomes `[999, 888]`.
`mask` = `[True, False, True]`.
`pc.replace_with_mask(self.native, mask, [999, 888])` will put 999 at index 0 and 888 at index 2.
Correct.

Wait, what if the same index is provided multiple times?
`indices = [0, 0]`, `values = [1, 2]`.
`sorting_indices` = `[0, 1]`.
`indices_native` = `[0, 0]`.
`values_native` = `[1, 2]`.
`mask` = `[True, False, False]`. (Since it's a boolean mask).
`pc.replace_with_mask(self.native, mask, [1, 2])`.
If `mask` has only one `True`, and `values_native` has two elements, what does `replace_with_mask` do?

Let's check PyArrow documentation or test it.

{
  "command": "python3 - <<'PY'\nimport pyarrow as pa\nimport pyarrow.compute as pc\nimport numpy as np\n\nser_native = pa.array([1, 2, 3])\nmask = np.array([True, False, False])\nvalues = pa.array([999, 888])\n\ntry:\n    result = pc.replace_with_mask(ser_native, mask, values)\n    print(\"Result:\", result)\nexcept Exception as e:\n    print(\"Error:\", e)\nPY\n"
}

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

It seems it just takes the first element of `values` and ignores the rest? Or it might raise an error if they don't match in length? In the above case it didn't raise an error.

Wait, if the user provides `indices = [0, 0]` and `values = [1, 2]`, what should happen?
In Pandas:
```python
import pandas as pd
s = pd.Series([1, 2, 3])
s.iloc[[0, 0]] = [1, 2]
# s becomes [2, 2, 3]
```
The last value wins.

In Polars:
```python
import polars as pl
s = pl.Series([1, 2, 3])
s.gather([0, 0], values=[1, 2]) # Wait, polars doesn't have scatter like this
# Polars scatter:
s.scatter([0, 0], [1, 2])
# Result: [2, 2, 3]
```
Again, last value wins.

Our current implementation:
`sorting_indices = pc.sort_indices(indices_native)`
`indices_native = indices_native.take(sorting_indices)`
`values_native = values_native.take(sorting_indices)`
If `indices = [0, 0]`, `sorting_indices` could be `[0, 1]`.
`indices_native` = `[0, 0]`.
`values_native` = `[1, 2]`.
`mask` = `[True, False, False]`.
`pc.replace_with_mask(self.native, mask, [1, 2])` -> `[1, 2, 3]`.
Value 1 wins, but it should be 2.

Wait, if `indices_native` has duplicates, `mask` will have fewer `True` values than `len(indices_native)`.
PyArrow `replace_with_mask` requires that the `replacements` array has the same length as the number of True values in the mask.

Wait, let me re-test `replace_with_mask` with different lengths.

{
  "command": "python3 - <<'PY'\nimport pyarrow as pa\nimport pyarrow.compute as pc\nimport numpy as np\n\nser_native = pa.array([1, 2, 3])\nmask = np.array([True, False, True])\nvalues = pa.array([999])\n\ntry:\n    result = pc.replace_with_mask(ser_native, mask, values)\n    print(\"Result (short values):\", result)\nexcept Exception as e:\n    print(\"Error (short values):\", e)\n\nvalues_long = pa.array([999, 888, 777])\ntry:\n    result = pc.replace_with_mask(ser_native, mask, values_long)\n    print(\"Result (long values):\", result)\nexcept Exception as e:\n    print(\"Error (long values):\", e)\nPY\n"
}

{
  "status": "ok",
  "stdout": "Error (short values): Replacement array must be of appropriate length (expected 2 items but got 1 items)\nResult (long values): [\n  999,\n  2,\n  888\n]\n",
  "stderr": "",
  "exit_code": 0
}

So `replace_with_mask` ignores extra elements in `replacements`, but requires at least as many as there are `True` in `mask`.

If `indices = [0, 0]` and `values = [1, 2]`:
`indices_native` = `[0, 0]`
`values_native` = `[1, 2]`
`mask` = `[True, False, False]` (1 True)
`replacements` = `[1, 2]`
`replace_with_mask` returns `[1, 2, 3]`.
The value at index 0 is 1. But it should be 2.

To make the last value win, we should handle duplicates in `indices_native`.
If we want the last elements of `values` to win, we can use `unique` on `indices_native` but keeping the last occurrence.

Wait, is this a requirement for `scatter`?
The problem statement just says `ArrowSeries.scatter` raises out of bound error. It doesn't mention duplicates.
But for a robust implementation, we should consider it.

However, the immediate task is fixing the "out of bound error".
The out of bound error is caused by `values_native.take(indices_native)`.

Let's see if I should fix the duplicate issue as well.
The current implementation of `scatter` in `_arrow/series.py` seems to be trying to implement it using `replace_with_mask`.

If I change `values_native.take(indices_native)` to `values_native`, the "out of bound" error will be fixed.

Wait, let's look at the `sorting_indices` part again.
```python
        sorting_indices = pc.sort_indices(indices_native)
        indices_native = indices_native.take(sorting_indices)
        values_native = values_native.take(sorting_indices)
```
This part ensures that `indices_native` is sorted.
Then `mask[indices_native] = True` is used.

If `indices = [0, 2]` and `values = [999, 888]`, then `indices_native` becomes `[0, 2]` and `values_native` becomes `[999, 888]`.
`mask` is `[True, False, True]`.
`pc.replace_with_mask(self.native, mask, values_native)` will put 999 at index 0 and 888 at index 2.

What if `indices = [2, 0]` and `values = [888, 999]`?
`sorting_indices` = `[1, 0]`.
`indices_native` = `[0, 2]`.
`values_native` = `[999, 888]`.
`mask` = `[True, False, True]`.
`pc.replace_with_mask(self.native, mask, values_native)` will put 999 at index 0 and 888 at index 2.
Correct.

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

Regarding duplicates: if `indices = [0, 0]` and `values = [1, 2]`.
`sorting_indices` = `[0, 1]`.
`indices_native` = `[0, 0]`.
`values_native` = `[1, 2]`.
`mask` = `[True, False, False]`.
`replace_with_mask` uses `values_native[0]` which is 1.
But the last one should win, which is 2.

To fix this, we could use `np.unique` with `return_index=True` and then take the last occurrence. Or just let it be for now if it's not the primary concern. But since I'm a principal engineer, I should probably fix it if it's easy.

Wait, if I use `np.unique` on `indices_native`, I'll get the unique indices and their first occurrences.

Actually, there's a simpler way to make the last one win:
Use `indices_native` to set values in a NumPy array, then convert back to Arrow.
But we are using PyArrow's `replace_with_mask`.

If we want the last one to win:
1. Use `np.unique` on `indices_native` to find unique indices.
2. Find the last occurrence of each unique index in the original `indices_native`.
3. Use those indices to slice `values_native`.

But wait, the current code is:
```python
        sorting_indices = pc.sort_indices(indices_native)
        indices_native = indices_native.take(sorting_indices)
        values_native = values_native.take(sorting_indices)
```
Now `indices_native` is sorted.
If `indices_native = [0, 0, 1, 2, 2]`.
`values_native` = `[v0, v1, v2, v3, v4]`.
We want `v1` for index 0, `v2` for index 1, `v4` for index 2.

We can use `np.unique(indices_native, return_index=False, return_counts=False)` to get `[0, 1, 2]`.
Then we need the indices of the last occurrences.

Wait, if I just want to fix the reported bug, the simplest fix is removing `.take(indices_native)`. Let's see if the reproduction test passes with that.

Reproduction tests:
1. `ser.scatter(1, 999)`
2. `ser.scatter([0, 2], [999, 888])`

In both cases, `indices` are unique.

I'll just remove the `.take(indices_native)` and see. I don't want to over-engineer it and potentially introduce new bugs if the duplicate case is not critical or handled differently in other backends.

Wait, let's check how `_pandas_like/series.py` handles it.
`s.iloc[indices] = values`
In pandas, if `indices` has duplicates, the last one wins.

So the Arrow implementation currently doesn't handle duplicates correctly.

Let's see if I can fix it easily.
```python
        sorting_indices = pc.sort_indices(indices_native)
        indices_native = indices_native.take(sorting_indices)
        values_native = values_native.take(sorting_indices)

        # Fix for duplicates: keep last occurrence
        # Use a mask to keep only the last occurrence of each index
        # or just use np.unique's return_index?
        # np.unique(indices_native) returns sorted unique elements.
```

Actually, if I want the last one to win, and I've already sorted `indices_native`, I just need to find the last occurrence of each unique value in the sorted `indices_native`.

Example: `indices_native = [0, 0, 1, 2, 2]`
Sorted indices are already `[0, 0, 1, 2, 2]`.
Unique values are `[0, 1, 2]`.
Last indices are `[1, 2, 3]`.
So `values_native` should be `[v1, v2, v4]`.

How to do this in PyArrow or NumPy?
In NumPy: `_, idx = np.unique(indices_native, return_index=True)` gives first occurrences.
Wait, if I want last occurrences, I can reverse the array, find first occurrences, and then reverse back.

But wait, the current code already does:
```python
        mask: _1DArray = np.zeros(self.len(), dtype=bool)
        mask[indices_native] = True
```
Since `indices_native` is used as a NumPy index, and `mask` is a NumPy array, if `indices_native` has duplicates, it just sets the same position to `True` multiple times.
`mask[0] = True`
`mask[0] = True`
`mask` at index 0 is `True`.

Then `pc.replace_with_mask(self.native, mask, values_native)` is called.
It will use `values_native[0]`, `values_native[1]`, etc. for each `True` in `mask`.
But `values_native` currently has all values, including those for duplicated indices.
So `values_native` is longer than the number of `True` values in `mask`.
PyArrow's `replace_with_mask` just takes the first $N$ elements of `values_native` where $N$ is the number of `True` values in `mask`.
This means it takes the *first* occurrence of each index, not the *last*.

To make it take the last occurrence:
We need to filter `values_native` to only keep the last occurrence of each index in the sorted `indices_native`.

But wait, if I do this:
```python
        unique_indices, first_indices = np.unique(indices_native, return_index=True)
        # This isn't quite right because I want last.
```

Actually, if I just want to fix the reported bug, the simplest fix is removing `.take(indices_native)`.
Let's see if I can find any other `scatter` calls in the codebase to see how they are tested.

The reproduction code provided in the issue only uses unique indices.
I'll stick to the minimal fix.

{
  "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 run the reproduction script again to verify the fix.

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

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