narwhals-dev__narwhals-2864

{
  "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
}

{
  "status": "ok",
  "filepath": "narwhals/_arrow/series.py",
  "content": "            return maybe_extract_py_scalar(k, _return_py_scalar)\n\n    def count(self, *, _return_py_scalar: bool = True) -> int:\n        return maybe_extract_py_scalar(pc.count(self.native), _return_py_scalar)\n\n    def n_unique(self, *, _return_py_scalar: bool = True) -> int:\n        return maybe_extract_py_scalar(\n            pc.count(self.native.unique(), mode=\"all\"), _return_py_scalar\n        )\n\n    def __native_namespace__(self) -> ModuleType:\n        if self._implementation is Implementation.PYARROW:\n            return self._implementation.to_native_namespace()\n\n        msg = f\"Expected pyarrow, got: {type(self._implementation)}\"  # pragma: no cover\n        raise AssertionError(msg)\n\n    @property\n    def name(self) -> str:\n        return self._name\n\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)\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(",
  "start_line": 400,
  "end_line": 470,
  "total_lines": 1170,
  "is_truncated": false
}

{
  "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:",
  "start_line": 460,
  "end_line": 480,
  "total_lines": 1170,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Error 1: Index 1 out of bounds\nError 2: Index 2 out of bounds\n",
  "stderr": "",
  "exit_code": 0
}

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

{
  "status": "ok",
  "filepath": "narwhals/series.py",
  "content": "            Series of class that user started with.\n\n        Examples:\n            >>> import polars as pl\n            >>> import narwhals as nw\n            >>>\n            >>> s_native = pl.Series([1, 2])\n            >>> s = nw.from_native(s_native, series_only=True)\n            >>> s.to_native()  # doctest: +NORMALIZE_WHITESPACE\n            shape: (2,)\n            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": 220,
  "end_line": 250,
  "total_lines": 2699,
  "is_truncated": false
}

{
  "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
}

{
  "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,\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": 260,
  "end_line": 300,
  "total_lines": 1106,
  "is_truncated": false
}

{
  "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
}

{
  "status": "ok",
  "stdout": "Success 1: ┌───────────────────────────────────────────────────┐\n|                  Narwhals Series                  |\n|---------------------------------------------------|\n|<pyarrow.lib.ChunkedArray object at 0x7b0b92129840>|\n|[                                                  |\n|  [                                                |\n|    1,                                             |\n|    999,                                           |\n|    3                                              |\n|  ]                                                |\n|]                                                  |\n└───────────────────────────────────────────────────┘\nSuccess 2: ┌───────────────────────────────────────────────────┐\n|                  Narwhals Series                  |\n|---------------------------------------------------|\n|<pyarrow.lib.ChunkedArray object at 0x7b0b921298a0>|\n|[                                                  |\n|  [                                                |\n|    999,                                           |\n|    2,                                             |\n|    888                                            |\n|  ]                                                |\n|]                                                  |\n└───────────────────────────────────────────────────┘\n",
  "stderr": "",
  "exit_code": 0
}

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

{
  "status": "ok",
  "stdout": "tests/series_only/scatter_test.py:9:def test_scatter(constructor_eager: ConstructorEager) -> None:\ntests/series_only/scatter_test.py:20:def test_scatter_indices() -> None:\ntests/series_only/scatter_test.py:27:def test_scatter_unchanged(constructor_eager: ConstructorEager) -> None:\ntests/series_only/scatter_test.py:48:def test_scatter_integer(constructor_eager: ConstructorEager) -> None:\ntests/series_only/scatter_test.py:58:def test_scatter_unordered_indices(constructor_eager: ConstructorEager) -> None:\n",
  "stderr": "",
  "exit_code": 0
}

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

{
  "status": "ok",
  "filepath": "tests/series_only/scatter_test.py",
  "content": "from __future__ import annotations\n\nimport pandas as pd\n\nimport narwhals as nw\nfrom tests.utils import ConstructorEager, assert_equal_data\n\n\ndef test_scatter(constructor_eager: ConstructorEager) -> None:\n    df = nw.from_native(\n        constructor_eager({\"a\": [1, 2, 3], \"b\": [142, 124, 132]}), eager_only=True\n    )\n    result = df.with_columns(\n        df[\"a\"].scatter([0, 1], [999, 888]), df[\"b\"].scatter([0, 2, 1], df[\"b\"])\n    )\n    expected = {\"a\": [999, 888, 3], \"b\": [142, 132, 124]}\n    assert_equal_data(result, expected)\n\n\ndef test_scatter_indices() -> None:\n    s = nw.from_native(pd.Series([2, 3, 6], index=[1, 0, 2]), series_only=True)\n    result = s.scatter([1, 0, 2], s)\n    expected = pd.Series([3, 2, 6], index=[1, 0, 2])\n    pd.testing.assert_series_equal(result.to_native(), expected)\n\n\ndef test_scatter_unchanged(constructor_eager: ConstructorEager) -> None:\n    df = nw.from_native(\n        constructor_eager({\"a\": [1, 2, 3], \"b\": [142, 124, 132]}), eager_only=True\n    )\n    df.with_columns(\n        df[\"a\"].scatter([0, 1], [999, 888]), df[\"b\"].scatter([0, 2, 1], [142, 124, 132])\n    )\n    expected = {\"a\": [1, 2, 3], \"b\": [142, 124, 132]}\n    assert_equal_data(df, expected)\n\n\ndef test_single_series(constructor_eager: ConstructorEager) -> None:\n    df = nw.from_native(\n        constructor_eager({\"a\": [1, 2, 3], \"b\": [142, 124, 132]}), eager_only=True\n    )\n    s = df[\"a\"]\n    s.scatter([0, 1], [999, 888])\n    expected = {\"a\": [1, 2, 3]}\n    assert_equal_data({\"a\": s}, expected)\n\n\ndef test_scatter_integer(constructor_eager: ConstructorEager) -> None:\n    df = nw.from_native(\n        constructor_eager({\"a\": [1, 2, 3], \"b\": [142, 124, 132]}), eager_only=True\n    )\n    s = df[\"a\"]\n    result = s.scatter(0, 999)\n    expected = {\"a\": [999, 2, 3]}\n    assert_equal_data({\"a\": result}, expected)\n\n\ndef test_scatter_unordered_indices(constructor_eager: ConstructorEager) -> None:\n    data = {\"a\": [16, 12, 10, 9, 6, 5, 2]}\n    indices = [6, 1, 0, 5, 3, 2, 4]\n    df = nw.from_native(constructor_eager(data))\n    result = df[\"a\"].scatter(indices, df[\"a\"])\n    assert_equal_data({\"a\": result}, {\"a\": [10, 12, 5, 6, 2, 9, 16]})",
  "start_line": 1,
  "end_line": 63,
  "total_lines": 63,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "Error: Replacements must be array or scalar, not ChunkedArray([\n  [\n    999\n  ],\n  [\n    888\n  ]\n])\n",
  "stderr": "",
  "exit_code": 0
}

{
  "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
}

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