mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-27 10:03:11 +07:00
Add forgotten typeshed files @ ac70fdc614feb07fb96e0524a06263c357f51647
This commit is contained in:
Semyon Proshev
@@ -0,0 +1,10 @@
|
||||
# Source: https://hg.python.org/cpython/file/2.7/Lib/dircache.py
|
||||
|
||||
from typing import List, MutableSequence, Text, Union
|
||||
|
||||
def reset() -> None: ...
|
||||
def listdir(path: Text) -> List[str]: ...
|
||||
|
||||
opendir = listdir
|
||||
|
||||
def annotate(head: Text, list: Union[MutableSequence[str], MutableSequence[Text], MutableSequence[Union[str, Text]]]) -> None: ...
|
||||
@@ -0,0 +1,8 @@
|
||||
def base64_len(s: bytes) -> int: ...
|
||||
def header_encode(header, charset=..., keep_eols=..., maxlinelen=..., eol=...): ...
|
||||
def encode(s, binary=..., maxlinelen=..., eol=...): ...
|
||||
body_encode = encode
|
||||
encodestring = encode
|
||||
def decode(s, convert_eols=...): ...
|
||||
body_decode = decode
|
||||
decodestring = decode
|
||||
@@ -0,0 +1,22 @@
|
||||
def add_charset(charset, header_enc=..., body_enc=..., output_charset=...) -> None: ...
|
||||
def add_alias(alias, canonical) -> None: ...
|
||||
def add_codec(charset, codecname) -> None: ...
|
||||
|
||||
class Charset:
|
||||
input_charset = ...
|
||||
header_encoding = ...
|
||||
body_encoding = ...
|
||||
output_charset = ...
|
||||
input_codec = ...
|
||||
output_codec = ...
|
||||
def __init__(self, input_charset=...) -> None: ...
|
||||
def __eq__(self, other): ...
|
||||
def __ne__(self, other): ...
|
||||
def get_body_encoding(self): ...
|
||||
def convert(self, s): ...
|
||||
def to_splittable(self, s): ...
|
||||
def from_splittable(self, ustr, to_output: bool = ...): ...
|
||||
def get_output_charset(self): ...
|
||||
def encoded_header_len(self, s): ...
|
||||
def header_encode(self, s, convert: bool = ...): ...
|
||||
def body_encode(self, s, convert: bool = ...): ...
|
||||
@@ -0,0 +1,4 @@
|
||||
def encode_base64(msg) -> None: ...
|
||||
def encode_quopri(msg) -> None: ...
|
||||
def encode_7or8bit(msg) -> None: ...
|
||||
def encode_noop(msg) -> None: ...
|
||||
@@ -0,0 +1,18 @@
|
||||
class BufferedSubFile:
|
||||
def __init__(self) -> None: ...
|
||||
def push_eof_matcher(self, pred) -> None: ...
|
||||
def pop_eof_matcher(self): ...
|
||||
def close(self) -> None: ...
|
||||
def readline(self): ...
|
||||
def unreadline(self, line) -> None: ...
|
||||
def push(self, data): ...
|
||||
def pushlines(self, lines) -> None: ...
|
||||
def is_closed(self): ...
|
||||
def __iter__(self): ...
|
||||
def next(self): ...
|
||||
|
||||
|
||||
class FeedParser:
|
||||
def __init__(self, _factory=...) -> None: ...
|
||||
def feed(self, data) -> None: ...
|
||||
def close(self): ...
|
||||
@@ -0,0 +1,9 @@
|
||||
class Generator:
|
||||
def __init__(self, outfp, mangle_from_: bool = ..., maxheaderlen: int = ...) -> None: ...
|
||||
def write(self, s) -> None: ...
|
||||
def flatten(self, msg, unixfrom: bool = ...) -> None: ...
|
||||
def clone(self, fp): ...
|
||||
|
||||
|
||||
class DecodedGenerator(Generator):
|
||||
def __init__(self, outfp, mangle_from_: bool = ..., maxheaderlen: int = ..., fmt=...) -> None: ...
|
||||
@@ -0,0 +1,11 @@
|
||||
def decode_header(header): ...
|
||||
def make_header(decoded_seq, maxlinelen=..., header_name=..., continuation_ws=...): ...
|
||||
|
||||
class Header:
|
||||
def __init__(self, s=..., charset=..., maxlinelen=..., header_name=..., continuation_ws=...,
|
||||
errors=...) -> None: ...
|
||||
def __unicode__(self): ...
|
||||
def __eq__(self, other): ...
|
||||
def __ne__(self, other): ...
|
||||
def append(self, s, charset=..., errors=...) -> None: ...
|
||||
def encode(self, splitchars=...): ...
|
||||
@@ -0,0 +1,5 @@
|
||||
from typing import Generator
|
||||
|
||||
def walk(self) -> Generator: ...
|
||||
def body_line_iterator(msg, decode: bool = ...) -> Generator: ...
|
||||
def typed_subpart_iterator(msg, maintype=..., subtype=...) -> Generator: ...
|
||||
@@ -0,0 +1,45 @@
|
||||
from typing import Generator
|
||||
|
||||
class Message:
|
||||
preamble = ...
|
||||
epilogue = ...
|
||||
defects = ...
|
||||
def __init__(self): ...
|
||||
def as_string(self, unixfrom=...): ...
|
||||
def is_multipart(self) -> bool: ...
|
||||
def set_unixfrom(self, unixfrom) -> None: ...
|
||||
def get_unixfrom(self): ...
|
||||
def attach(self, payload) -> None: ...
|
||||
def get_payload(self, i=..., decode: bool = ...): ...
|
||||
def set_payload(self, payload, charset=...) -> None: ...
|
||||
def set_charset(self, charset): ...
|
||||
def get_charset(self): ...
|
||||
def __len__(self): ...
|
||||
def __getitem__(self, name): ...
|
||||
def __setitem__(self, name, val) -> None: ...
|
||||
def __delitem__(self, name) -> None: ...
|
||||
def __contains__(self, name): ...
|
||||
def has_key(self, name) -> bool: ...
|
||||
def keys(self): ...
|
||||
def values(self): ...
|
||||
def items(self): ...
|
||||
def get(self, name, failobj=...): ...
|
||||
def get_all(self, name, failobj=...): ...
|
||||
def add_header(self, _name, _value, **_params) -> None: ...
|
||||
def replace_header(self, _name, _value) -> None: ...
|
||||
def get_content_type(self): ...
|
||||
def get_content_maintype(self): ...
|
||||
def get_content_subtype(self): ...
|
||||
def get_default_type(self): ...
|
||||
def set_default_type(self, ctype) -> None: ...
|
||||
def get_params(self, failobj=..., header=..., unquote: bool = ...): ...
|
||||
def get_param(self, param, failobj=..., header=..., unquote: bool = ...): ...
|
||||
def set_param(self, param, value, header=..., requote: bool = ..., charset=..., language=...) -> None: ...
|
||||
def del_param(self, param, header=..., requote: bool = ...): ...
|
||||
def set_type(self, type, header=..., requote: bool = ...): ...
|
||||
def get_filename(self, failobj=...): ...
|
||||
def get_boundary(self, failobj=...): ...
|
||||
def set_boundary(self, boundary) -> None: ...
|
||||
def get_content_charset(self, failobj=...): ...
|
||||
def get_charsets(self, failobj=...): ...
|
||||
def walk(self) -> Generator: ...
|
||||
@@ -0,0 +1,5 @@
|
||||
from email.mime.nonmultipart import MIMENonMultipart
|
||||
|
||||
|
||||
class MIMEAudio(MIMENonMultipart):
|
||||
def __init__(self, _audiodata, _subtype=..., _encoder=..., **_params) -> None: ...
|
||||
@@ -0,0 +1,5 @@
|
||||
from email.mime.nonmultipart import MIMENonMultipart
|
||||
|
||||
|
||||
class MIMEImage(MIMENonMultipart):
|
||||
def __init__(self, _imagedata, _subtype=..., _encoder=..., **_params) -> None: ...
|
||||
@@ -0,0 +1,5 @@
|
||||
from email.mime.nonmultipart import MIMENonMultipart
|
||||
|
||||
|
||||
class MIMEMessage(MIMENonMultipart):
|
||||
def __init__(self, _msg, _subtype=...) -> None: ...
|
||||
@@ -0,0 +1,8 @@
|
||||
class Parser:
|
||||
def __init__(self, *args, **kws) -> None: ...
|
||||
def parse(self, fp, headersonly: bool = ...): ...
|
||||
def parsestr(self, text, headersonly: bool = ...): ...
|
||||
|
||||
class HeaderParser(Parser):
|
||||
def parse(self, fp, headersonly: bool = ...): ...
|
||||
def parsestr(self, text, headersonly: bool = ...): ...
|
||||
@@ -0,0 +1,18 @@
|
||||
def header_quopri_check(c): ...
|
||||
def body_quopri_check(c): ...
|
||||
def header_quopri_len(s): ...
|
||||
def body_quopri_len(str): ...
|
||||
def unquote(s): ...
|
||||
def quote(c): ...
|
||||
def header_encode(header, charset: str = ..., keep_eols: bool = ..., maxlinelen: int = ..., eol=...): ...
|
||||
def encode(body, binary: bool = ..., maxlinelen: int = ..., eol=...): ...
|
||||
|
||||
body_encode = encode
|
||||
encodestring = encode
|
||||
|
||||
def decode(encoded, eol=...): ...
|
||||
|
||||
body_decode = decode
|
||||
decodestring = decode
|
||||
|
||||
def header_decode(s): ...
|
||||
@@ -0,0 +1,58 @@
|
||||
# Stubs for multiprocessing.pool (Python 2)
|
||||
|
||||
from typing import (
|
||||
Any, Callable, ContextManager, Iterable, Mapping, Optional, Dict, List,
|
||||
TypeVar,
|
||||
)
|
||||
|
||||
_T = TypeVar('_T', bound='Pool')
|
||||
|
||||
class AsyncResult():
|
||||
def get(self, timeout: Optional[float] = ...) -> Any: ...
|
||||
def wait(self, timeout: Optional[float] = ...) -> None: ...
|
||||
def ready(self) -> bool: ...
|
||||
def successful(self) -> bool: ...
|
||||
|
||||
class IMapIterator(Iterable[Any]):
|
||||
def next(self, timeout: Optional[float] = ...) -> Any: ...
|
||||
|
||||
class Pool(ContextManager[Pool]):
|
||||
def __init__(self, processes: Optional[int] = ...,
|
||||
initializer: Optional[Callable[..., None]] = ...,
|
||||
initargs: Iterable[Any] = ...,
|
||||
maxtasksperchild: Optional[int] = ...) -> None: ...
|
||||
def apply(self,
|
||||
func: Callable[..., Any],
|
||||
args: Iterable[Any] = ...,
|
||||
kwds: Dict[str, Any] = ...) -> Any: ...
|
||||
def apply_async(self,
|
||||
func: Callable[..., Any],
|
||||
args: Iterable[Any] = ...,
|
||||
kwds: Dict[str, Any] = ...,
|
||||
callback: Optional[Callable[..., None]] = ...) -> AsyncResult: ...
|
||||
def map(self,
|
||||
func: Callable[..., Any],
|
||||
iterable: Iterable[Any] = ...,
|
||||
chunksize: Optional[int] = ...) -> List[Any]: ...
|
||||
def map_async(self, func: Callable[..., Any],
|
||||
iterable: Iterable[Any] = ...,
|
||||
chunksize: Optional[int] = ...,
|
||||
callback: Optional[Callable[..., None]] = ...) -> AsyncResult: ...
|
||||
def imap(self,
|
||||
func: Callable[..., Any],
|
||||
iterable: Iterable[Any] = ...,
|
||||
chunksize: Optional[int] = ...) -> IMapIterator: ...
|
||||
def imap_unordered(self,
|
||||
func: Callable[..., Any],
|
||||
iterable: Iterable[Any] = ...,
|
||||
chunksize: Optional[int] = ...) -> IMapIterator: ...
|
||||
def close(self) -> None: ...
|
||||
def terminate(self) -> None: ...
|
||||
def join(self) -> None: ...
|
||||
def __enter__(self: _T) -> _T: ...
|
||||
|
||||
class ThreadPool(Pool, ContextManager[ThreadPool]):
|
||||
|
||||
def __init__(self, processes: Optional[int] = ...,
|
||||
initializer: Optional[Callable[..., Any]] = ...,
|
||||
initargs: Iterable[Any] = ...) -> None: ...
|
||||
@@ -0,0 +1,255 @@
|
||||
# Stubs for ctypes
|
||||
|
||||
from typing import (
|
||||
Any, Callable, ClassVar, Iterable, List, Mapping, Optional, Sequence, Sized, Text, Tuple, Type,
|
||||
Generic, TypeVar, overload,
|
||||
)
|
||||
from typing import Union as _UnionT
|
||||
import sys
|
||||
|
||||
_T = TypeVar('_T')
|
||||
_DLLT = TypeVar('_DLLT', bound=CDLL)
|
||||
_CT = TypeVar('_CT', bound=_CData)
|
||||
|
||||
|
||||
RTLD_GLOBAL: int = ...
|
||||
RTLD_LOCAL: int = ...
|
||||
DEFAULT_MODE: int = ...
|
||||
|
||||
|
||||
class CDLL(object):
|
||||
_func_flags_: ClassVar[int] = ...
|
||||
_func_restype_: ClassVar[_CData] = ...
|
||||
_name: str = ...
|
||||
_handle: int = ...
|
||||
_FuncPtr: Type[_FuncPointer] = ...
|
||||
def __init__(self, name: str, mode: int = ..., handle: Optional[int] = ...,
|
||||
use_errno: bool = ..., use_last_error: bool = ...) -> None: ...
|
||||
def __getattr__(self, name: str) -> _FuncPointer: ...
|
||||
def __getitem__(self, name: str) -> _FuncPointer: ...
|
||||
if sys.platform == 'win32':
|
||||
class OleDLL(CDLL): ...
|
||||
class WinDLL(CDLL): ...
|
||||
class PyDLL(CDLL): ...
|
||||
|
||||
class LibraryLoader(Generic[_DLLT]):
|
||||
def __init__(self, dlltype: Type[_DLLT]) -> None: ...
|
||||
def __getattr__(self, name: str) -> _DLLT: ...
|
||||
def __getitem__(self, name: str) -> _DLLT: ...
|
||||
def LoadLibrary(self, name: str) -> _DLLT: ...
|
||||
|
||||
cdll: LibraryLoader[CDLL] = ...
|
||||
if sys.platform == 'win32':
|
||||
windll: LibraryLoader[WinDLL] = ...
|
||||
oledll: LibraryLoader[OleDLL] = ...
|
||||
pydll: LibraryLoader[PyDLL] = ...
|
||||
pythonapi: PyDLL = ...
|
||||
|
||||
class _CDataMeta(type):
|
||||
# TODO The return type is not accurate. The method definition *should* look like this:
|
||||
# def __mul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ...
|
||||
# but that is not valid, because technically a _CDataMeta might not be a Type[_CT].
|
||||
# This can never actually happen, because all _CDataMeta instances are _CData subclasses, but a typechecker doesn't know that.
|
||||
def __mul__(cls: _CDataMeta, other: int) -> Type[Array[_CT]]: ...
|
||||
def __rmul__(cls: _CDataMeta, other: int) -> Type[Array[_CT]]: ...
|
||||
class _CData(metaclass=_CDataMeta):
|
||||
_b_base: int = ...
|
||||
_b_needsfree_: bool = ...
|
||||
_objects: Optional[Mapping[Any, int]] = ...
|
||||
@classmethod
|
||||
def from_buffer(cls: Type[_CT], source: bytearray, offset: int = ...) -> _CT: ...
|
||||
@classmethod
|
||||
def from_buffer_copy(cls: Type[_CT], source: bytearray, offset: int = ...) -> _CT: ...
|
||||
@classmethod
|
||||
def from_address(cls: Type[_CT], address: int) -> _CT: ...
|
||||
@classmethod
|
||||
def from_param(cls: Type[_CT], obj: Any) -> _UnionT[_CT, _cparam]: ...
|
||||
@classmethod
|
||||
def in_dll(cls: Type[_CT], library: CDLL, name: str) -> _CT: ...
|
||||
|
||||
class _PointerLike(_CData): pass
|
||||
|
||||
_ECT = Callable[[Optional[Type[_CData]],
|
||||
_FuncPointer,
|
||||
Tuple[_CData, ...]],
|
||||
_CData]
|
||||
_PF = _UnionT[
|
||||
Tuple[int],
|
||||
Tuple[int, str],
|
||||
Tuple[int, str, Any]
|
||||
]
|
||||
class _FuncPointer(_PointerLike, _CData):
|
||||
restype: _UnionT[Type[_CData], Callable[[int], None], None] = ...
|
||||
argtypes: Tuple[Type[_CData], ...] = ...
|
||||
errcheck: _ECT = ...
|
||||
@overload
|
||||
def __init__(self, address: int) -> None: ...
|
||||
@overload
|
||||
def __init__(self, callable: Callable[..., Any]) -> None: ...
|
||||
@overload
|
||||
def __init__(self, func_spec: Tuple[_UnionT[str, int], CDLL],
|
||||
paramflags: Tuple[_PF, ...] = ...) -> None: ...
|
||||
@overload
|
||||
def __init__(self, vtlb_index: int, name: str,
|
||||
paramflags: Tuple[_PF, ...] = ...,
|
||||
iid: _Pointer[c_int] = ...) -> None: ...
|
||||
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
|
||||
|
||||
class ArgumentError(Exception): ...
|
||||
|
||||
|
||||
def CFUNCTYPE(restype: Type[_CData],
|
||||
*argtypes: Type[_CData],
|
||||
use_errno: bool = ...,
|
||||
use_last_error: bool = ...) -> Type[_FuncPointer]: ...
|
||||
if sys.platform == 'win32':
|
||||
def WINFUNCTYPE(restype: Type[_CData],
|
||||
*argtypes: Type[_CData],
|
||||
use_errno: bool = ...,
|
||||
use_last_error: bool = ...) -> Type[_FuncPointer]: ...
|
||||
def PYFUNCTYPE(restype: Type[_CData],
|
||||
*argtypes: Type[_CData]) -> Type[_FuncPointer]: ...
|
||||
|
||||
class _cparam: ...
|
||||
|
||||
def addressof(obj: _CData) -> int: ...
|
||||
def alignment(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
|
||||
def byref(obj: _CData, offset: int = ...) -> _cparam: ...
|
||||
_PT = TypeVar('_PT', bound=_PointerLike)
|
||||
def cast(obj: _UnionT[_CData, _cparam], type: Type[_PT]) -> _PT: ...
|
||||
def create_string_buffer(init_or_size: _UnionT[int, bytes],
|
||||
size: Optional[int] = ...) -> Array[c_char]: ...
|
||||
c_buffer = create_string_buffer
|
||||
def create_unicode_buffer(init_or_size: _UnionT[int, Text],
|
||||
size: Optional[int] = ...) -> Array[c_wchar]: ...
|
||||
if sys.platform == 'win32':
|
||||
def DllCanUnloadNow() -> int: ...
|
||||
def DllGetClassObject(rclsid: Any, riid: Any, ppv: Any) -> int: ... # TODO not documented
|
||||
def FormatError(code: int) -> str: ...
|
||||
def GetLastError() -> int: ...
|
||||
def get_errno() -> int: ...
|
||||
if sys.platform == 'win32':
|
||||
def get_last_error() -> int: ...
|
||||
def memmove(dst: _UnionT[int, _CData],
|
||||
src: _UnionT[int, _CData],
|
||||
count: int) -> None: ...
|
||||
def memset(dst: _UnionT[int, _CData],
|
||||
c: int, count: int) -> None: ...
|
||||
def POINTER(type: Type[_CT]) -> Type[_Pointer[_CT]]: ...
|
||||
def pointer(obj: _CT) -> _Pointer[_CT]: ...
|
||||
def resize(obj: _CData, size: int) -> None: ...
|
||||
if sys.version_info < (3,):
|
||||
def set_conversion_mode(encoding: str, errors: str) -> Tuple[str, str]: ...
|
||||
def set_errno(value: int) -> int: ...
|
||||
if sys.platform == 'win32':
|
||||
def set_last_error(value: int) -> int: ...
|
||||
def sizeof(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
|
||||
def string_at(address: int, size: int = ...) -> bytes: ...
|
||||
if sys.platform == 'win32':
|
||||
def WinError(code: Optional[int] = ...,
|
||||
desc: Optional[str] = ...) -> OSError: ...
|
||||
def wstring_at(address: int, size: int = ...) -> str: ...
|
||||
|
||||
class _SimpleCData(Generic[_T], _CData):
|
||||
value: _T = ...
|
||||
def __init__(self, value: _T = ...) -> None: ...
|
||||
|
||||
class c_byte(_SimpleCData[int]): ...
|
||||
|
||||
class c_char(_SimpleCData[bytes]):
|
||||
def __init__(self, value: _UnionT[int, bytes] = ...) -> None: ...
|
||||
class c_char_p(_PointerLike, _SimpleCData[Optional[bytes]]):
|
||||
def __init__(self, value: Optional[_UnionT[int, bytes]] = ...) -> None: ...
|
||||
|
||||
class c_double(_SimpleCData[float]): ...
|
||||
class c_longdouble(_SimpleCData[float]): ...
|
||||
class c_float(_SimpleCData[float]): ...
|
||||
|
||||
class c_int(_SimpleCData[int]): ...
|
||||
class c_int8(_SimpleCData[int]): ...
|
||||
class c_int16(_SimpleCData[int]): ...
|
||||
class c_int32(_SimpleCData[int]): ...
|
||||
class c_int64(_SimpleCData[int]): ...
|
||||
|
||||
class c_long(_SimpleCData[int]): ...
|
||||
class c_longlong(_SimpleCData[int]): ...
|
||||
|
||||
class c_short(_SimpleCData[int]): ...
|
||||
|
||||
class c_size_t(_SimpleCData[int]): ...
|
||||
class c_ssize_t(_SimpleCData[int]): ...
|
||||
|
||||
class c_ubyte(_SimpleCData[int]): ...
|
||||
|
||||
class c_uint(_SimpleCData[int]): ...
|
||||
class c_uint8(_SimpleCData[int]): ...
|
||||
class c_uint16(_SimpleCData[int]): ...
|
||||
class c_uint32(_SimpleCData[int]): ...
|
||||
class c_uint64(_SimpleCData[int]): ...
|
||||
|
||||
class c_ulong(_SimpleCData[int]): ...
|
||||
class c_ulonglong(_SimpleCData[int]): ...
|
||||
|
||||
class c_ushort(_SimpleCData[int]): ...
|
||||
|
||||
class c_void_p(_PointerLike, _SimpleCData[Optional[int]]): ...
|
||||
|
||||
class c_wchar(_SimpleCData[Text]): ...
|
||||
class c_wchar_p(_PointerLike, _SimpleCData[Optional[Text]]):
|
||||
def __init__(self, value: Optional[_UnionT[int, Text]] = ...) -> None: ...
|
||||
|
||||
class c_bool(_SimpleCData[bool]):
|
||||
def __init__(self, value: bool) -> None: ...
|
||||
|
||||
if sys.platform == 'win32':
|
||||
class HRESULT(_SimpleCData[Any]): ... # TODO undocumented
|
||||
|
||||
class py_object(_SimpleCData[_T]): ...
|
||||
|
||||
class _CField:
|
||||
offset: int = ...
|
||||
size: int = ...
|
||||
class _StructUnionMeta(_CDataMeta):
|
||||
_fields_: Sequence[_UnionT[Tuple[str, Type[_CData]], Tuple[str, Type[_CData], int]]] = ...
|
||||
_pack_: int = ...
|
||||
_anonymous_: Sequence[str] = ...
|
||||
def __getattr__(self, name: str) -> _CField: ...
|
||||
class _StructUnionBase(_CData, metaclass=_StructUnionMeta):
|
||||
def __init__(self, *args: Any, **kw: Any) -> None: ...
|
||||
def __getattr__(self, name: str) -> Any: ...
|
||||
def __setattr__(self, name: str, value: Any) -> None: ...
|
||||
|
||||
class Union(_StructUnionBase): pass
|
||||
class Structure(_StructUnionBase): pass
|
||||
class BigEndianStructure(Structure): pass
|
||||
class LittleEndianStructure(Structure): pass
|
||||
|
||||
class Array(Generic[_T], Sized, _CData):
|
||||
_length_: ClassVar[int] = ...
|
||||
_type_: ClassVar[Type[_T]] = ...
|
||||
raw: bytes = ... # TODO only available with _T == c_char
|
||||
value: bytes = ... # TODO only available with _T == c_char
|
||||
def __init__(self, *args: _T) -> None: ...
|
||||
@overload
|
||||
def __getitem__(self, i: int) -> _T: ...
|
||||
@overload
|
||||
def __getitem__(self, s: slice) -> List[_T]: ...
|
||||
@overload
|
||||
def __setitem__(self, i: int, o: _T) -> None: ...
|
||||
@overload
|
||||
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
|
||||
def __iter__(self) -> Iterable[_T]: ...
|
||||
|
||||
|
||||
class _Pointer(Generic[_T], _PointerLike, _CData):
|
||||
_type_: ClassVar[Type[_T]] = ...
|
||||
contents: _T = ...
|
||||
def __init__(self, arg: _T = ...) -> None: ...
|
||||
@overload
|
||||
def __getitem__(self, i: int) -> _T: ...
|
||||
@overload
|
||||
def __getitem__(self, s: slice) -> List[_T]: ...
|
||||
@overload
|
||||
def __setitem__(self, i: int, o: _T) -> None: ...
|
||||
@overload
|
||||
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
|
||||
@@ -0,0 +1,8 @@
|
||||
# Stubs for ctypes.util
|
||||
|
||||
from typing import Optional
|
||||
import sys
|
||||
|
||||
def find_library(name: str) -> Optional[str]: ...
|
||||
if sys.platform == 'win32':
|
||||
def find_msvcrt() -> Optional[str]: ...
|
||||
@@ -0,0 +1,96 @@
|
||||
"""Stub file for the 'time' module."""
|
||||
# See https://docs.python.org/3/library/time.html
|
||||
|
||||
import sys
|
||||
from typing import Any, NamedTuple, Tuple, Union, Optional
|
||||
if sys.version_info >= (3, 3):
|
||||
from types import SimpleNamespace
|
||||
|
||||
_TimeTuple = Tuple[int, int, int, int, int, int, int, int, int]
|
||||
|
||||
if sys.version_info < (3, 3):
|
||||
accept2dyear: bool
|
||||
altzone: int
|
||||
daylight: int
|
||||
timezone: int
|
||||
tzname: Tuple[str, str]
|
||||
|
||||
if sys.version_info >= (3, 3) and sys.platform != 'win32':
|
||||
CLOCK_HIGHRES: int = ... # Solaris only
|
||||
CLOCK_MONOTONIC: int = ... # Unix only
|
||||
CLOCK_MONOTONIC_RAW: int = ... # Linux 2.6.28 or later
|
||||
CLOCK_PROCESS_CPUTIME_ID: int = ... # Unix only
|
||||
CLOCK_REALTIME: int = ... # Unix only
|
||||
CLOCK_THREAD_CPUTIME_ID: int = ... # Unix only
|
||||
|
||||
|
||||
if sys.version_info >= (3, 3):
|
||||
class struct_time(
|
||||
NamedTuple(
|
||||
'_struct_time',
|
||||
[('tm_year', int), ('tm_mon', int), ('tm_mday', int),
|
||||
('tm_hour', int), ('tm_min', int), ('tm_sec', int),
|
||||
('tm_wday', int), ('tm_yday', int), ('tm_isdst', int),
|
||||
('tm_zone', str), ('tm_gmtoff', int)]
|
||||
)
|
||||
):
|
||||
def __init__(
|
||||
self,
|
||||
o: Union[
|
||||
Tuple[int, int, int, int, int, int, int, int, int],
|
||||
Tuple[int, int, int, int, int, int, int, int, int, str],
|
||||
Tuple[int, int, int, int, int, int, int, int, int, str, int]
|
||||
],
|
||||
_arg: Any = ...,
|
||||
) -> None: ...
|
||||
def __new__(
|
||||
cls,
|
||||
o: Union[
|
||||
Tuple[int, int, int, int, int, int, int, int, int],
|
||||
Tuple[int, int, int, int, int, int, int, int, int, str],
|
||||
Tuple[int, int, int, int, int, int, int, int, int, str, int]
|
||||
],
|
||||
_arg: Any = ...,
|
||||
) -> struct_time: ...
|
||||
else:
|
||||
class struct_time(
|
||||
NamedTuple(
|
||||
'_struct_time',
|
||||
[('tm_year', int), ('tm_mon', int), ('tm_mday', int),
|
||||
('tm_hour', int), ('tm_min', int), ('tm_sec', int),
|
||||
('tm_wday', int), ('tm_yday', int), ('tm_isdst', int)]
|
||||
)
|
||||
):
|
||||
def __init__(self, o: _TimeTuple, _arg: Any = ...) -> None: ...
|
||||
def __new__(cls, o: _TimeTuple, _arg: Any = ...) -> struct_time: ...
|
||||
|
||||
def asctime(t: Union[_TimeTuple, struct_time] = ...) -> str: ...
|
||||
def clock() -> float: ...
|
||||
def ctime(secs: Optional[float] = ...) -> str: ...
|
||||
def gmtime(secs: Optional[float] = ...) -> struct_time: ...
|
||||
def localtime(secs: Optional[float] = ...) -> struct_time: ...
|
||||
def mktime(t: Union[_TimeTuple, struct_time]) -> float: ...
|
||||
def sleep(secs: float) -> None: ...
|
||||
def strftime(format: str, t: Union[_TimeTuple, struct_time] = ...) -> str: ...
|
||||
def strptime(string: str, format: str = ...) -> struct_time: ...
|
||||
def time() -> float: ...
|
||||
if sys.platform != 'win32':
|
||||
def tzset() -> None: ... # Unix only
|
||||
|
||||
if sys.version_info >= (3, 3):
|
||||
def get_clock_info(name: str) -> SimpleNamespace: ...
|
||||
def monotonic() -> float: ...
|
||||
def perf_counter() -> float: ...
|
||||
def process_time() -> float: ...
|
||||
if sys.platform != 'win32':
|
||||
def clock_getres(clk_id: int) -> float: ... # Unix only
|
||||
def clock_gettime(clk_id: int) -> float: ... # Unix only
|
||||
def clock_settime(clk_id: int, time: float) -> None: ... # Unix only
|
||||
|
||||
if sys.version_info >= (3, 7):
|
||||
def clock_gettime_ns(clock_id: int) -> int: ...
|
||||
def clock_settime_ns(clock_id: int, time: int) -> int: ...
|
||||
def monotonic_ns() -> int: ...
|
||||
def perf_counter_ns() -> int: ...
|
||||
def process_time_ns() -> int: ...
|
||||
def time_ns() -> int: ...
|
||||
@@ -0,0 +1,27 @@
|
||||
from typing import Any, Callable, ClassVar, Generic, Mapping, TypeVar, Union
|
||||
|
||||
_T = TypeVar('_T')
|
||||
|
||||
class ContextVar(Generic[_T]):
|
||||
def __init__(self, name: str, *, default: _T = ...) -> None: ...
|
||||
@property
|
||||
def name(self) -> str: ...
|
||||
def get(self, default: _T = ...) -> _T: ...
|
||||
def set(self, value: _T) -> Token[_T]: ...
|
||||
def reset(self, token: Token[_T]) -> None: ...
|
||||
|
||||
class Token(Generic[_T]):
|
||||
@property
|
||||
def var(self) -> ContextVar[_T]: ...
|
||||
@property
|
||||
def old_value(self) -> Any: ... # returns either _T or MISSING, but that's hard to express
|
||||
MISSING: ClassVar[object]
|
||||
|
||||
def copy_context() -> Context: ...
|
||||
|
||||
# It doesn't make sense to make this generic, because for most Contexts each ContextVar will have
|
||||
# a different value.
|
||||
class Context(Mapping[ContextVar[Any], Any]):
|
||||
def __init__(self) -> None: ...
|
||||
def run(self, callable: Callable[..., _T], *args: Any, **kwargs: Any) -> _T: ...
|
||||
def copy(self) -> Context: ...
|
||||
@@ -0,0 +1,30 @@
|
||||
from typing import Any, Generic, Optional, TypeVar
|
||||
|
||||
import queue
|
||||
|
||||
_T = TypeVar('_T')
|
||||
|
||||
class Queue(queue.Queue[_T]):
|
||||
# FIXME: `ctx` is a circular dependency and it's not actually optional.
|
||||
# It's marked as such to be able to use the generic Queue in __init__.pyi.
|
||||
def __init__(self, maxsize: int = ..., *, ctx: Any = ...) -> None: ...
|
||||
def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
|
||||
def put(self, obj: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
|
||||
def qsize(self) -> int: ...
|
||||
def empty(self) -> bool: ...
|
||||
def full(self) -> bool: ...
|
||||
def put_nowait(self, item: _T) -> None: ...
|
||||
def get_nowait(self) -> _T: ...
|
||||
def close(self) -> None: ...
|
||||
def join_thread(self) -> None: ...
|
||||
def cancel_join_thread(self) -> None: ...
|
||||
|
||||
class JoinableQueue(Queue[_T]):
|
||||
def task_done(self) -> None: ...
|
||||
def join(self) -> None: ...
|
||||
|
||||
class SimpleQueue(Generic[_T]):
|
||||
def __init__(self, *, ctx: Any = ...) -> None: ...
|
||||
def empty(self) -> bool: ...
|
||||
def get(self) -> _T: ...
|
||||
def put(self, item: _T) -> None: ...
|
||||
+35
@@ -0,0 +1,35 @@
|
||||
from google.protobuf.descriptor import Descriptor
|
||||
from google.protobuf.internal.message_listener import MessageListener
|
||||
from google.protobuf.message import Message
|
||||
from typing import (
|
||||
MutableSequence, Sequence, TypeVar, Generic, Any, Iterator, Iterable,
|
||||
Union, Optional, Callable
|
||||
)
|
||||
|
||||
_T = TypeVar('_T')
|
||||
class BaseContainer(Generic[_T], MutableSequence[_T]):
|
||||
def __init__(self, message_listener: MessageListener) -> None: ...
|
||||
def __len__(self) -> int: ...
|
||||
def __ne__(self, other: object) -> bool: ...
|
||||
def __hash__(self) -> int: ...
|
||||
def __repr__(self) -> str: ...
|
||||
def sort(self, *, key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> None: ...
|
||||
|
||||
class RepeatedScalarFieldContainer(Generic[_T], BaseContainer[_T]):
|
||||
def __init__(self, message_listener: MessageListener, message_descriptor: Descriptor) -> None: ...
|
||||
def MergeFrom(self, other: RepeatedScalarFieldContainer[_T]) -> None: ...
|
||||
|
||||
class RepeatedCompositeFieldContainer(Generic[_T], BaseContainer[_T]):
|
||||
def __init__(self, message_listener: MessageListener, type_checker: Any) -> None: ...
|
||||
def add(self, **kwargs: Any) -> _T: ...
|
||||
def MergeFrom(self, other: RepeatedCompositeFieldContainer[_T]) -> None: ...
|
||||
|
||||
# Classes not yet typed
|
||||
class Mapping(Any):
|
||||
pass
|
||||
class MutableMapping(Mapping):
|
||||
pass
|
||||
class ScalarMap(MutableMapping):
|
||||
pass
|
||||
class MessageMap(MutableMapping):
|
||||
pass
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
class MessageListener(object):
|
||||
def Modified(self) -> None: ...
|
||||
|
||||
class NullMessageListener(MessageListener):
|
||||
def Modified(self) -> None: ...
|
||||
@@ -0,0 +1,24 @@
|
||||
from typing import Any, Optional
|
||||
|
||||
long = int
|
||||
CalledProcessError: Any
|
||||
|
||||
def cpu_count() -> int: ...
|
||||
def fork_processes(num_processes, max_restarts: int = ...) -> Optional[int]: ...
|
||||
def task_id() -> int: ...
|
||||
|
||||
class Subprocess:
|
||||
STREAM: Any = ...
|
||||
io_loop: Any = ...
|
||||
stdin: Any = ...
|
||||
stdout: Any = ...
|
||||
stderr: Any = ...
|
||||
proc: Any = ...
|
||||
returncode: Any = ...
|
||||
def __init__(self, *args, **kwargs) -> None: ...
|
||||
def set_exit_callback(self, callback): ...
|
||||
def wait_for_exit(self, raise_error: bool = ...): ...
|
||||
@classmethod
|
||||
def initialize(cls, io_loop: Optional[Any] = ...): ...
|
||||
@classmethod
|
||||
def uninitialize(cls): ...
|
||||
@@ -0,0 +1,372 @@
|
||||
from typing import Any, Callable, Dict, Generic, List, Optional, Sequence, Mapping, Tuple, Type, TypeVar, Union, overload
|
||||
# `import X as X` is required to make these public
|
||||
from . import exceptions as exceptions
|
||||
from . import filters as filters
|
||||
from . import converters as converters
|
||||
from . import validators as validators
|
||||
|
||||
_T = TypeVar('_T')
|
||||
_C = TypeVar('_C', bound=type)
|
||||
|
||||
_ValidatorType = Callable[[Any, Attribute, _T], Any]
|
||||
_ConverterType = Callable[[Any], _T]
|
||||
_FilterType = Callable[[Attribute, Any], bool]
|
||||
# FIXME: in reality, if multiple validators are passed they must be in a list or tuple,
|
||||
# but those are invariant and so would prevent subtypes of _ValidatorType from working
|
||||
# when passed in a list or tuple.
|
||||
_ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]]
|
||||
|
||||
# _make --
|
||||
|
||||
NOTHING: object
|
||||
|
||||
# NOTE: Factory lies about its return type to make this possible: `x: List[int] = Factory(list)`
|
||||
# Work around mypy issue #4554 by using an overload vs a Union.
|
||||
@overload
|
||||
def Factory(factory: Callable[[], _T], takes_self: bool = ...) -> _T: ...
|
||||
@overload
|
||||
def Factory(factory: Callable[[Any], _T], takes_self: bool = ...) -> _T: ...
|
||||
|
||||
class Attribute(Generic[_T]):
|
||||
name: str
|
||||
default: Optional[_T]
|
||||
validator: Optional[_ValidatorType[_T]]
|
||||
repr: bool
|
||||
cmp: bool
|
||||
hash: Optional[bool]
|
||||
init: bool
|
||||
converter: Optional[_ConverterType[_T]]
|
||||
metadata: Dict[Any, Any]
|
||||
type: Optional[Type[_T]]
|
||||
def __lt__(self, x: Attribute) -> bool: ...
|
||||
def __le__(self, x: Attribute) -> bool: ...
|
||||
def __gt__(self, x: Attribute) -> bool: ...
|
||||
def __ge__(self, x: Attribute) -> bool: ...
|
||||
|
||||
|
||||
# NOTE: We had several choices for the annotation to use for type arg:
|
||||
# 1) Type[_T]
|
||||
# - Pros: works in PyCharm without plugin support
|
||||
# - Cons: produces less informative error in the case of conflicting TypeVars
|
||||
# e.g. `attr.ib(default='bad', type=int)`
|
||||
# 2) Callable[..., _T]
|
||||
# - Pros: more informative errors than #1
|
||||
# - Cons: validator tests results in confusing error.
|
||||
# e.g. `attr.ib(type=int, validator=validate_str)`
|
||||
# 3) type (and do all of the work in the mypy plugin)
|
||||
# - Pros: in mypy, the behavior of type argument is exactly the same as with
|
||||
# annotations.
|
||||
# - Cons: completely disables type inspections in PyCharm when using the
|
||||
# type arg.
|
||||
# We chose option #1 until either PyCharm adds support for attrs, or python 2
|
||||
# reaches EOL.
|
||||
|
||||
# NOTE: If you update these, update `ib` and `attr` below.
|
||||
|
||||
# `attr` lies about its return type to make the following possible:
|
||||
# attr() -> Any
|
||||
# attr(8) -> int
|
||||
# attr(validator=<some callable>) -> Whatever the callable expects.
|
||||
# This makes this type of assignments possible:
|
||||
# x: int = attr(8)
|
||||
|
||||
# This form catches an explicit None or no default and infers the type from the other arguments.
|
||||
@overload
|
||||
def attrib(default: None = ...,
|
||||
validator: Optional[_ValidatorArgType[_T]] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: Optional[_ConverterType[_T]] = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: Optional[Type[_T]] = ...,
|
||||
converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
|
||||
# This form catches an explicit default argument.
|
||||
@overload
|
||||
def attrib(default: _T,
|
||||
validator: Optional[_ValidatorArgType[_T]] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: Optional[_ConverterType[_T]] = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: Optional[Type[_T]] = ...,
|
||||
converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
|
||||
# This form catches explicit None or no default but with no other arguments returns Any.
|
||||
@overload
|
||||
def attrib(default: None = ...,
|
||||
validator: None = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: None = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: None = ...,
|
||||
converter: None = ...) -> Any: ...
|
||||
# This form covers type=non-Type: e.g. forward references (str), Any
|
||||
@overload
|
||||
def attrib(default: Optional[_T] = ...,
|
||||
validator: Optional[_ValidatorArgType[_T]] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: Optional[_ConverterType[_T]] = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: object = ...,
|
||||
converter: Optional[_ConverterType[_T]] = ...) -> Any: ...
|
||||
|
||||
|
||||
# NOTE: If you update these, update `s` and `attributes` below.
|
||||
@overload
|
||||
def attrs(maybe_cls: _C,
|
||||
these: Optional[Dict[str, Any]] = ...,
|
||||
repr_ns: Optional[str] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
slots: bool = ...,
|
||||
frozen: bool = ...,
|
||||
str: bool = ...,
|
||||
auto_attribs: bool = ...) -> _C: ...
|
||||
@overload
|
||||
def attrs(maybe_cls: None = ...,
|
||||
these: Optional[Dict[str, Any]] = ...,
|
||||
repr_ns: Optional[str] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
slots: bool = ...,
|
||||
frozen: bool = ...,
|
||||
str: bool = ...,
|
||||
auto_attribs: bool = ...) -> Callable[[_C], _C]: ...
|
||||
|
||||
|
||||
# TODO: add support for returning NamedTuple from the mypy plugin
|
||||
class _Fields(Tuple[Attribute, ...]):
|
||||
def __getattr__(self, name: str) -> Attribute: ...
|
||||
|
||||
def fields(cls: type) -> _Fields: ...
|
||||
def validate(inst: Any) -> None: ...
|
||||
|
||||
# TODO: add support for returning a proper attrs class from the mypy plugin
|
||||
# we use Any instead of _CountingAttr so that e.g. `make_class('Foo', [attr.ib()])` is valid
|
||||
def make_class(name: str,
|
||||
attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]],
|
||||
bases: Tuple[type, ...] = ...,
|
||||
repr_ns: Optional[str] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
slots: bool = ...,
|
||||
frozen: bool = ...,
|
||||
str: bool = ...,
|
||||
auto_attribs: bool = ...) -> type: ...
|
||||
|
||||
# _funcs --
|
||||
|
||||
# TODO: add support for returning TypedDict from the mypy plugin
|
||||
# FIXME: asdict/astuple do not honor their factory args. waiting on one of these:
|
||||
# https://github.com/python/mypy/issues/4236
|
||||
# https://github.com/python/typing/issues/253
|
||||
def asdict(inst: Any,
|
||||
recurse: bool = ...,
|
||||
filter: Optional[_FilterType] = ...,
|
||||
dict_factory: Type[Mapping[Any, Any]] = ...,
|
||||
retain_collection_types: bool = ...) -> Dict[str, Any]: ...
|
||||
# TODO: add support for returning NamedTuple from the mypy plugin
|
||||
def astuple(inst: Any,
|
||||
recurse: bool = ...,
|
||||
filter: Optional[_FilterType] = ...,
|
||||
tuple_factory: Type[Sequence] = ...,
|
||||
retain_collection_types: bool = ...) -> Tuple[Any, ...]: ...
|
||||
def has(cls: type) -> bool: ...
|
||||
def assoc(inst: _T, **changes: Any) -> _T: ...
|
||||
def evolve(inst: _T, **changes: Any) -> _T: ...
|
||||
|
||||
# _config --
|
||||
|
||||
def set_run_validators(run: bool) -> None: ...
|
||||
def get_run_validators() -> bool: ...
|
||||
|
||||
|
||||
# aliases --
|
||||
|
||||
# FIXME: there is a bug in PyCharm with creating aliases to overloads.
|
||||
# Use the aliases instead of the duplicated overloads when the bug is fixed:
|
||||
# https://youtrack.jetbrains.com/issue/PY-27788
|
||||
|
||||
# s = attributes = attrs
|
||||
# ib = attr = attrib
|
||||
# dataclass = attrs # Technically, partial(attrs, auto_attribs=True) ;)
|
||||
|
||||
|
||||
@overload
|
||||
def ib(default: None = ...,
|
||||
validator: Optional[_ValidatorArgType[_T]] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: Optional[_ConverterType[_T]] = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: Optional[Type[_T]] = ...,
|
||||
converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
|
||||
@overload
|
||||
def ib(default: _T,
|
||||
validator: Optional[_ValidatorArgType[_T]] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: Optional[_ConverterType[_T]] = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: Optional[Type[_T]] = ...,
|
||||
converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
|
||||
@overload
|
||||
def ib(default: None = ...,
|
||||
validator: None = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: None = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: None = ...,
|
||||
converter: None = ...) -> Any: ...
|
||||
@overload
|
||||
def ib(default: Optional[_T] = ...,
|
||||
validator: Optional[_ValidatorArgType[_T]] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: Optional[_ConverterType[_T]] = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: object = ...,
|
||||
converter: Optional[_ConverterType[_T]] = ...) -> Any: ...
|
||||
|
||||
@overload
|
||||
def attr(default: None = ...,
|
||||
validator: Optional[_ValidatorArgType[_T]] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: Optional[_ConverterType[_T]] = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: Optional[Type[_T]] = ...,
|
||||
converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
|
||||
@overload
|
||||
def attr(default: _T,
|
||||
validator: Optional[_ValidatorArgType[_T]] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: Optional[_ConverterType[_T]] = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: Optional[Type[_T]] = ...,
|
||||
converter: Optional[_ConverterType[_T]] = ...) -> _T: ...
|
||||
@overload
|
||||
def attr(default: None = ...,
|
||||
validator: None = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: None = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: None = ...,
|
||||
converter: None = ...) -> Any: ...
|
||||
@overload
|
||||
def attr(default: Optional[_T] = ...,
|
||||
validator: Optional[_ValidatorArgType[_T]] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
convert: Optional[_ConverterType[_T]] = ...,
|
||||
metadata: Optional[Mapping[Any, Any]] = ...,
|
||||
type: object = ...,
|
||||
converter: Optional[_ConverterType[_T]] = ...) -> Any: ...
|
||||
|
||||
@overload
|
||||
def attributes(maybe_cls: _C,
|
||||
these: Optional[Dict[str, Any]] = ...,
|
||||
repr_ns: Optional[str] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
slots: bool = ...,
|
||||
frozen: bool = ...,
|
||||
str: bool = ...,
|
||||
auto_attribs: bool = ...) -> _C: ...
|
||||
@overload
|
||||
def attributes(maybe_cls: None = ...,
|
||||
these: Optional[Dict[str, Any]] = ...,
|
||||
repr_ns: Optional[str] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
slots: bool = ...,
|
||||
frozen: bool = ...,
|
||||
str: bool = ...,
|
||||
auto_attribs: bool = ...) -> Callable[[_C], _C]: ...
|
||||
|
||||
@overload
|
||||
def s(maybe_cls: _C,
|
||||
these: Optional[Dict[str, Any]] = ...,
|
||||
repr_ns: Optional[str] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
slots: bool = ...,
|
||||
frozen: bool = ...,
|
||||
str: bool = ...,
|
||||
auto_attribs: bool = ...) -> _C: ...
|
||||
@overload
|
||||
def s(maybe_cls: None = ...,
|
||||
these: Optional[Dict[str, Any]] = ...,
|
||||
repr_ns: Optional[str] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
slots: bool = ...,
|
||||
frozen: bool = ...,
|
||||
str: bool = ...,
|
||||
auto_attribs: bool = ...) -> Callable[[_C], _C]: ...
|
||||
|
||||
# same as above, but with auto_attrib=True
|
||||
@overload
|
||||
def dataclass(maybe_cls: _C,
|
||||
these: Optional[Dict[str, Any]] = ...,
|
||||
repr_ns: Optional[str] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
slots: bool = ...,
|
||||
frozen: bool = ...,
|
||||
str: bool = ...) -> _C: ...
|
||||
@overload
|
||||
def dataclass(maybe_cls: None = ...,
|
||||
these: Optional[Dict[str, Any]] = ...,
|
||||
repr_ns: Optional[str] = ...,
|
||||
repr: bool = ...,
|
||||
cmp: bool = ...,
|
||||
hash: Optional[bool] = ...,
|
||||
init: bool = ...,
|
||||
slots: bool = ...,
|
||||
frozen: bool = ...,
|
||||
str: bool = ...) -> Callable[[_C], _C]: ...
|
||||
@@ -0,0 +1,6 @@
|
||||
from typing import TypeVar, Optional
|
||||
from . import _ConverterType
|
||||
|
||||
_T = TypeVar('_T')
|
||||
|
||||
def optional(converter: _ConverterType[_T]) -> _ConverterType[Optional[_T]]: ...
|
||||
@@ -0,0 +1,6 @@
|
||||
class FrozenInstanceError(AttributeError):
|
||||
msg: str = ...
|
||||
class AttrsAttributeNotFoundError(ValueError): ...
|
||||
class NotAnAttrsClassError(ValueError): ...
|
||||
class DefaultAlreadySetError(RuntimeError): ...
|
||||
class UnannotatedAttributeError(RuntimeError): ...
|
||||
@@ -0,0 +1,5 @@
|
||||
from typing import Union
|
||||
from . import Attribute, _FilterType
|
||||
|
||||
def include(*what: Union[type, Attribute]) -> _FilterType: ...
|
||||
def exclude(*what: Union[type, Attribute]) -> _FilterType: ...
|
||||
@@ -0,0 +1,10 @@
|
||||
from typing import Container, List, Union, TypeVar, Type, Any, Optional, Tuple
|
||||
from . import _ValidatorType
|
||||
|
||||
_T = TypeVar('_T')
|
||||
|
||||
def instance_of(type: Union[Tuple[Type[_T], ...], Type[_T]]) -> _ValidatorType[_T]: ...
|
||||
def provides(interface: Any) -> _ValidatorType[Any]: ...
|
||||
def optional(validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]]) -> _ValidatorType[Optional[_T]]: ...
|
||||
def in_(options: Container[_T]) -> _ValidatorType[_T]: ...
|
||||
def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...
|
||||
@@ -0,0 +1,21 @@
|
||||
# Stub for termcolor: https://pypi.python.org/pypi/termcolor
|
||||
from typing import Any, Iterable, Optional, Text
|
||||
|
||||
|
||||
def colored(
|
||||
text: Text,
|
||||
color: Optional[Text] = ...,
|
||||
on_color: Optional[Text] = ...,
|
||||
attrs: Optional[Iterable[Text]] = ...,
|
||||
) -> Text:
|
||||
...
|
||||
|
||||
|
||||
def cprint(
|
||||
text: Text,
|
||||
color: Optional[Text] = ...,
|
||||
on_color: Optional[Text] = ...,
|
||||
attrs: Optional[Iterable[Text]] = ...,
|
||||
**kwargs: Any,
|
||||
) -> None:
|
||||
...
|
||||
Reference in New Issue
Block a user