narwhals-dev__narwhals-2864

{
  "status": "ok",
  "stdout": "Testing single index scatter...\nCaught exception: Index 1 out of bounds\n\nTesting multiple indices scatter...\nCaught exception: Index 2 out of bounds\n",
  "stderr": "",
  "exit_code": 0
}

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

{
  "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)\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]\n        )\n        return self._with_native(result)\n\n    def round(self, decimals: int) -> Self:\n        return self._with_native(\n            pc.round(self.native, decimals, round_mode=\"half_towards_infinity\")\n        )\n\n    def diff(self) -> Self:\n        return self._with_native(pc.pairwise_diff(self.native.combine_chunks()))\n\n    def any(self, *, _return_py_scalar: bool = True) -> bool:\n        return maybe_extract_py_scalar(\n            pc.any(self.native, min_count=0), _return_py_scalar\n        )\n\n    def all(self, *, _return_py_scalar: bool = True) -> bool:\n        return maybe_extract_py_scalar(\n            pc.all(self.native, min_count=0), _return_py_scalar\n        )\n\n    def is_between(\n        self, lower_bound: Any, upper_bound: Any, closed: ClosedInterval\n    ) -> Self:\n        _, lower_bound = extract_native(self, lower_bound)\n        _, upper_bound = extract_native(self, upper_bound)\n        if closed == \"left\":\n            ge = pc.greater_equal(self.native, lower_bound)\n            lt = pc.less(self.native, upper_bound)\n            res = pc.and_kleene(ge, lt)\n        elif closed == \"right\":\n            gt = pc.greater(self.native, lower_bound)\n            le = pc.less_equal(self.native, upper_bound)\n            res = pc.and_kleene(gt, le)\n        elif closed == \"none\":\n            gt = pc.greater(self.native, lower_bound)\n            lt = pc.less(self.native, upper_bound)\n            res = pc.and_kleene(gt, lt)\n        elif closed == \"both\":\n            ge = pc.greater_equal(self.native, lower_bound)\n            le = pc.less_equal(self.native, upper_bound)\n            res = pc.and_kleene(ge, le)\n        else:\n            assert_never(closed)\n        return self._with_native(res)\n\n    def is_null(self) -> Self:\n        return self._with_native(self.native.is_null(), preserve_broadcast=True)\n\n    def is_nan(self) -> Self:\n        return self._with_native(pc.is_nan(self.native), preserve_broadcast=True)\n\n    def cast(self, dtype: IntoDType) -> Self:\n        data_type = narwhals_to_native_dtype(dtype, self._version)\n        return self._with_native(pc.cast(self.native, data_type), preserve_broadcast=True)\n\n    def null_count(self, *, _return_py_scalar: bool = True) -> int:\n        return maybe_extract_py_scalar(self.native.null_count, _return_py_scalar)\n\n    def head(self, n: int) -> Self:\n        if n >= 0:\n            return self._with_native(self.native.slice(0, n))\n        else:\n            num_rows = len(self)\n            return self._with_native(self.native.slice(0, max(0, num_rows + n)))\n\n    def tail(self, n: int) -> Self:\n        if n >= 0:\n            num_rows = len(self)\n            return self._with_native(self.native.slice(max(0, num_rows - n)))\n        else:\n            return self._with_native(self.native.slice(abs(n)))\n\n    def is_in(self, other: Any) -> Self:\n        if self._is_native(other):\n            value_set: ArrayOrChunkedArray = other\n        else:\n            value_set = pa.array(other)\n        return self._with_native(pc.is_in(self.native, value_set=value_set))\n\n    def arg_true(self) -> Self:\n        import numpy as np  # ignore-banned-import\n\n        res = np.flatnonzero(self.native)\n        return self.from_iterable(res, name=self.name, context=self)\n\n    def item(self, index: int | None = None) -> Any:\n        if index is None:\n            if len(self) != 1:",
  "start_line": 440,
  "end_line": 589,
  "total_lines": 1170,
  "is_truncated": true
}

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

