Skip to content

Checks

CheckBuilder

A helper object to create a constraint.

Source code in tsumugi-python/tsumugi/checks.py 
 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
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
class CheckBuilder:
    """A helper object to create a constraint."""

    def __init__(self) -> None:
        self._level: CheckLevel = CheckLevel.Warning
        self._constraints: list[suite.Check.Constraint] = list()
        self._description: str = ""

    def with_level(self, level: CheckLevel) -> Self:
        """Set a level of the Check."""
        self._level = level
        return self

    def with_description(self, decription: str) -> Self:
        """Set a description of the Check."""
        self._description = decription
        return self

    def with_constraint(self, constraint: suite.Check.Constraint) -> Self:
        """Add a constraint to the Check.

        It is recommended to use ConstraintBuilder!
        """
        self._constraints.append(constraint)
        return self

    def with_constraints(self, constraints_list: list[suite.Check.Constraint]) -> Self:
        """Set constraints. Override existing!"""
        self._constraints = constraints_list
        return self

    def has_size(
        self, expected_size: int, hint: str = "", name: str | None = None
    ) -> Self:
        """Add a constraint that the DataFrame has size like expected."""
        return self.with_constraint(
            ConstraintBuilder()
            .for_analyzer(Size())
            .with_hint(hint)
            .with_name(name or "Size")
            .should_be_eq_to(expected_size)
            .build()
        )

    def is_complete(
        self,
        column: str,
        hint: str = "",
        name: str | None = None,
        where: str | None = None,
        options: AnalyzerOptions | None = None,
    ) -> Self:
        """Add a constraint that the column doesn not have missings."""
        return self.has_completeness(column, 1.0, hint, name, where, options)

    def has_completeness(
        self,
        column: str,
        expected_value: float,
        hint: str = "",
        name: str | None = None,
        where: str | None = None,
        options: AnalyzerOptions | None = None,
    ) -> Self:
        """Add a constraint the the column has an expected part of missings."""
        return self.with_constraint(
            ConstraintBuilder()
            .for_analyzer(
                Completeness(
                    column=column,
                    where=where,
                    options=options or AnalyzerOptions.default(),
                )
            )
            .with_hint(hint)
            .with_name(name or f"Completeness({column})")
            .should_be_eq_to(expected_value)
            .build()
        )

    def are_complete(
        self,
        columns: list[str],
        hint: str = "",
        name: str | None = None,
        where: str | None = None,
        options: AnalyzerOptions | None = None,
    ) -> Self:
        """Add a constraint that columns have an expected part of missings."""
        return self.have_completeness(columns, 1.0, hint, name, where, options)

    def have_completeness(
        self,
        columns: list[str],
        expected_value: float,
        hint: str = "",
        name: str | None = None,
        where: str | None = None,
        options: AnalyzerOptions | None = None,
    ) -> Self:
        """Add a constraint that columns have an expected level of completeness."""
        list_of_constraints = [
            ConstraintBuilder()
            .for_analyzer(
                Completeness(
                    column=col,
                    where=where,
                    options=options or AnalyzerOptions.default(),
                )
            )
            .with_name(name or f"Completeness({col})")
            .with_hint(hint)
            .should_be_eq_to(expected_value)
            .build()
            for col in columns
        ]
        for constraint in list_of_constraints:
            self = self.with_constraint(constraint=constraint)

        return self

    def is_unique(
        self,
        column: str,
        hint: str = "",
        name: str | None = None,
        where: str | None = None,
        options: AnalyzerOptions | None = None,
    ) -> Self:
        """Create a constraint that the column is unique."""
        return self.has_uniqueness([column], 1.0, hint, name, where, options)

    def is_primary_key(
        self,
        column: str,
        hint: str = "",
        name: str | None = None,
        where: str | None = None,
        options: AnalyzerOptions | None = None,
    ) -> Self:
        """Create a contraint that the column is like a primary key."""
        return self.is_unique(column, hint, name, where, options).is_complete(
            column, hint, name, where, options
        )

    def has_uniqueness(
        self,
        columns: list[str],
        expected_value: float,
        hint: str = "",
        name: str | None = None,
        where: str | None = None,
        options: AnalyzerOptions | None = None,
    ) -> Self:
        """Create a constraint that the given set of columns have an expected level of uniqueness."""
        return self.with_constraint(
            ConstraintBuilder()
            .for_analyzer(
                Uniqueness(
                    columns=columns,
                    where=where,
                    options=options or AnalyzerOptions.default(),
                )
            )
            .with_name(name or f"Uniquesness{','.join(columns)}")
            .with_hint(hint)
            .should_be_eq_to(expected_value)
            .build()
        )

    def _validate(self) -> None:
        if len(self._constraints) == 0:
            raise ValueError("At least one constraint is required")

    def build(self) -> suite.Check:
        """Build a Check to the protobuf message."""
        return suite.Check(
            checkLevel=self._level,
            description=self._description,
            constraints=self._constraints,
        )

