Skip to content

Validators

provide.foundation.config.validators

TODO: Add module docstring.

Functions

validate_choice 

validate_choice(
    choices: list[Any],
) -> Callable[[Any, Any, Any], None]

Create a validator that ensures value is one of the given choices.

Parameters:

Name Type Description Default
choices list[Any]

List of valid choices

 required

Returns:

Type Description
Callable[[Any, Any, Any], None]

Validator function for use with attrs
Source code in provide/foundation/config/validators.py 
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
def validate_choice(choices: list[Any]) -> Callable[[Any, Any, Any], None]:
    """Create a validator that ensures value is one of the given choices.

    Args:
        choices: List of valid choices

    Returns:
        Validator function for use with attrs

    """

    def validator(instance: Any, attribute: Any, value: Any) -> None:
        if value not in choices:
            # Import ValidationError locally to avoid circular imports
            from provide.foundation.errors.config import ValidationError

            raise ValidationError(
                f"Invalid value '{value}' for {attribute.name}. Must be one of: {choices!r}",
            )

    return validator

validate_log_level 

validate_log_level(
    instance: Any, attribute: Any, value: str
) -> None

Validate that a log level is valid.

Source code in provide/foundation/config/validators.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
def validate_log_level(instance: Any, attribute: Any, value: str) -> None:
    """Validate that a log level is valid."""
    # Import ValidationError locally to avoid circular imports
    from provide.foundation.errors.config import ValidationError

    if value not in _VALID_LOG_LEVEL_TUPLE:
        raise ValidationError(
            _format_invalid_value_error(
                attribute.name,
                value,
                valid_options=list(_VALID_LOG_LEVEL_TUPLE),
            ),
        )

validate_non_negative 

validate_non_negative(
    instance: Any, attribute: Any, value: float
) -> None

Validate that a value is non-negative.

Source code in provide/foundation/config/validators.py 
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
def validate_non_negative(instance: Any, attribute: Any, value: float) -> None:
    """Validate that a value is non-negative."""
    # Import ValidationError locally to avoid circular imports
    from provide.foundation.errors.config import ValidationError

    # Check if value is numeric
    if not isinstance(value, (int, float)):
        raise ValidationError(
            f"Value must be a number, got {type(value).__name__}",
        )

    if value < 0:
        raise ValidationError(
            _format_validation_error(attribute.name, value, "must be non-negative"),
        )

validate_overflow_policy 

validate_overflow_policy(
    instance: Any, attribute: Any, value: str
) -> None

Validate rate limit overflow policy.

Source code in provide/foundation/config/validators.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
def validate_overflow_policy(instance: Any, attribute: Any, value: str) -> None:
    """Validate rate limit overflow policy."""
    # Import ValidationError locally to avoid circular imports
    from provide.foundation.errors.config import ValidationError

    if value not in _VALID_OVERFLOW_POLICY_TUPLE:
        raise ValidationError(
            _format_invalid_value_error(
                attribute.name,
                value,
                valid_options=list(_VALID_OVERFLOW_POLICY_TUPLE),
            ),
        )

validate_port 

validate_port(
    instance: Any, attribute: Any, value: int
) -> None

Validate that a port number is valid.

Source code in provide/foundation/config/validators.py 
54
55
56
57
58
59
60
61
62
def validate_port(instance: Any, attribute: Any, value: int) -> None:
    """Validate that a port number is valid."""
    # Import ValidationError locally to avoid circular imports
    from provide.foundation.errors.config import ValidationError

    if not 1 <= value <= 65535:
        raise ValidationError(
            _format_validation_error(attribute.name, value, "must be between 1 and 65535"),
        )

validate_positive 

validate_positive(
    instance: Any, attribute: Any, value: float
) -> None

Validate that a value is positive.

Source code in provide/foundation/config/validators.py 
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
def validate_positive(instance: Any, attribute: Any, value: float) -> None:
    """Validate that a value is positive."""
    # Import ValidationError locally to avoid circular imports
    from provide.foundation.errors.config import ValidationError

    # Check if value is numeric
    if not isinstance(value, (int, float)):
        raise ValidationError(
            f"Value must be a number, got {type(value).__name__}",
        )

    if value <= 0:
        raise ValidationError(
            _format_validation_error(attribute.name, value, "must be positive"),
        )

validate_range 

validate_range(
    min_val: float, max_val: float
) -> Callable[[Any, Any, Any], None]

Create a validator that ensures value is within the given numeric range.

Parameters:

Name Type Description Default
min_val float

Minimum allowed value (inclusive)

 required
max_val float

Maximum allowed value (inclusive)

 required

Returns:

Type Description
Callable[[Any, Any, Any], None]

Validator function for use with attrs
Source code in provide/foundation/config/validators.py 
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
def validate_range(min_val: float, max_val: float) -> Callable[[Any, Any, Any], None]:
    """Create a validator that ensures value is within the given numeric range.

    Args:
        min_val: Minimum allowed value (inclusive)
        max_val: Maximum allowed value (inclusive)

    Returns:
        Validator function for use with attrs

    """

    def validator(instance: Any, attribute: Any, value: Any) -> None:
        # Import ValidationError locally to avoid circular imports
        from provide.foundation.errors.config import ValidationError

        # Check if value is numeric
        if not isinstance(value, (int, float)):
            raise ValidationError(
                f"Value must be a number, got {type(value).__name__}",
            )

        if not (min_val <= value <= max_val):
            raise ValidationError(
                f"Value must be between {min_val} and {max_val}, got {value}",
            )

    return validator

validate_sample_rate 

validate_sample_rate(
    instance: Any, attribute: Any, value: float
) -> None

Validate that a sample rate is between 0.0 and 1.0.

Source code in provide/foundation/config/validators.py 
43
44
45
46
47
48
49
50
51
def validate_sample_rate(instance: Any, attribute: Any, value: float) -> None:
    """Validate that a sample rate is between 0.0 and 1.0."""
    # Import ValidationError locally to avoid circular imports
    from provide.foundation.errors.config import ValidationError

    if not 0.0 <= value <= 1.0:
        raise ValidationError(
            _format_validation_error(attribute.name, value, "must be between 0.0 and 1.0"),
        )