{
  "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/series.py",
  "content": "    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\n            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\n            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]]\n            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,)\n        \"\"\"\n        return (self._compliant_series.len(),)\n\n    def _extract_native(self, arg: Any) -> Any:\n        from narwhals.series import Series\n\n        if isinstance(arg, Series):\n            return arg._compliant_series\n        return arg\n\n    def _with_compliant(self, series: Any) -> Self:\n        return self.__class__(series, level=self._level)\n\n    def pipe(self, function: Callable[[Any], Self], *args: Any, **kwargs: Any) -> Self:\n        \"\"\"Pipe function call.\n\n        Returns:\n            A new Series with the results of the piped function applied.\n\n        Examples:\n            >>> import polars as pl\n            >>> import narwhals as nw\n            >>> s_native = pl.Series([1, 2, 3])\n            >>> s = nw.from_native(s_native, series_only=True)\n            >>> s.pipe(lambda x: x + 2).to_native()  # doctest: +NORMALIZE_WHITESPACE\n            shape: (3,)\n            Series: '' [i64]\n            [\n                3\n                4\n                5\n            ]\n        \"\"\"\n        return function(self, *args, **kwargs)\n\n    def __repr__(self) -> str:  # pragma: no cover\n        return generate_repr(\"Narwhals Series\", self.to_native().__repr__())\n\n    def __len__(self) -> int:\n        return len(self._compliant_series)\n\n    def len(self) -> int:\n        r\"\"\"Return the number of elements in the Series.\n\n        Null values count towards the total.\n\n        Returns:\n            The number of elements in the Series.\n\n        Examples:\n            >>> import pyarrow as pa\n            >>> import narwhals as nw\n            >>>\n            >>> s_native = pa.chunked_array([[1, 2, None]])\n            >>> nw.from_native(s_native, series_only=True).len()\n            3\n        \"\"\"\n        return len(self._compliant_series)\n\n    @property\n    def dtype(self) -> DType:\n        \"\"\"Get the data type of the Series.\n\n        Returns:\n            The data type 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).dtype\n            Int64\n        \"\"\"\n        return self._compliant_series.dtype\n\n    @property\n    def name(self) -> str:\n        \"\"\"Get the name of the Series.\n\n        Returns:\n            The name of the Series.\n\n        Examples:\n            >>> import polars as pl\n            >>> import narwhals as nw\n            >>>",
  "start_line": 238,
  "end_line": 387,
  "total_lines": 2699,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "narwhals/_polars/series.py",
  "content": "    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\n    def __contains__(self, other: Any) -> bool:\n        try:\n            return self.native.__contains__(other)\n        except Exception as e:  # noqa: BLE001\n            raise catch_polars_exception(e) from None\n\n    def hist(  # noqa: C901, PLR0912\n        self,\n        bins: list[float | int] | None,\n        *,\n        bin_count: int | None,\n        include_breakpoint: bool,\n    ) -> PolarsDataFrame:\n        from narwhals._polars.dataframe import PolarsDataFrame\n\n        if (bins is not None and len(bins) <= 1) or (bin_count == 0):  # pragma: no cover\n            data: list[pl.Series] = []\n            if include_breakpoint:\n                data.append(pl.Series(\"breakpoint\", [], dtype=pl.Float64))\n            data.append(pl.Series(\"count\", [], dtype=pl.UInt32))\n            return PolarsDataFrame.from_native(pl.DataFrame(data), context=self)\n\n        if self.native.count() < 1:\n            data_dict: dict[str, Sequence[Any] | pl.Series]\n            if bins is not None:\n                data_dict = {\n                    \"breakpoint\": bins[1:],\n                    \"count\": pl.zeros(n=len(bins) - 1, dtype=pl.Int64, eager=True),\n                }\n            elif (bin_count is not None) and bin_count == 1:\n                data_dict = {\"breakpoint\": [1.0], \"count\": [0]}\n            elif (bin_count is not None) and bin_count > 1:\n                data_dict = {\n                    \"breakpoint\": pl.int_range(1, bin_count + 1, eager=True) / bin_count,\n                    \"count\": pl.zeros(n=bin_count, dtype=pl.Int64, eager=True),\n                }\n            else:  # pragma: no cover\n                msg = (\n                    \"congratulations, you entered unreachable code - please report a bug\"\n                )\n                raise AssertionError(msg)\n            if not include_breakpoint:\n                del data_dict[\"breakpoint\"]\n            return PolarsDataFrame.from_native(pl.DataFrame(data_dict), context=self)\n\n        # polars <1.15 does not adjust the bins when they have equivalent min/max\n        # polars <1.5 with bin_count=...\n        # returns bins that range from -inf to +inf and has bin_count + 1 bins.\n        #   for compat: convert `bin_count=` call to `bins=`\n        if (self._backend_version < (1, 15)) and (\n            bin_count is not None\n        ):  # pragma: no cover\n            lower = cast(\"float\", self.native.min())\n            upper = cast(\"float\", self.native.max())\n            if lower == upper:\n                width = 1 / bin_count\n                lower -= 0.5\n                upper += 0.5\n            else:\n                width = (upper - lower) / bin_count\n\n            bins = (pl.int_range(0, bin_count + 1, eager=True) * width + lower).to_list()\n            bin_count = None\n\n        # Polars inconsistently handles NaN values when computing histograms\n        #   against predefined bins: https://github.com/pola-rs/polars/issues/21082\n        series = self.native\n        if self._backend_version < (1, 15) or bins is not None:\n            series = series.set(series.is_nan(), None)\n\n        df = series.hist(\n            bins,\n            bin_count=bin_count,\n            include_category=False,\n            include_breakpoint=include_breakpoint,\n        )\n\n        if not include_breakpoint:\n            df.columns = [\"count\"]\n\n        if self._backend_version < (1, 0) and include_breakpoint:\n            df = df.rename({\"break_point\": \"breakpoint\"})\n\n        #  polars<1.15 implicitly adds -inf and inf to either end of bins\n        if self._backend_version < (1, 15) and bins is not None:  # pragma: no cover\n            r = pl.int_range(0, len(df))\n            df = df.filter((r > 0) & (r < len(df) - 1))\n\n        # polars<1.27 makes the lowest bin a left/right closed interval.\n        if self._backend_version < (1, 27) and bins is not None:\n            df[0, \"count\"] += (series == bins[0]).sum()\n\n        return PolarsDataFrame.from_native(df, context=self)\n\n    def to_polars(self) -> pl.Series:\n        return self.native\n\n    @property\n    def dt(self) -> PolarsSeriesDateTimeNamespace:\n        return PolarsSeriesDateTimeNamespace(self)\n\n    @property\n    def str(self) -> PolarsSeriesStringNamespace:\n        return PolarsSeriesStringNamespace(self)\n\n    @property\n    def cat(self) -> PolarsSeriesCatNamespace:\n        return PolarsSeriesCatNamespace(self)\n\n    @property\n    def struct(self) -> PolarsSeriesStructNamespace:\n        return PolarsSeriesStructNamespace(self)\n\n    __add__: Method[Self]\n    __and__: Method[Self]\n    __floordiv__: Method[Self]\n    __invert__: Method[Self]\n    __iter__: Method[Iterator[Any]]\n    __mod__: Method[Self]\n    __mul__: Method[Self]\n    __or__: Method[Self]",
  "start_line": 432,
  "end_line": 581,
  "total_lines": 741,
  "is_truncated": true
}

