Skip to content

types.middleware.validators

Between

Validator to ensure that a value falls within a particular range

Type Constraints

  • Supports Comparison (<, >, ==)
Source code in /home/runner/work/arc/arc/arc/types/middleware/validators.py 
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
class Between:
    """Validator to ensure that a value falls within a particular range

    ## Type Constraints
    - Supports Comparison (<, >, ==)
    """

    def __init__(self, lower: SupportsComparison, upper: SupportsComparison):
        self.lower = lower
        self.upper = upper

    def __call__(self, value: SupportsComparison) -> SupportsComparison:
        if value <= self.lower or value >= self.upper:
            raise errors.ValidationError(
                f"must be between {self.lower} and {self.upper}"
            )

        return value

GreaterThan

Validator to limit the maximum size of a value

Type Constraints

  • Supports Comparison (<, >, ==)
Source code in /home/runner/work/arc/arc/arc/types/middleware/validators.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
class GreaterThan:
    """Validator to limit the maximum size of a value

    ## Type Constraints
    - Supports Comparison (<, >, ==)
    """

    def __init__(self, smallest: SupportsComparison):
        self.smallest = smallest

    def __call__(self, value: SupportsComparison) -> SupportsComparison:
        if value <= self.smallest:
            raise errors.ValidationError(f"must be greater than {self.smallest}")

        return value

Len

Validator for the length of a value.

  • Len(4) - Value must be length 4
  • Len(1, 4) - Value must be from length 1 to 4

Type Constraints

  • Supports len()

Note: If you find yourself doing something similar to Annotated[list[int], Len(2)], it's generally going to be a bettter idea to do: tuple[int, int]

Source code in /home/runner/work/arc/arc/arc/types/middleware/validators.py 
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
class Len:
    """Validator for the length of a value.

    - `Len(4)` - Value must be length 4
    - `Len(1, 4)` - Value must be from length 1 to 4

    ## Type Constraints
    - Supports `len()`

    **Note**: If you find yourself doing something similar to `Annotated[list[int], Len(2)]`,
    it's generally going to be a bettter idea to do: `tuple[int, int]`
    """

    def __init__(self, min: int, max: int | None = None):
        self.min = min
        self.max = max

    def __call__(
        self,
        value: SupportsLen,
        ctx: Context | None = None,
        param: Param[t.Any] | None = None,
    ) -> SupportsLen:
        length = len(value)

        if self.max:
            if length < self.min or length > self.max:
                if param and param.type.is_collection_type:
                    raise errors.ValidationError(
                        f"expects between {self.min} and {self.max} arguments"
                    )

                raise errors.ValidationError(
                    f"must have a length between {self.min} and {self.max}"
                )
        elif length != self.min:
            if param and param.type.is_collection_type:
                raise errors.ValidationError(f"expects {self.min} arguments")

            raise errors.ValidationError(f"must have a length equal to {self.min}")

        return value

LessThan

Validator to limit the minimum size of a value

Type Constraints

  • Supports Comparison (<, >, ==)
Source code in /home/runner/work/arc/arc/arc/types/middleware/validators.py 
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
class LessThan:
    """Validator to limit the minimum size of a value

    ## Type Constraints
    - Supports Comparison (<, >, ==)
    """

    def __init__(self, largest: SupportsComparison):
        self.largest = largest

    def __call__(self, value: SupportsComparison) -> SupportsComparison:
        if value >= self.largest:
            raise errors.ValidationError(f"must be less than {self.largest}")

        return value

Matches

Validator to match a regular expression.

Type Constraints

  • Matches against str(value), so the type must have a sensible string representation
Source code in /home/runner/work/arc/arc/arc/types/middleware/validators.py 
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
class Matches:
    """Validator to match a regular expression.

    ## Type Constraints
    - Matches against `str(value)`, so the type must have a sensible string representation
    """

    def __init__(
        self,
        pattern: str | re.Pattern[str],
        flags: int = 0,
        message: str = "does not match expected format: {pattern}",
    ):
        self.pattern = pattern
        self.flags = flags
        self.message = message

    def __call__(self, value: t.Any) -> t.Any:
        if not re.match(self.pattern, str(value), self.flags):
            raise errors.ValidationError(
                self.message.format(
                    pattern=self.pattern,
                    value=value,
                )
            )

        return value