chore[python]: remove Series.inner (#4595)

py-polars/polars/internals/construction.py

@@ -65,7 +65,7 @@
 def series_to_pyseries(name: str, values: pli.Series) -> PySeries:
     """Construct a PySeries from a Polars Series."""
     values.rename(name, in_place=True)
-    return values.inner()
+    return values._s
 
 
 def arrow_to_pyseries(name: str, values: pa.Array, rechunk: bool = True) -> PySeries:
@@ -287,7 +287,7 @@ def sequence_to_pyseries(
             return PySeries.new_object(name, values, strict)
 
         elif python_dtype == pli.Series:
-            return PySeries.new_series_list(name, [v.inner() for v in values], strict)
+            return PySeries.new_series_list(name, [v._s for v in values], strict)
         elif python_dtype == PySeries:
             return PySeries.new_series_list(name, values, strict)
         else:
@@ -397,7 +397,7 @@ def _handle_columns_arg(
         return data
     else:
         if not data:
-            return [pli.Series(c, None).inner() for c in columns]
+            return [pli.Series(c, None)._s for c in columns]
         elif len(data) == len(columns):
             for i, c in enumerate(columns):
                 data[i].rename(c)
@@ -465,11 +465,11 @@ def dict_to_pydf(
 
         if not data and dtypes:
             data_series = [
-                pli.Series(name, [], dtypes.get(name)).inner() for name in columns
+                pli.Series(name, [], dtypes.get(name))._s for name in columns
             ]
         else:
             data_series = [
-                pli.Series(name, values, dtypes.get(name)).inner()
+                pli.Series(name, values, dtypes.get(name))._s
                 for name, values in data.items()
             ]
         data_series = _handle_columns_arg(data_series, columns=columns)
@@ -495,7 +495,7 @@ def dict_to_pydf(
             pool_size = threadpool_size()
             pool = multiprocessing.dummy.Pool(pool_size)
             data_series = pool.map(
-                lambda t: pli.Series(t[0], t[1]).inner(),
+                lambda t: pli.Series(t[0], t[1])._s,
                 [(k, v) for k, v in data.items()],
             )
             return PyDataFrame(data_series)
@@ -528,7 +528,7 @@ def sequence_to_pydf(
             if new_dtype and new_dtype != s.dtype:
                 s = s.cast(new_dtype)
 
-            data_series.append(s.inner())
+            data_series.append(s._s)
 
     elif isinstance(data[0], dict):
         pydf = PyDataFrame.read_dicts(data, infer_schema_length)
@@ -549,7 +549,7 @@ def sequence_to_pydf(
         elif orient == "col" or orient is None:
             columns, dtypes = _unpack_columns(columns, n_expected=len(data))
             data_series = [
-                pli.Series(columns[i], data[i], dtypes.get(columns[i])).inner()
+                pli.Series(columns[i], data[i], dtypes.get(columns[i]))._s
                 for i in range(len(data))
             ]
         else:
@@ -559,7 +559,7 @@ def sequence_to_pydf(
 
     else:
         columns, dtypes = _unpack_columns(columns, n_expected=1)
-        data_series = [pli.Series(columns[0], data, dtypes.get(columns[0])).inner()]
+        data_series = [pli.Series(columns[0], data, dtypes.get(columns[0]))._s]
 
     data_series = _handle_columns_arg(data_series, columns=columns)
     return PyDataFrame(data_series)
@@ -620,17 +620,17 @@ def numpy_to_pydf(
         data_series = []
 
     elif len(shape) == 1:
-        data_series = [pli.Series(columns[0], data, dtypes.get(columns[0])).inner()]
+        data_series = [pli.Series(columns[0], data, dtypes.get(columns[0]))._s]
 
     else:
         if orient == "row":
             data_series = [
-                pli.Series(columns[i], data[:, i], dtypes.get(columns[i])).inner()
+                pli.Series(columns[i], data[:, i], dtypes.get(columns[i]))._s
                 for i in range(n_columns)
             ]
         else:
             data_series = [
-                pli.Series(columns[i], data[i], dtypes.get(columns[i])).inner()
+                pli.Series(columns[i], data[i], dtypes.get(columns[i]))._s
                 for i in range(n_columns)
             ]
 
@@ -704,7 +704,7 @@ def arrow_to_pydf(
 
 def series_to_pydf(data: pli.Series, columns: ColumnsType | None = None) -> PyDataFrame:
     """Construct a PyDataFrame from a Polars Series."""
-    data_series = [data.inner()]
+    data_series = [data._s]
     series_name = [s.name() for s in data_series]
     columns, dtypes = _unpack_columns(columns or series_name, n_expected=1)
     if dtypes:

py-polars/polars/internals/dataframe/frame.py

@@ -1865,7 +1865,7 @@ def __getitem__(
             if item.dtype.kind in ("i", "u"):
                 # Numpy array with signed or unsigned integers.
                 return self._from_pydf(
-                    self._df.take_with_series(self._pos_idxs(item, dim=0).inner())
+                    self._df.take_with_series(self._pos_idxs(item, dim=0)._s)
                 )
             if isinstance(item[0], str):
                 return self._from_pydf(self._df.select(item))
@@ -1882,10 +1882,10 @@ def __getitem__(
             if dtype == Utf8:
                 return self._from_pydf(self._df.select(item))
             if dtype == UInt32:
-                return self._from_pydf(self._df.take_with_series(item.inner()))
+                return self._from_pydf(self._df.take_with_series(item._s))
             if dtype in {UInt8, UInt16, UInt64, Int8, Int16, Int32, Int64}:
                 return self._from_pydf(
-                    self._df.take_with_series(self._pos_idxs(item, dim=0).inner())
+                    self._df.take_with_series(self._pos_idxs(item, dim=0)._s)
                 )
 
         # if no data has been returned, the operation is not supported
@@ -2578,7 +2578,7 @@ def replace(self, column: str, new_col: pli.Series) -> None:
         └─────┴─────┘
 
         """
-        self._df.replace(column, new_col.inner())
+        self._df.replace(column, new_col._s)
 
     def slice(self: DF, offset: int, length: int | None = None) -> DF:
         """
@@ -3976,10 +3976,10 @@ def hstack(
         if not isinstance(columns, list):
             columns = columns.get_columns()
         if in_place:
-            self._df.hstack_mut([s.inner() for s in columns])
+            self._df.hstack_mut([s._s for s in columns])
             return None
         else:
-            return self._from_pydf(self._df.hstack([s.inner() for s in columns]))
+            return self._from_pydf(self._df.hstack([s._s for s in columns]))
 
     @overload
     def vstack(self, df: DataFrame, in_place: Literal[True]) -> None:

py-polars/polars/internals/series/series.py

@@ -270,9 +270,6 @@ def _from_pandas(
             pandas_to_pyseries(name, values, nan_to_none=nan_to_none)
         )
 
-    def inner(self) -> PySeries:
-        return self._s
-
     def __getstate__(self) -> Any:
         return self._s.__getstate__()
 
@@ -568,9 +565,9 @@ def __getitem__(
                 raise ValueError("Only a 1D-Numpy array is supported as index.")
             if item.dtype.kind in ("i", "u"):
                 # Numpy array with signed or unsigned integers.
-                return wrap_s(self._s.take_with_series(self._pos_idxs(item).inner()))
+                return wrap_s(self._s.take_with_series(self._pos_idxs(item)._s))
             if item.dtype == bool:
-                return wrap_s(self._s.filter(pli.Series("", item).inner()))
+                return wrap_s(self._s.filter(pli.Series("", item)._s))
 
         if is_bool_sequence(item) or is_int_sequence(item):
             item = Series("", item)  # fall through to next if isinstance
@@ -579,9 +576,9 @@ def __getitem__(
             if item.dtype == Boolean:
                 return wrap_s(self._s.filter(item._s))
             if item.dtype == UInt32:
-                return wrap_s(self._s.take_with_series(item.inner()))
+                return wrap_s(self._s.take_with_series(item._s))
             if item.dtype in {UInt8, UInt16, UInt64, Int8, Int16, Int32, Int64}:
-                return wrap_s(self._s.take_with_series(self._pos_idxs(item).inner()))
+                return wrap_s(self._s.take_with_series(self._pos_idxs(item)._s))
 
         if isinstance(item, range):
             return self[range_to_slice(item)]