CoCalc -- test_all

GitHub Repository: pola-rs/polars
Path: blob/main/py-polars/tests/unit/series/test_all_any.py
⁸⁴⁴⁶ views
1
from __future__ import annotations
2

3
import operator
4
from typing import Any
5

6
import pytest
7

8
import polars as pl
9
from polars.exceptions import SchemaError
10

11

12
@pytest.mark.parametrize(
13
    ("data", "expected"),
14
    [
15
        ([], False),
16
        ([None], False),
17
        ([False], False),
18
        ([False, None], False),
19
        ([True], True),
20
        ([True, None], True),
21
        ([None] * 199 + [True], True),
22
        ([None] * 200, False),
23
        ([None] * 200 + [False] * 200, False),
24
    ],
25
)
26
def test_any(data: list[bool | None], expected: bool) -> None:
27
    assert pl.Series(data, dtype=pl.Boolean).any() is expected
28

29

30
@pytest.mark.parametrize(
31
    ("data", "expected"),
32
    [
33
        ([], False),
34
        ([None], None),
35
        ([False], False),
36
        ([False, None], None),
37
        ([True], True),
38
        ([True, None], True),
39
    ],
40
)
41
def test_any_kleene(data: list[bool | None], expected: bool | None) -> None:
42
    assert pl.Series(data, dtype=pl.Boolean).any(ignore_nulls=False) is expected
43

44

45
def test_any_wrong_dtype() -> None:
46
    with pytest.raises(SchemaError, match="expected `Boolean`"):
47
        pl.Series([0, 1, 0]).any()
48

49

50
@pytest.mark.parametrize(
51
    ("data", "expected"),
52
    [
53
        ([], True),
54
        ([None], True),
55
        ([False], False),
56
        ([False, None], False),
57
        ([True], True),
58
        ([True, None], True),
59
        ([None] * 200 + [True] * 199 + [False], False),
60
        ([True] * 200 + [None] * 200 + [True] * 200, True),
61
    ],
62
)
63
def test_all(data: list[bool | None], expected: bool) -> None:
64
    assert pl.Series(data, dtype=pl.Boolean).all() is expected
65

66

67
@pytest.mark.parametrize(
68
    ("data", "expected"),
69
    [
70
        ([], True),
71
        ([None], None),
72
        ([False], False),
73
        ([False, None], False),
74
        ([True], True),
75
        ([True, None], None),
76
    ],
77
)
78
def test_all_kleene(data: list[bool | None], expected: bool | None) -> None:
79
    assert pl.Series(data, dtype=pl.Boolean).all(ignore_nulls=False) is expected
80

81

82
def test_all_wrong_dtype() -> None:
83
    with pytest.raises(SchemaError, match="expected `Boolean`"):
84
        pl.Series([0, 1, 0]).all()
85

86

87
F = False
88
U = None
89
T = True
90

91

92
@pytest.mark.parametrize(
93
    ("op_impl", "truth_table"),
94
    [
95
        # https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics
96
        (
97
            operator.and_,
98
            {  #   [F, U, T]
99
                F: [F, F, F],
100
                U: [F, U, U],
101
                T: [F, U, T],
102
            },
103
        ),
104
        (
105
            operator.or_,
106
            {  #   [F, U, T]
107
                F: [F, U, T],
108
                U: [U, U, T],
109
                T: [T, T, T],
110
            },
111
        ),
112
        (
113
            operator.xor,
114
            {  #   [F, U, T]
115
                F: [F, U, T],
116
                U: [U, U, U],
117
                T: [T, U, F],
118
            },
119
        ),
120
    ],
121
)
122
@pytest.mark.parametrize("swap_args", [True, False])
123
def test_binary_bitwise_kleene_24809(
124
    op_impl: Any,
125
    swap_args: bool,
126
    truth_table: dict[bool, list[bool]],
127
) -> None:
128
    def op(lhs: Any, rhs: Any) -> Any:
129
        return op_impl(rhs, lhs) if swap_args else op_impl(lhs, rhs)
130

131
    rhs = pl.Series([F, U, T], dtype=pl.Boolean)
132

133
    class _:
134
        def f(scalar: bool | None) -> Any:  # type: ignore[misc]
135
            lhs = pl.lit(scalar, dtype=pl.Boolean)
136
            return pl.select(op(lhs, rhs)).to_series().to_list()
137

138
        assert {
139
            F: f(F),
140
            U: f(U),
141
            T: f(T),
142
        } == truth_table
143

144
    class _:  # type: ignore[no-redef]
145
        def f(scalar: bool | None) -> Any:  # type: ignore[misc]
146
            lhs = pl.Series([scalar], dtype=pl.Boolean)
147
            return pl.select(op(lhs, rhs)).to_series().to_list()
148

149
        assert {
150
            F: f(F),
151
            U: f(U),
152
            T: f(T),
153
        } == truth_table
154

155
    class _:  # type: ignore[no-redef]
156
        def f(scalar: bool | None) -> Any:  # type: ignore[misc]
157
            lhs = pl.Series([scalar, scalar, scalar], dtype=pl.Boolean)
158
            return op(lhs, rhs).to_list()
159

160
        assert {
161
            F: f(F),
162
            U: f(U),
163
            T: f(T),
164
        } == truth_table
165

166
    class _:  # type: ignore[no-redef]
167
        def f(scalar: bool | None) -> Any:  # type: ignore[misc]
168
            lhs = pl.lit(pl.Series([scalar]))
169
            return pl.select(op(lhs, rhs)).to_series().to_list()
170

171
        assert {
172
            F: f(F),
173
            U: f(U),
174
            T: f(T),
175
        } == truth_table
176

177
    class _:  # type: ignore[no-redef]
178
        def f(scalar: bool | None) -> Any:  # type: ignore[misc]
179
            lhs = pl.lit(pl.Series([scalar, scalar, scalar]))
180
            return pl.select(op(lhs, rhs)).to_series().to_list()
181

182
        assert {
183
            F: f(F),
184
            U: f(U),
185
            T: f(T),
186
        } == truth_table
187

188
Product

Resources

Company
