polars-core 0.54.4

Core of the Polars DataFrame library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use arrow::array::*;

use crate::prelude::*;

pub mod par;

impl<T> ChunkedArray<T>
where
    T: PolarsDataType,
{
    #[inline]
    pub fn iter(&self) -> impl PolarsIterator<Item = Option<T::Physical<'_>>> {
        // SAFETY: we set the correct length of the iterator.
        unsafe {
            self.downcast_iter()
                .flat_map(|arr| arr.iter())
                .trust_my_length(self.len())
        }
    }

    #[inline]
    pub fn no_null_iter(&self) -> impl PolarsIterator<Item = T::Physical<'_>> {
        // SAFETY: we set the correct length of the iterator.
        unsafe {
            self.downcast_iter()
                .flat_map(|arr| arr.values_iter())
                .trust_my_length(self.len())
        }
    }
}

/// A [`PolarsIterator`] is an iterator over a [`ChunkedArray`] which contains polars types. A [`PolarsIterator`]
/// must implement [`ExactSizeIterator`] and [`DoubleEndedIterator`].
pub trait PolarsIterator:
    ExactSizeIterator + DoubleEndedIterator + Send + Sync + TrustedLen
{
}

/// Implement [`PolarsIterator`] for every iterator that implements the needed traits.
impl<T: ?Sized> PolarsIterator for T where
    T: ExactSizeIterator + DoubleEndedIterator + Send + Sync + TrustedLen
{
}

impl ListChunked {
    pub fn series_iter(&self) -> impl PolarsIterator<Item = Option<Series>> {
        let dtype = self.inner_dtype();
        unsafe {
            self.downcast_iter()
                .flat_map(|arr| arr.iter())
                .trust_my_length(self.len())
                .map(move |arr| {
                    arr.map(|arr| {
                        Series::from_chunks_and_dtype_unchecked(PlSmallStr::EMPTY, vec![arr], dtype)
                    })
                })
        }
    }

    pub fn no_null_series_iter(&self) -> impl PolarsIterator<Item = Series> {
        let inner_type = self.inner_dtype();
        unsafe {
            self.downcast_iter()
                .flat_map(|arr| arr.values_iter())
                .map(move |arr| {
                    Series::from_chunks_and_dtype_unchecked(
                        PlSmallStr::EMPTY,
                        vec![arr],
                        inner_type,
                    )
                })
                .trust_my_length(self.len())
        }
    }
}

#[cfg(feature = "dtype-array")]
impl ArrayChunked {
    pub fn series_iter(&self) -> impl PolarsIterator<Item = Option<Series>> {
        let dtype = self.inner_dtype();
        unsafe {
            self.downcast_iter()
                .flat_map(|arr| arr.iter())
                .trust_my_length(self.len())
                .map(move |arr| {
                    arr.map(|arr| {
                        Series::from_chunks_and_dtype_unchecked(PlSmallStr::EMPTY, vec![arr], dtype)
                    })
                })
        }
    }
}