are_complete(columns, hint='', name=None, where=None, options=None)

Add a constraint that columns have an expected part of missings.

Source code in tsumugi-python/tsumugi/checks.py 
 95
 96
 97
 98
 99
100
101
102
103
104
def are_complete(
    self,
    columns: list[str],
    hint: str = "",
    name: str | None = None,
    where: str | None = None,
    options: AnalyzerOptions | None = None,
) -> Self:
    """Add a constraint that columns have an expected part of missings."""
    return self.have_completeness(columns, 1.0, hint, name, where, options)

build()

Build a Check to the protobuf message.

Source code in tsumugi-python/tsumugi/checks.py 
189
190
191
192
193
194
195
def build(self) -> suite.Check:
    """Build a Check to the protobuf message."""
    return suite.Check(
        checkLevel=self._level,
        description=self._description,
        constraints=self._constraints,
    )

has_completeness(column, expected_value, hint='', name=None, where=None, options=None)

Add a constraint the the column has an expected part of missings.

Source code in tsumugi-python/tsumugi/checks.py 
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
def has_completeness(
    self,
    column: str,
    expected_value: float,
    hint: str = "",
    name: str | None = None,
    where: str | None = None,
    options: AnalyzerOptions | None = None,
) -> Self:
    """Add a constraint the the column has an expected part of missings."""
    return self.with_constraint(
        ConstraintBuilder()
        .for_analyzer(
            Completeness(
                column=column,
                where=where,
                options=options or AnalyzerOptions.default(),
            )
        )
        .with_hint(hint)
        .with_name(name or f"Completeness({column})")
        .should_be_eq_to(expected_value)
        .build()
    )

has_size(expected_size, hint='', name=None)

Add a constraint that the DataFrame has size like expected.

Source code in tsumugi-python/tsumugi/checks.py 
46
47
48
49
50
51
52
53
54
55
56
57
def has_size(
    self, expected_size: int, hint: str = "", name: str | None = None
) -> Self:
    """Add a constraint that the DataFrame has size like expected."""
    return self.with_constraint(
        ConstraintBuilder()
        .for_analyzer(Size())
        .with_hint(hint)
        .with_name(name or "Size")
        .should_be_eq_to(expected_size)
        .build()
    )

has_uniqueness(columns, expected_value, hint='', name=None, where=None, options=None)

Create a constraint that the given set of columns have an expected level of uniqueness.

Source code in tsumugi-python/tsumugi/checks.py 
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
def has_uniqueness(
    self,
    columns: list[str],
    expected_value: float,
    hint: str = "",
    name: str | None = None,
    where: str | None = None,
    options: AnalyzerOptions | None = None,
) -> Self:
    """Create a constraint that the given set of columns have an expected level of uniqueness."""
    return self.with_constraint(
        ConstraintBuilder()
        .for_analyzer(
            Uniqueness(
                columns=columns,
                where=where,
                options=options or AnalyzerOptions.default(),
            )
        )
        .with_name(name or f"Uniquesness{','.join(columns)}")
        .with_hint(hint)
        .should_be_eq_to(expected_value)
        .build()
    )

