|
49643
|
1 |
from typing import ( |
|
|
2 |
Any, |
|
|
3 |
AnyStr, |
|
|
4 |
Callable, |
|
|
5 |
Container, |
|
|
6 |
ContextManager, |
|
|
7 |
Iterable, |
|
|
8 |
List, |
|
|
9 |
Mapping, |
|
|
10 |
Match, |
|
|
11 |
Optional, |
|
|
12 |
Pattern, |
|
|
13 |
Tuple, |
|
|
14 |
Type, |
|
|
15 |
TypeVar, |
|
|
16 |
Union, |
|
|
17 |
overload, |
|
|
18 |
) |
|
|
19 |
|
|
|
20 |
from . import _ValidatorType |
|
|
21 |
from . import _ValidatorArgType |
|
|
22 |
|
|
|
23 |
_T = TypeVar("_T") |
|
|
24 |
_T1 = TypeVar("_T1") |
|
|
25 |
_T2 = TypeVar("_T2") |
|
|
26 |
_T3 = TypeVar("_T3") |
|
|
27 |
_I = TypeVar("_I", bound=Iterable) |
|
|
28 |
_K = TypeVar("_K") |
|
|
29 |
_V = TypeVar("_V") |
|
|
30 |
_M = TypeVar("_M", bound=Mapping) |
|
|
31 |
|
|
|
32 |
def set_disabled(run: bool) -> None: ... |
|
|
33 |
def get_disabled() -> bool: ... |
|
|
34 |
def disabled() -> ContextManager[None]: ... |
|
|
35 |
|
|
|
36 |
# To be more precise on instance_of use some overloads. |
|
|
37 |
# If there are more than 3 items in the tuple then we fall back to Any |
|
|
38 |
@overload |
|
|
39 |
def instance_of(type: Type[_T]) -> _ValidatorType[_T]: ... |
|
|
40 |
@overload |
|
|
41 |
def instance_of(type: Tuple[Type[_T]]) -> _ValidatorType[_T]: ... |
|
|
42 |
@overload |
|
|
43 |
def instance_of( |
|
|
44 |
type: Tuple[Type[_T1], Type[_T2]] |
|
|
45 |
) -> _ValidatorType[Union[_T1, _T2]]: ... |
|
|
46 |
@overload |
|
|
47 |
def instance_of( |
|
|
48 |
type: Tuple[Type[_T1], Type[_T2], Type[_T3]] |
|
|
49 |
) -> _ValidatorType[Union[_T1, _T2, _T3]]: ... |
|
|
50 |
@overload |
|
|
51 |
def instance_of(type: Tuple[type, ...]) -> _ValidatorType[Any]: ... |
|
|
52 |
def provides(interface: Any) -> _ValidatorType[Any]: ... |
|
|
53 |
def optional( |
|
|
54 |
validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]] |
|
|
55 |
) -> _ValidatorType[Optional[_T]]: ... |
|
|
56 |
def in_(options: Container[_T]) -> _ValidatorType[_T]: ... |
|
|
57 |
def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ... |
|
|
58 |
def matches_re( |
|
|
59 |
regex: Union[Pattern[AnyStr], AnyStr], |
|
|
60 |
flags: int = ..., |
|
|
61 |
func: Optional[ |
|
|
62 |
Callable[[AnyStr, AnyStr, int], Optional[Match[AnyStr]]] |
|
|
63 |
] = ..., |
|
|
64 |
) -> _ValidatorType[AnyStr]: ... |
|
|
65 |
def deep_iterable( |
|
|
66 |
member_validator: _ValidatorArgType[_T], |
|
|
67 |
iterable_validator: Optional[_ValidatorType[_I]] = ..., |
|
|
68 |
) -> _ValidatorType[_I]: ... |
|
|
69 |
def deep_mapping( |
|
|
70 |
key_validator: _ValidatorType[_K], |
|
|
71 |
value_validator: _ValidatorType[_V], |
|
|
72 |
mapping_validator: Optional[_ValidatorType[_M]] = ..., |
|
|
73 |
) -> _ValidatorType[_M]: ... |
|
|
74 |
def is_callable() -> _ValidatorType[_T]: ... |
|
|
75 |
def lt(val: _T) -> _ValidatorType[_T]: ... |
|
|
76 |
def le(val: _T) -> _ValidatorType[_T]: ... |
|
|
77 |
def ge(val: _T) -> _ValidatorType[_T]: ... |
|
|
78 |
def gt(val: _T) -> _ValidatorType[_T]: ... |
|
|
79 |
def max_len(length: int) -> _ValidatorType[_T]: ... |
|
|
80 |
def min_len(length: int) -> _ValidatorType[_T]: ... |