{
  "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": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 30, in <module>\n  File \"<stdin>\", line 9, in test_scatter\n  File \"/workspace/narwhals/series.py\", line 284, in scatter\n    self._compliant_series.scatter(indices, self._extract_native(values))\n  File \"/workspace/narwhals/_arrow/series.py\", line 471, in scatter\n    pc_replace_with_mask(self.native, mask, values_native)\n  File \"/usr/local/lib/python3.10/site-packages/pyarrow/compute.py\", line 254, in wrapper\n    return func.call(args, None, memory_pool)\n  File \"pyarrow/_compute.pyx\", line 405, in pyarrow._compute.Function.call\n  File \"pyarrow/error.pxi\", line 155, in pyarrow.lib.pyarrow_internal_check_status\n  File \"pyarrow/error.pxi\", line 92, in pyarrow.lib.check_status\npyarrow.lib.ArrowNotImplementedError: Function 'replace_with_mask' has no kernel matching input types (int64, bool, null)\n",
  "details": {
    "stdout": "indices=1, values=999, expected=[1, 999, 3], actual=[np.int64(1), np.int64(999), np.int64(3)]\nindices=[0, 2], values=[999, 888], expected=[999, 2, 888], actual=[np.int64(999), np.int64(2), np.int64(888)]\nindices=0, values=999, expected=[999, 2, 3], actual=[np.int64(999), np.int64(2), np.int64(3)]\nindices=[0, 1, 2], values=[9, 8, 7], expected=[9, 8, 7], actual=[np.int64(9), np.int64(8), np.int64(7)]\nindices=[2, 0], values=[888, 999], expected=[999, 2, 888], actual=[np.int64(999), np.int64(2), np.int64(888)]\n",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 30, in <module>\n  File \"<stdin>\", line 9, in test_scatter\n  File \"/workspace/narwhals/series.py\", line 284, in scatter\n    self._compliant_series.scatter(indices, self._extract_native(values))\n  File \"/workspace/narwhals/_arrow/series.py\", line 471, in scatter\n    pc_replace_with_mask(self.native, mask, values_native)\n  File \"/usr/local/lib/python3.10/site-packages/pyarrow/compute.py\", line 254, in wrapper\n    return func.call(args, None, memory_pool)\n  File \"pyarrow/_compute.pyx\", line 405, in pyarrow._compute.Function.call\n  File \"pyarrow/error.pxi\", line 155, in pyarrow.lib.pyarrow_internal_check_status\n  File \"pyarrow/error.pxi\", line 92, in pyarrow.lib.check_status\npyarrow.lib.ArrowNotImplementedError: Function 'replace_with_mask' has no kernel matching input types (int64, bool, null)\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "null\n",
  "stderr": "",
  "exit_code": 0
}

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