polars-runtime-32 1.35.1__tar.gz → 1.35.2__tar.gz

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/Cargo.lock

@@ -3832,7 +3832,7 @@ dependencies = [
 
 [[package]]
 name = "py-polars"
-version = "1.35.1"
+version = "1.35.2"
 dependencies = [
  "either",
  "libc",

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polars-runtime-32
-Version: 1.35.1
+Version: 1.35.2
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Science/Research

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-core/src/frame/mod.rs

@@ -2108,6 +2108,8 @@ impl DataFrame {
 
     /// Rename a column in the [`DataFrame`].
     ///
+    /// Should not be called in a loop as that can lead to quadratic behavior.
+    ///
     /// # Example
     ///
     /// ```
@@ -2136,6 +2138,37 @@ impl DataFrame {
         Ok(self)
     }
 
+    pub fn rename_many<'a>(
+        &mut self,
+        renames: impl Iterator<Item = (&'a str, PlSmallStr)>,
+    ) -> PolarsResult<&mut Self> {
+        let mut schema = self.schema().as_ref().clone();
+        self.clear_schema();
+
+        for (from, to) in renames {
+            if from == to.as_str() {
+                continue;
+            }
+
+            polars_ensure!(
+                !schema.contains(&to),
+                Duplicate: "column rename attempted with already existing name \"{to}\""
+            );
+
+            match schema.get_full(from) {
+                None => polars_bail!(col_not_found = from),
+                Some((idx, _, _)) => {
+                    let (n, _) = schema.get_at_index_mut(idx).unwrap();
+                    *n = to.clone();
+                    self.columns.get_mut(idx).unwrap().rename(to);
+                },
+            }
+        }
+
+        self.cached_schema = OnceLock::from(Arc::new(schema));
+        Ok(self)
+    }
+
     /// Sort [`DataFrame`] in place.
     ///
     /// See [`DataFrame::sort`] for more instruction.

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-core/src/lib.rs

@@ -33,7 +33,6 @@ pub mod testing;
 mod tests;
 
 use std::cell::{Cell, RefCell};
-use std::panic::AssertUnwindSafe;
 use std::sync::{LazyLock, Mutex};
 use std::time::{SystemTime, UNIX_EPOCH};
 
@@ -53,7 +52,7 @@ pub struct POOL;
 // Thread locals to allow disabling threading for specific threads.
 #[cfg(any(target_os = "emscripten", not(target_family = "wasm")))]
 thread_local! {
-    static ALLOW_THREADS: Cell<bool> = const { Cell::new(true) };
+    pub static ALLOW_RAYON_THREADS: Cell<bool> = const { Cell::new(true) };
     static NOOP_POOL: RefCell<ThreadPool> = RefCell::new(
         ThreadPoolBuilder::new()
             .use_current_thread()
@@ -180,36 +179,12 @@ impl POOL {
         OP: FnOnce(&ThreadPool) -> R + Send,
         R: Send,
     {
-        if ALLOW_THREADS.get() || THREAD_POOL.current_thread_index().is_some() {
+        if ALLOW_RAYON_THREADS.get() || THREAD_POOL.current_thread_index().is_some() {
             op(&THREAD_POOL)
         } else {
             NOOP_POOL.with(|v| op(&v.borrow()))
         }
     }
-
-    pub fn without_threading<R>(&self, op: impl FnOnce() -> R) -> R {
-        #[cfg(not(any(target_os = "emscripten", not(target_family = "wasm"))))]
-        {
-            op()
-        }
-
-        #[cfg(any(target_os = "emscripten", not(target_family = "wasm")))]
-        {
-            // This can only be done from threads that are not in the main threadpool.
-            if THREAD_POOL.current_thread_index().is_some() {
-                op()
-            } else {
-                let prev = ALLOW_THREADS.replace(false);
-                // @Q? Should this catch_unwind?
-                let result = std::panic::catch_unwind(AssertUnwindSafe(op));
-                ALLOW_THREADS.set(prev);
-                match result {
-                    Ok(v) => v,
-                    Err(p) => std::panic::resume_unwind(p),
-                }
-            }
-        }
-    }
 }
 
 // this is re-exported in utils for polars child crates

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-expr/src/dispatch/groups_dispatch.rs

@@ -405,8 +405,9 @@ pub fn drop_nans<'a>(
         values.rechunk_mut();
         values.downcast_as_array().values().clone()
     } else {
-        Bitmap::new_with_value(true, 1)
+        Bitmap::new_with_value(false, 1)
     };
+    let predicate = !&predicate;
     drop_items(ac, &predicate)
 }
 

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-expr/src/expressions/apply.rs

@@ -170,7 +170,7 @@ impl ApplyExpr {
             let lst = agg.list().unwrap();
             let iter = lst.par_iter().map(f);
 
-            if self.output_field.dtype.is_known() && !self.output_field.dtype.is_null() {
+            if self.output_field.dtype.is_known() {
                 let dtype = self.output_field.dtype.clone();
                 let dtype = dtype.implode();
                 POOL.install(|| {

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-mem-engine/src/executors/cache.rs

@@ -22,24 +22,6 @@ impl CachePrefill {
         }
     }
 
-    pub fn new_scan(input: Box<dyn Executor>) -> Self {
-        Self {
-            input,
-            id: UniqueId::new(),
-            hit_count: 0,
-            is_new_streaming_scan: true,
-        }
-    }
-
-    pub fn new_sink(input: Box<dyn Executor>) -> Self {
-        Self {
-            input,
-            id: UniqueId::new(),
-            hit_count: 0,
-            is_new_streaming_scan: false,
-        }
-    }
-
     pub fn id(&self) -> UniqueId {
         self.id
     }

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-mem-engine/src/planner/lp.rs

@@ -396,16 +396,7 @@ fn create_physical_plan_impl(
                         input, builder, root, lp_arena, expr_arena,
                     ));
 
-                    // Use cache so that this runs during the cache pre-filling stage and not on the
-                    // thread pool, it could deadlock since the streaming engine uses the thread
-                    // pool internally.
-                    let mut prefill = executors::CachePrefill::new_sink(executor);
-                    let exec = prefill.make_exec();
-                    let existing = cache_nodes.insert(prefill.id(), prefill);
-
-                    assert!(existing.is_none());
-
-                    Ok(Box::new(exec))
+                    Ok(executor)
                 },
             }
         },
@@ -527,16 +518,7 @@ fn create_physical_plan_impl(
                     let build_func = build_streaming_executor
                         .expect("invalid build. Missing feature new-streaming");
 
-                    let executor = build_func(root, lp_arena, expr_arena)?;
-
-                    let mut prefill = executors::CachePrefill::new_scan(executor);
-                    let exec = prefill.make_exec();
-
-                    let existing = cache_nodes.insert(prefill.id(), prefill);
-
-                    assert!(existing.is_none());
-
-                    Ok(Box::new(exec))
+                    build_func(root, lp_arena, expr_arena)
                 },
                 #[allow(unreachable_patterns)]
                 _ => unreachable!(),
@@ -710,16 +692,7 @@ fn create_physical_plan_impl(
                     from_partitioned_ds,
                 ));
 
-                // Use cache so that this runs during the cache pre-filling stage and not on the
-                // thread pool, it could deadlock since the streaming engine uses the thread
-                // pool internally.
-                let mut prefill = executors::CachePrefill::new_sink(executor);
-                let exec = prefill.make_exec();
-                let existing = cache_nodes.insert(prefill.id(), prefill);
-
-                assert!(existing.is_none());
-
-                Ok(Box::new(exec))
+                Ok(executor)
             } else {
                 let input = recurse!(input, state)?;
                 Ok(Box::new(executors::GroupByExec::new(

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-ops/src/frame/join/general.rs

@@ -36,11 +36,12 @@ pub fn _finish_join(
 
     let suffix = get_suffix(suffix);
 
-    for name in rename_strs {
-        let new_name = _join_suffix_name(name.as_str(), suffix.as_str());
-        // Safety: IR resolving should guarantee this passes
-        df_right.rename(&name, new_name.clone()).unwrap();
-    }
+    df_right.rename_many(rename_strs.iter().map(|name| {
+        (
+            name.as_str(),
+            _join_suffix_name(name.as_str(), suffix.as_str()),
+        )
+    }))?;
 
     drop(left_names);
     // Safety: IR resolving should guarantee this passes

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-python/src/c_api/mod.rs

@@ -4,7 +4,7 @@ pub mod allocator;
 // Since Python Polars cannot share its version into here and we need to be able to build this
 // package correctly without `py-polars`, we need to mirror the version here.
 // example: 1.35.0-beta.1
-pub static PYPOLARS_VERSION: &str = "1.35.1";
+pub static PYPOLARS_VERSION: &str = "1.35.2";
 pub static RUNTIME_REPR: &str = "rt32";
 
 use pyo3::prelude::*;

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-stream/src/async_executor/mod.rs

@@ -17,6 +17,7 @@ use crossbeam_deque::{Injector, Steal, Stealer, Worker as WorkQueue};
 use crossbeam_utils::CachePadded;
 use park_group::ParkGroup;
 use parking_lot::Mutex;
+use polars_core::ALLOW_RAYON_THREADS;
 use polars_utils::relaxed_cell::RelaxedCell;
 use rand::rngs::SmallRng;
 use rand::{Rng, SeedableRng};
@@ -265,6 +266,7 @@ impl Executor {
 
     fn runner(&self, thread: usize) {
         TLS_THREAD_ID.set(thread);
+        ALLOW_RAYON_THREADS.set(false);
 
         let mut rng = SmallRng::from_rng(&mut rand::rng());
         let mut worker = self.park_group.new_worker();

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-stream/src/dispatch.rs

@@ -1,6 +1,5 @@
 use std::sync::{Arc, Mutex};
 
-use polars_core::POOL;
 use polars_core::error::PolarsResult;
 use polars_core::frame::DataFrame;
 use polars_expr::state::ExecutionState;
@@ -49,9 +48,6 @@ struct StreamingQueryExecutor {
 
 impl Executor for StreamingQueryExecutor {
     fn execute(&mut self, _cache: &mut ExecutionState) -> PolarsResult<DataFrame> {
-        // Must not block rayon thread on pending new-streaming future.
-        assert!(POOL.current_thread_index().is_none());
-
         let mut df = { self.executor.try_lock().unwrap().take() }
             .expect("unhandled: execute() more than once")
             .execute()

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/crates/polars-stream/src/expression.rs

@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use polars_core::POOL;
 use polars_core::frame::DataFrame;
 use polars_core::prelude::Column;
 use polars_error::PolarsResult;
@@ -28,11 +27,11 @@ impl StreamExpr {
             let phys_expr = self.inner.clone();
             let df = df.clone();
             polars_io::pl_async::get_runtime()
-                .spawn_blocking(move || POOL.without_threading(|| phys_expr.evaluate(&df, &state)))
+                .spawn_blocking(move || phys_expr.evaluate(&df, &state))
                 .await
                 .unwrap()
         } else {
-            POOL.without_threading(|| self.inner.evaluate(df, state))
+            self.inner.evaluate(df, state)
         }
     }
 
@@ -41,6 +40,6 @@ impl StreamExpr {
         df: &DataFrame,
         state: &ExecutionState,
     ) -> PolarsResult<Column> {
-        POOL.without_threading(|| self.inner.evaluate(df, state))
+        self.inner.evaluate(df, state)
     }
 }

{polars_runtime_32-1.35.1 → polars_runtime_32-1.35.2}/py-polars/runtime/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "py-polars"
-version = "1.35.1"
+version = "1.35.2"
 edition = "2021"
 
 [lib]