polars-runtime-32 1.36.0b1__tar.gz → 1.36.0b2__tar.gz

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/Cargo.lock

@@ -3610,7 +3610,7 @@ dependencies = [
 
 [[package]]
 name = "polars-runtime-32"
-version = "1.36.0-beta.1"
+version = "1.36.0-beta.2"
 dependencies = [
  "either",
  "libc",
@@ -3621,7 +3621,7 @@ dependencies = [
 
 [[package]]
 name = "polars-runtime-64"
-version = "1.36.0-beta.1"
+version = "1.36.0-beta.2"
 dependencies = [
  "either",
  "libc",
@@ -3632,7 +3632,7 @@ dependencies = [
 
 [[package]]
 name = "polars-runtime-compat"
-version = "1.36.0-beta.1"
+version = "1.36.0-beta.2"
 dependencies = [
  "either",
  "libc",

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/PKG-INFO

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

polars_runtime_32-1.36.0b2/crates/polars/tests/it/time/date.rs

@@ -0,0 +1,94 @@
+use polars::prelude::*;
+
+#[test]
+fn test_datetime_parse_overflow_7631() {
+    let df = df![
+        "year"=> &[2020, 2021, 2022],
+        "month"=> &[1, 2, 3],
+        "day"=> &[1, 2, 3],
+    ]
+    .unwrap()
+    .lazy();
+
+    let df = df.with_column(
+        concat_str([col("year"), col("month"), col("day")], "-", false) // produces e.g., `2020-1-1`
+            .str()
+            .strptime(
+                DataType::Datetime(TimeUnit::Milliseconds, None),
+                StrptimeOptions {
+                    format: Some("%Y-%m-%_d".into()),
+                    ..Default::default()
+                },
+                lit("latest"),
+            )
+            .alias("dt1"),
+    );
+    let actual = df.collect().unwrap();
+
+    let expected = DataFrame::new(vec![
+        Column::new("year".into(), &[2020, 2021, 2022]),
+        Column::new("month".into(), &[1, 2, 3]),
+        Column::new("day".into(), &[1, 2, 3]),
+        Column::new(
+            "dt1".into(),
+            &[
+                AnyValue::Datetime(1577836800000, TimeUnit::Milliseconds, None),
+                AnyValue::Datetime(1612224000000, TimeUnit::Milliseconds, None),
+                AnyValue::Datetime(1646265600000, TimeUnit::Milliseconds, None),
+            ],
+        ),
+    ])
+    .unwrap();
+
+    assert_eq!(actual, expected);
+}
+
+#[test]
+#[cfg(feature = "dtype-date")]
+fn test_date_temporal_operations_11991() {
+    use polars::prelude::*;
+
+    let normal_date = 18628; // 2021-01-01
+    let s = Int32Chunked::new("".into(), &[normal_date])
+        .into_date()
+        .into_series();
+
+    let year = s.year().unwrap();
+    assert_eq!(year.get(0), Some(2021));
+
+    let month = s.month().unwrap();
+    assert_eq!(month.get(0), Some(1));
+
+    let day = s.day().unwrap();
+    assert_eq!(day.get(0), Some(1));
+
+    // Null values should remain null (regression test for #15313)
+    let s_with_null = Int32Chunked::new("".into(), &[Some(18628), None])
+        .into_date()
+        .into_series();
+
+    let year_with_null = s_with_null.year().unwrap();
+    assert_eq!(year_with_null.get(0), Some(2021));
+    assert_eq!(year_with_null.get(1), None);
+}
+
+#[test]
+#[cfg(feature = "dtype-date")]
+fn test_out_of_range_date_year_11991() {
+    use polars::prelude::*;
+
+    // Out-of-range dates should return null instead of panicking or returning wrong values
+    // Regression test for #11991 where out-of-range dates silently returned the input value
+    let out_of_range_date = -96_465_659;
+    let s = Int32Chunked::new("".into(), &[out_of_range_date])
+        .into_date()
+        .into_series();
+
+    let year = s.year().unwrap();
+    // Should return null, not the input value -96465659
+    assert_eq!(year.get(0), None);
+
+    // is_leap_year should also return null for out-of-range dates
+    let is_leap = s.is_leap_year().unwrap();
+    assert_eq!(is_leap.get(0), None);
+}

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/crates/polars-expr/src/expressions/eval.rs

@@ -105,6 +105,8 @@ impl EvalExpr {
         }
 
         let offsets = ca.offsets()?;
+        // Detect accidental inclusion of sliced-out elements from chunks after the 1st (if present).
+        assert_eq!(i64::try_from(flattened_len).unwrap(), *offsets.last());
 
         // Create groups for all valid array elements.
         let groups = if ca.has_nulls() {
@@ -248,6 +250,8 @@ impl EvalExpr {
             });
         }
 
+        assert_eq!(flattened_len, ca.width() * ca.len());
+
         // Create groups for all valid array elements.
         let groups = if ca.has_nulls() {
             let validity = validity.as_ref().unwrap();

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/crates/polars-ops/src/frame/join/asof/mod.rs

@@ -112,18 +112,22 @@ impl<T: PartialOrd> AsofJoinState<T> for AsofJoinBackwardState {
 
 #[derive(Default)]
 struct AsofJoinNearestState {
-    // best_bound is the nearest value to left_val, with ties broken towards the last element.
-    best_bound: Option<IdxSize>,
-    scan_offset: IdxSize,
+    /// The last value that is strictly smaller than the current
+    /// left value.
+    strictly_smaller: Option<IdxSize>,
+    /// If `allow_eq == false`: the first value strictly greater than the
+    /// current left value.
+    /// If `allow_eq == true`: the last value of the first chunk of equal
+    /// values that are strictly greater than the current left value.
+    upper_candidate: IdxSize,
     allow_eq: bool,
 }
 
 impl<T: NumericNative> AsofJoinState<T> for AsofJoinNearestState {
     fn new(allow_eq: bool) -> Self {
         AsofJoinNearestState {
-            scan_offset: Default::default(),
-            best_bound: Default::default(),
             allow_eq,
+            ..Default::default()
         }
     }
     #[inline]
@@ -135,50 +139,62 @@ impl<T: NumericNative> AsofJoinState<T> for AsofJoinNearestState {
     ) -> Option<IdxSize> {
         // Skipping ahead to the first value greater than left_val. This is
         // cheaper than computing differences.
-        while self.scan_offset < n_right {
-            if let Some(scan_right_val) = right(self.scan_offset) {
-                if lt_allow_eq(&scan_right_val, left_val, self.allow_eq) {
-                    self.best_bound = Some(self.scan_offset);
-                } else {
-                    // Now we must compute a difference to see if scan_right_val
-                    // is closer than our current best bound.
-                    let scan_is_better = if let Some(best_idx) = self.best_bound {
-                        let best_right_val = unsafe { right(best_idx).unwrap_unchecked() };
-                        let best_diff = left_val.abs_diff(best_right_val);
-                        let scan_diff = left_val.abs_diff(scan_right_val);
-
-                        lt_allow_eq(&scan_diff, &best_diff, self.allow_eq)
-                    } else {
-                        true
-                    };
-
-                    if scan_is_better {
-                        self.best_bound = Some(self.scan_offset);
-                        self.scan_offset += 1;
+        while self.upper_candidate < n_right {
+            let Some(scan_right_val) = right(self.upper_candidate) else {
+                self.upper_candidate += 1;
+                continue;
+            };
+            if scan_right_val > *left_val {
+                break;
+            }
+            self.upper_candidate += 1;
+        }
 
-                        // It is possible there are later elements equal to our
-                        // scan, so keep going on.
-                        while self.scan_offset < n_right {
-                            if let Some(next_right_val) = right(self.scan_offset) {
-                                if next_right_val == scan_right_val && self.allow_eq {
-                                    self.best_bound = Some(self.scan_offset);
-                                } else {
-                                    break;
-                                }
-                            }
+        if self.allow_eq
+            && self.upper_candidate > 0
+            && right(self.upper_candidate - 1) == Some(*left_val)
+        {
+            return Some(self.upper_candidate - 1);
+        }
 
-                            self.scan_offset += 1;
-                        }
-                    }
+        // It is possible there are later elements equal to our
+        // scan, so keep going on.
+        while self.upper_candidate + 1 < n_right
+            && right(self.upper_candidate + 1) == right(self.upper_candidate)
+        {
+            self.upper_candidate += 1;
+        }
 
-                    break;
-                }
+        let mut cursor = self.strictly_smaller.unwrap_or(0);
+        while cursor < self.upper_candidate {
+            let Some(scan_right_val) = right(cursor) else {
+                cursor += 1;
+                continue;
+            };
+            if scan_right_val >= *left_val {
+                break;
             }
-
-            self.scan_offset += 1;
+            self.strictly_smaller = Some(cursor);
+            cursor += 1;
         }
 
-        self.best_bound
+        let mut right_get = |idx: IdxSize| (idx < n_right).then(|| right(idx)).flatten();
+        let lower = self.strictly_smaller.and_then(&mut right_get);
+        let upper = right_get(self.upper_candidate);
+        match (lower, upper) {
+            (None, None) => None,
+            (Some(_), None) => self.strictly_smaller,
+            (None, Some(_)) => Some(self.upper_candidate),
+            (Some(lo), Some(hi)) => {
+                let lo_diff = left_val.abs_diff(lo);
+                let hi_diff = left_val.abs_diff(hi);
+                if hi_diff <= lo_diff {
+                    Some(self.upper_candidate)
+                } else {
+                    self.strictly_smaller
+                }
+            },
+        }
     }
 }
 

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/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.36.0-beta.1";
+pub static PYPOLARS_VERSION: &str = "1.36.0-beta.2";
 
 // We allow multiple features to be set simultaneously so checking with all-features
 // is possible. In the case multiple are set or none at all, we set the repr to "unknown".

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/crates/polars-stream/src/lib.rs

@@ -11,13 +11,14 @@ mod execute;
 pub use dispatch::build_streaming_query_executor;
 pub(crate) mod expression;
 mod graph;
-pub use graph::{LogicalPipe, LogicalPipeKey};
+pub use graph::{GraphNodeKey, LogicalPipe, LogicalPipeKey};
 pub use skeleton::{QueryResult, StreamingQuery};
 mod metrics;
 pub use metrics::{GraphMetrics, NodeMetrics};
 mod morsel;
 mod nodes;
 mod physical_plan;
+pub use physical_plan::PhysNodeKey;
 #[cfg(feature = "physical_plan_visualization")]
 pub use physical_plan::visualization as physical_plan_visualization;
 mod pipe;

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/crates/polars-stream/src/nodes/io_sources/multi_scan/components/projection/builder.rs

@@ -264,7 +264,6 @@ impl ProjectionBuilder {
         self.projected_schema().len()
     }
 
-    #[cfg_attr(not(feature = "physical_plan_visualization"), expect(unused))]
     pub fn projected_names(&self) -> impl Iterator<Item = &PlSmallStr> {
         self.projected_schema().iter_names()
     }

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/crates/polars-stream/src/skeleton.rs

@@ -58,9 +58,9 @@ pub fn visualize_physical_plan(
 pub struct StreamingQuery {
     top_ir: IR,
     pub graph: Graph,
-    root_phys_node: PhysNodeKey,
-    phys_sm: SlotMap<PhysNodeKey, PhysNode>,
-    phys_to_graph: SecondaryMap<PhysNodeKey, GraphNodeKey>,
+    pub root_phys_node: PhysNodeKey,
+    pub phys_sm: SlotMap<PhysNodeKey, PhysNode>,
+    pub phys_to_graph: SecondaryMap<PhysNodeKey, GraphNodeKey>,
     pub metrics: Option<Arc<Mutex<GraphMetrics>>>,
 }
 

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/crates/polars-time/src/chunkedarray/kernels.rs

@@ -1,7 +1,6 @@
 //! macros that define kernels for extracting
 //! `week`, `weekday`, `year`, `hour` etc. from primitive arrays.
 use arrow::array::{BooleanArray, PrimitiveArray};
-use arrow::compute::arity::unary;
 #[cfg(feature = "dtype-time")]
 use arrow::temporal_conversions::time64ns_to_time_opt;
 use arrow::temporal_conversions::{
@@ -42,14 +41,12 @@ macro_rules! to_temporal_unit {
     $primitive_out: ty,
     $dtype_out:expr) => {
         pub(crate) fn $name(arr: &PrimitiveArray<$primitive_in>) -> ArrayRef {
-            Box::new(unary(
-                arr,
-                |value| {
-                    $to_datetime_fn(value)
-                        .map(|dt| dt.$chrono_method() as $primitive_out)
-                        .unwrap_or(value as $primitive_out)
-                },
-                $dtype_out,
+            Box::new(PrimitiveArray::<$primitive_out>::from_trusted_len_iter(
+                arr.iter().map(|opt_value| {
+                    opt_value.and_then(|&value| {
+                        $to_datetime_fn(value).map(|dt| dt.$chrono_method() as $primitive_out)
+                    })
+                }),
             )) as ArrayRef
         }
     };
@@ -58,20 +55,13 @@ macro_rules! to_temporal_unit {
 macro_rules! to_boolean_temporal_unit {
     ($name: ident, $chrono_method: ident, $boolean_method: ident, $to_datetime_fn: expr, $dtype_in: ty) => {
         pub(crate) fn $name(arr: &PrimitiveArray<$dtype_in>) -> ArrayRef {
-            let values = arr
-                .values()
-                .iter()
-                .map(|value| {
-                    $to_datetime_fn(*value)
-                        .map(|dt| $boolean_method(dt.$chrono_method()))
-                        .unwrap_or(false)
-                })
-                .collect::<Vec<_>>();
-            Box::new(BooleanArray::new(
-                ArrowDataType::Boolean,
-                values.into(),
-                arr.validity().cloned(),
-            ))
+            Box::new(BooleanArray::from_trusted_len_iter(arr.iter().map(
+                |opt_value| {
+                    opt_value.and_then(|&value| {
+                        $to_datetime_fn(value).map(|dt| $boolean_method(dt.$chrono_method()))
+                    })
+                },
+            )))
         }
     };
 }
@@ -82,14 +72,12 @@ macro_rules! to_calendar_value {
     $primitive_out: ty,
     $dtype_out:expr) => {
         pub(crate) fn $name(arr: &PrimitiveArray<$primitive_in>) -> ArrayRef {
-            Box::new(unary(
-                arr,
-                |value| {
-                    $to_datetime_fn(value)
-                        .map(|$dt| $expr as $primitive_out)
-                        .unwrap_or(value as $primitive_out)
-                },
-                $dtype_out,
+            Box::new(PrimitiveArray::<$primitive_out>::from_trusted_len_iter(
+                arr.iter().map(|opt_value| {
+                    opt_value.and_then(|&value| {
+                        $to_datetime_fn(value).map(|$dt| $expr as $primitive_out)
+                    })
+                }),
             )) as ArrayRef
         }
     };

{polars_runtime_32-1.36.0b1 → polars_runtime_32-1.36.0b2}/py-polars/runtime/polars-runtime-32/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "polars-runtime-32"
 # example: 1.35.0-beta.1
-version = "1.36.0-beta.1"
+version = "1.36.0-beta.2"
 edition = "2021"
 
 [lib]

polars_runtime_32-1.36.0b1/crates/polars/tests/it/time/date.rs

@@ -1,44 +0,0 @@
-use polars::prelude::*;
-
-#[test]
-fn test_datetime_parse_overflow_7631() {
-    let df = df![
-        "year"=> &[2020, 2021, 2022],
-        "month"=> &[1, 2, 3],
-        "day"=> &[1, 2, 3],
-    ]
-    .unwrap()
-    .lazy();
-
-    let df = df.with_column(
-        concat_str([col("year"), col("month"), col("day")], "-", false) // produces e.g., `2020-1-1`
-            .str()
-            .strptime(
-                DataType::Datetime(TimeUnit::Milliseconds, None),
-                StrptimeOptions {
-                    format: Some("%Y-%m-%_d".into()),
-                    ..Default::default()
-                },
-                lit("latest"),
-            )
-            .alias("dt1"),
-    );
-    let actual = df.collect().unwrap();
-
-    let expected = DataFrame::new(vec![
-        Column::new("year".into(), &[2020, 2021, 2022]),
-        Column::new("month".into(), &[1, 2, 3]),
-        Column::new("day".into(), &[1, 2, 3]),
-        Column::new(
-            "dt1".into(),
-            &[
-                AnyValue::Datetime(1577836800000, TimeUnit::Milliseconds, None),
-                AnyValue::Datetime(1612224000000, TimeUnit::Milliseconds, None),
-                AnyValue::Datetime(1646265600000, TimeUnit::Milliseconds, None),
-            ],
-        ),
-    ])
-    .unwrap();
-
-    assert_eq!(actual, expected);
-}