[python] fill_none

examples/10_minutes_to_pypolars.ipynb

@@ -1606,13 +1606,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    " >\n",
-    "Terminal Sessions\n",
-    "\n",
-    "Kernel Sessions\n",
-    "\n",
-    "    10_minutes_to_pypolars.ipynb\n",
-    "\n",
     "df = pl.DataFrame(df.to_dict(orient=\"list\"))"
    ]
   },

py-polars/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-polars = {path = "../polars", features = ["parquet", "simd"]}
+polars = {path = "../polars", features = ["parquet", "simd", "parallel"]}
 pyo3 = {version = "0.11", features = ["extension-module"] }
 thiserror = "1.0.20"
 numpy = "0.11"

py-polars/pypolars/frame.py

@@ -293,16 +293,44 @@ def groupby(self, by: Union[str, List[str]]) -> GroupBy:
         return GroupBy(self._df, by)
 
     def join(
-        self, df: DataFrame, left_on: str, right_on: str, how="inner"
+        self, df: DataFrame, left_on: str, right_on: str, how="inner", parallel: bool = False
     ) -> DataFrame:
-        if how == "inner":
-            inner = self._df.inner_join(df._df, left_on, right_on)
-        elif how == "left":
-            inner = self._df.left_join(df._df, left_on, right_on)
-        elif how == "outer":
-            inner = self._df.outer_join(df._df, left_on, right_on)
-        else:
-            return NotImplemented
+        """
+        SQL like joins
+
+        Parameters
+        ----------
+        df
+            DataFrame to join with
+        left_on
+            Name of the left join column
+        right_on
+            Name of the right join column
+        how
+            Join strategy
+                - "inner"
+                - "left"
+                - "outer"
+        parallel
+            Use parallel join strategy.
+
+        Returns
+        -------
+            Joined DataFrame
+        """
+        self._df.with_parallel(parallel)
+        try:
+            if how == "inner":
+                inner = self._df.inner_join(df._df, left_on, right_on)
+            elif how == "left":
+                inner = self._df.left_join(df._df, left_on, right_on)
+            elif how == "outer":
+                inner = self._df.outer_join(df._df, left_on, right_on)
+            else:
+                return NotImplemented
+        except Exception as e:
+            self._df.with_parallel(False)
+            raise e
         return wrap_df(inner)
 
     def hstack(self, columns: List[Series]):
@@ -329,6 +357,25 @@ def clone(self) -> DataFrame:
     def get_columns(self) -> List[Series]:
         return list(map(lambda s: wrap_s(s), self._df.get_columns()))
 
+    def fill_none(self, strategy: str) -> DataFrame:
+        """
+        Fill None values by a filling strategy.
+
+        Parameters
+        ----------
+        strategy
+            - "backward"
+            - "forward"
+            - "mean"
+            - "min'
+            - "max"
+
+        Returns
+        -------
+            DataFrame with None replaced with the filling strategy.
+        """
+        return wrap_df(self._df.fill_none(strategy))
+
 
 class GroupBy:
     def __init__(self, df: DataFrame, by: List[str]):

py-polars/pypolars/series.py

@@ -541,3 +541,6 @@ def clone(self) -> Series:
         Cheap deep clones
         """
         return wrap_s(self._s.clone())
+
+    def fill_none(self, strategy: str) -> Series:
+        return wrap_s(self._s.fill_none(strategy))

py-polars/src/dataframe.rs

@@ -102,6 +102,23 @@ impl PyDataFrame {
         format!("{:?}", self.df)
     }
 
+    pub fn with_parallel(&mut self, parallel: bool) {
+        self.df.with_parallel(parallel);
+    }
+
+    pub fn fill_none(&self, strategy: &str) -> PyResult<Self> {
+        let strat = match strategy {
+            "backward" => FillNoneStrategy::Backward,
+            "forward" => FillNoneStrategy::Forward,
+            "min" => FillNoneStrategy::Min,
+            "max" => FillNoneStrategy::Max,
+            "mean" => FillNoneStrategy::Mean,
+            s => return Err(PyPolarsEr::Other(format!("Strategy {} not supported", s)).into()),
+        };
+        let df = self.df.fill_none(strat).map_err(PyPolarsEr::from)?;
+        Ok(PyDataFrame::new(df))
+    }
+
     pub fn inner_join(&self, other: &PyDataFrame, left_on: &str, right_on: &str) -> PyResult<Self> {
         let df = self
             .df

py-polars/src/series.rs

@@ -281,6 +281,19 @@ impl PySeries {
         self.series.as_single_ptr()
     }
 
+    pub fn fill_none(&self, strategy: &str) -> PyResult<Self> {
+        let strat = match strategy {
+            "backward" => FillNoneStrategy::Backward,
+            "forward" => FillNoneStrategy::Forward,
+            "min" => FillNoneStrategy::Min,
+            "max" => FillNoneStrategy::Max,
+            "mean" => FillNoneStrategy::Mean,
+            s => return Err(PyPolarsEr::Other(format!("Strategy {} not supported", s)).into()),
+        };
+        let series = self.series.fill_none(strat).map_err(PyPolarsEr::from)?;
+        Ok(PySeries::new(series))
+    }
+
     /// Attempts to copy data to numpy arrays. If integer types have missing values
     /// they will be casted to floating point values, where NaNs are used to represent missing.
     /// Strings will be converted to python lists and booleans will be a numpy array if there are no

py-polars/tests/test_series.py

@@ -169,3 +169,9 @@ def test_get():
     a = Series("a", [1, 2, 3])
     assert a[0] == 1
     assert a[:2] == [1, 2]
+
+
+def test_fill_none():
+    a = Series("a", [1, 2, None], nullable=True)
+    b = a.fill_none("forward")
+    assert b == [1, 2, 2]