mercurial/thirdparty/attr/validators.pyi
changeset 49643 e1c586b9a43c
equal deleted inserted replaced
49642:7e6f3c69c0fb 49643:e1c586b9a43c
       
     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]: ...