have_completeness(columns, expected_value, hint='', name=None, where=None, options=None)

Add a constraint that columns have an expected level of completeness.

Source code in tsumugi-python/tsumugi/checks.py 
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
def have_completeness(
    self,
    columns: list[str],
    expected_value: float,
    hint: str = "",
    name: str | None = None,
    where: str | None = None,
    options: AnalyzerOptions | None = None,
) -> Self:
    """Add a constraint that columns have an expected level of completeness."""
    list_of_constraints = [
        ConstraintBuilder()
        .for_analyzer(
            Completeness(
                column=col,
                where=where,
                options=options or AnalyzerOptions.default(),
            )
        )
        .with_name(name or f"Completeness({col})")
        .with_hint(hint)
        .should_be_eq_to(expected_value)
        .build()
        for col in columns
    ]
    for constraint in list_of_constraints:
        self = self.with_constraint(constraint=constraint)

    return self

is_complete(column, hint='', name=None, where=None, options=None)

Add a constraint that the column doesn not have missings.

Source code in tsumugi-python/tsumugi/checks.py 
59
60
61
62
63
64
65
66
67
68
def is_complete(
    self,
    column: str,
    hint: str = "",
    name: str | None = None,
    where: str | None = None,
    options: AnalyzerOptions | None = None,
) -> Self:
    """Add a constraint that the column doesn not have missings."""
    return self.has_completeness(column, 1.0, hint, name, where, options)

is_primary_key(column, hint='', name=None, where=None, options=None)

Create a contraint that the column is like a primary key.

Source code in tsumugi-python/tsumugi/checks.py 
147
148
149
150
151
152
153
154
155
156
157
158
def is_primary_key(
    self,
    column: str,
    hint: str = "",
    name: str | None = None,
    where: str | None = None,
    options: AnalyzerOptions | None = None,
) -> Self:
    """Create a contraint that the column is like a primary key."""
    return self.is_unique(column, hint, name, where, options).is_complete(
        column, hint, name, where, options
    )

is_unique(column, hint='', name=None, where=None, options=None)

Create a constraint that the column is unique.

Source code in tsumugi-python/tsumugi/checks.py 
136
137
138
139
140
141
142
143
144
145
def is_unique(
    self,
    column: str,
    hint: str = "",
    name: str | None = None,
    where: str | None = None,
    options: AnalyzerOptions | None = None,
) -> Self:
    """Create a constraint that the column is unique."""
    return self.has_uniqueness([column], 1.0, hint, name, where, options)

with_constraint(constraint)

Add a constraint to the Check.

It is recommended to use ConstraintBuilder!

Source code in tsumugi-python/tsumugi/checks.py 
33
34
35
36
37
38
39
def with_constraint(self, constraint: suite.Check.Constraint) -> Self:
    """Add a constraint to the Check.

    It is recommended to use ConstraintBuilder!
    """
    self._constraints.append(constraint)
    return self

with_constraints(constraints_list)

Set constraints. Override existing!

Source code in tsumugi-python/tsumugi/checks.py 
41
42
43
44
def with_constraints(self, constraints_list: list[suite.Check.Constraint]) -> Self:
    """Set constraints. Override existing!"""
    self._constraints = constraints_list
    return self

with_description(decription)

Set a description of the Check.

Source code in tsumugi-python/tsumugi/checks.py 
28
29
30
31
def with_description(self, decription: str) -> Self:
    """Set a description of the Check."""
    self._description = decription
    return self

with_level(level)

Set a level of the Check.

Source code in tsumugi-python/tsumugi/checks.py 
23
24
25
26
def with_level(self, level: CheckLevel) -> Self:
    """Set a level of the Check."""
    self._level = level
    return self