Skip to content

sgn.validator

Validators for simplifying element validation.

many_to_one(arg) 

many_to_one(arg: TMethod) -> TMethod

many_to_one(arg: T) -> None

Validator for many-to-one transforms.

Can be used as a decorator or called directly::

# As a decorator
class MyTransform(TransformElement):
    @validator.many_to_one
    def validate(self) -> None:
        pass

# Called directly
class MyTransform(TransformElement):
    def __post_init__(self):
        super().__post_init__()
        validator.many_to_one(self)
Source code in src/sgn/validator.py 
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
def many_to_one(arg: TMethod | T) -> TMethod | None:
    """Validator for many-to-one transforms.

    Can be used as a decorator or called directly::

        # As a decorator
        class MyTransform(TransformElement):
            @validator.many_to_one
            def validate(self) -> None:
                pass

        # Called directly
        class MyTransform(TransformElement):
            def __post_init__(self):
                super().__post_init__()
                validator.many_to_one(self)
    """

    def validate(self: T) -> None:
        assert len(self.source_pads) == 1, (
            f"{self.name} requires exactly one source pad, "
            f"got {len(self.source_pads)}"
        )

    return _make_validator(validate)(arg)

num_pads(sink_pads=None, source_pads=None)

Validator for specific number of sink and source pads.

Can be used as a decorator or called directly::

# As a decorator
class MyTransform(TransformElement):
    @validator.num_pads(sink_pads=2, source_pads=1)
    def validate(self) -> None:
        # Additional custom validation
        pass

# Called directly
class MyTransform(TransformElement):
    def __post_init__(self):
        super().__post_init__()
        validator.num_pads(sink_pads=2, source_pads=1)(self)
Source code in src/sgn/validator.py 
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
def num_pads(
    sink_pads: int | None = None, source_pads: int | None = None
) -> Callable[[TMethod], TMethod]:
    """Validator for specific number of sink and source pads.

    Can be used as a decorator or called directly::

        # As a decorator
        class MyTransform(TransformElement):
            @validator.num_pads(sink_pads=2, source_pads=1)
            def validate(self) -> None:
                # Additional custom validation
                pass

        # Called directly
        class MyTransform(TransformElement):
            def __post_init__(self):
                super().__post_init__()
                validator.num_pads(sink_pads=2, source_pads=1)(self)
    """

    def validate(self: T) -> None:
        if sink_pads is not None:
            assert len(self.sink_pads) == sink_pads, (
                f"{self.name} requires exactly {sink_pads} sink pad(s), "
                f"got {len(self.sink_pads)}"
            )
        if source_pads is not None:
            assert len(self.source_pads) == source_pads, (
                f"{self.name} requires exactly {source_pads} source pad(s), "
                f"got {len(self.source_pads)}"
            )

    return _make_validator(validate)  # type: ignore[return-value]

one_to_many(arg)

Validator for one-to-many transforms.

Can be used as a decorator or called directly::

# As a decorator
class MyTransform(TransformElement):
    @validator.one_to_many
    def validate(self) -> None:
        pass

# Called directly
class MyTransform(TransformElement):
    def __post_init__(self):
        super().__post_init__()
        validator.one_to_many(self)
Source code in src/sgn/validator.py 
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
def one_to_many(arg: TMethod | T) -> TMethod | None:
    """Validator for one-to-many transforms.

    Can be used as a decorator or called directly::

        # As a decorator
        class MyTransform(TransformElement):
            @validator.one_to_many
            def validate(self) -> None:
                pass

        # Called directly
        class MyTransform(TransformElement):
            def __post_init__(self):
                super().__post_init__()
                validator.one_to_many(self)
    """

    def validate(self: T) -> None:
        assert len(self.sink_pads) == 1, (
            f"{self.name} requires exactly one sink pad, " f"got {len(self.sink_pads)}"
        )

    return _make_validator(validate)(arg)

one_to_one(arg) 

one_to_one(arg: TMethod) -> TMethod

one_to_one(arg: T) -> None

Validator for one-to-one transforms.

Can be used as a decorator or called directly::

# As a decorator
class MyTransform(TransformElement):
    @validator.one_to_one
    def validate(self) -> None:
        pass

# Called directly
class MyTransform(TransformElement):
    def __post_init__(self):
        super().__post_init__()
        validator.one_to_one(self)
Source code in src/sgn/validator.py 
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
def one_to_one(arg: TMethod | T) -> TMethod | None:
    """Validator for one-to-one transforms.

    Can be used as a decorator or called directly::

        # As a decorator
        class MyTransform(TransformElement):
            @validator.one_to_one
            def validate(self) -> None:
                pass

        # Called directly
        class MyTransform(TransformElement):
            def __post_init__(self):
                super().__post_init__()
                validator.one_to_one(self)
    """

    def validate(self: T) -> None:
        assert len(self.sink_pads) == 1 and len(self.source_pads) == 1, (
            f"{self.name} requires exactly one sink and source pad, "
            f"got {len(self.sink_pads)} sink pads and "
            f"{len(self.source_pads)} source pads"
        )

    return _make_validator(validate)(arg)

pad_names_match(arg) 

pad_names_match(arg: TMethod) -> TMethod

pad_names_match(arg: T) -> None

Validator that source and sink pad names match.

Can be used as a decorator or called directly::

# As a decorator
class MyTransform(TransformElement):
    @validator.pad_names_match
    def validate(self) -> None:
        pass

# Called directly
class MyTransform(TransformElement):
    def __post_init__(self):
        super().__post_init__()
        validator.pad_names_match(self)
Source code in src/sgn/validator.py 
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
def pad_names_match(arg: TMethod | T) -> TMethod | None:
    """Validator that source and sink pad names match.

    Can be used as a decorator or called directly::

        # As a decorator
        class MyTransform(TransformElement):
            @validator.pad_names_match
            def validate(self) -> None:
                pass

        # Called directly
        class MyTransform(TransformElement):
            def __post_init__(self):
                super().__post_init__()
                validator.pad_names_match(self)
    """

    def validate(self: T) -> None:
        assert set(self.source_pad_names) == set(self.sink_pad_names), (
            f"{self.name} requires source and sink pad names to match. "
            f"Source: {self.source_pad_names}, Sink: {self.sink_pad_names}"
        )

    return _make_validator(validate)(arg)

single_pad(arg) 

single_pad(arg: SMethod) -> SMethod

single_pad(arg: S) -> None

Validator for single-pad sinks.

Can be used as a decorator or called directly::

# As a decorator
class MySink(SinkElement):
    @validator.single_pad
    def validate(self) -> None:
        pass

# Called directly
class MySink(SinkElement):
    def __post_init__(self):
        super().__post_init__()
        validator.single_pad(self)
Source code in src/sgn/validator.py 
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
def single_pad(arg: SMethod | S) -> SMethod | None:
    """Validator for single-pad sinks.

    Can be used as a decorator or called directly::

        # As a decorator
        class MySink(SinkElement):
            @validator.single_pad
            def validate(self) -> None:
                pass

        # Called directly
        class MySink(SinkElement):
            def __post_init__(self):
                super().__post_init__()
                validator.single_pad(self)
    """

    def validate(self: S) -> None:
        assert len(self.sink_pads) == 1, (
            f"{self.name} requires exactly one sink pad, " f"got {len(self.sink_pads)}"
        )

    return _make_validator(validate)(arg)