mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-27 10:03:11 +07:00
Enable pyi-stubs for several modules and packages
_dummy_threading, _types, _warnings, antigravity, asyncore, cgi, doctest, faulthandler, filecmp, gettext, imghdr, importlib, locale, mimetypes, parser, pathlib2, pstats, pydoc, select, selectors, statistics, struct, tarfile, termios, textwrap, this, venv, warnings, winsound, zipfile GitOrigin-RevId: c8711b1ea14eb6965141eff91de79d39695c07d2
This commit is contained in:
Semyon Proshev
committed by
intellij-monorepo-bot
intellij-monorepo-bot
parent
e6e76c3238
commit
a38d011cae
@@ -0,0 +1,41 @@
|
||||
from typing import Any, Container, Dict, IO, List, Optional, Sequence, Type, Union
|
||||
|
||||
def bindtextdomain(domain: str, localedir: str = ...) -> str: ...
|
||||
def bind_textdomain_codeset(domain: str, codeset: str = ...) -> str: ...
|
||||
def textdomain(domain: str = ...) -> str: ...
|
||||
def gettext(message: str) -> str: ...
|
||||
def lgettext(message: str) -> str: ...
|
||||
def dgettext(domain: str, message: str) -> str: ...
|
||||
def ldgettext(domain: str, message: str) -> str: ...
|
||||
def ngettext(singular: str, plural: str, n: int) -> str: ...
|
||||
def lngettext(singular: str, plural: str, n: int) -> str: ...
|
||||
def dngettext(domain: str, singular: str, plural: str, n: int) -> str: ...
|
||||
def ldngettext(domain: str, singular: str, plural: str, n: int) -> str: ...
|
||||
|
||||
class NullTranslations(object):
|
||||
def __init__(self, fp: IO[str] = ...) -> None: ...
|
||||
def _parse(self, fp: IO[str]) -> None: ...
|
||||
def add_fallback(self, fallback: NullTranslations) -> None: ...
|
||||
def gettext(self, message: str) -> str: ...
|
||||
def lgettext(self, message: str) -> str: ...
|
||||
def ugettext(self, message: Union[str, unicode]) -> unicode: ...
|
||||
def ngettext(self, singular: str, plural: str, n: int) -> str: ...
|
||||
def lngettext(self, singular: str, plural: str, n: int) -> str: ...
|
||||
def ungettext(self, singular: Union[str, unicode], plural: Union[str, unicode], n: int) -> unicode: ...
|
||||
def info(self) -> Dict[str, str]: ...
|
||||
def charset(self) -> Optional[str]: ...
|
||||
def output_charset(self) -> Optional[str]: ...
|
||||
def set_output_charset(self, charset: Optional[str]) -> None: ...
|
||||
def install(self, unicode: bool = ..., names: Container[str] = ...) -> None: ...
|
||||
|
||||
class GNUTranslations(NullTranslations):
|
||||
LE_MAGIC: int
|
||||
BE_MAGIC: int
|
||||
|
||||
def find(domain: str, localedir: Optional[str] = ..., languages: Optional[Sequence[str]] = ...,
|
||||
all: Any = ...) -> Optional[Union[str, List[str]]]: ...
|
||||
|
||||
def translation(domain: str, localedir: Optional[str] = ..., languages: Optional[Sequence[str]] = ...,
|
||||
class_: Optional[Type[NullTranslations]] = ..., fallback: bool = ..., codeset: Optional[str] = ...) -> NullTranslations: ...
|
||||
def install(domain: str, localedir: Optional[str] = ..., unicode: bool = ..., codeset: Optional[str] = ...,
|
||||
names: Container[str] = ...) -> None: ...
|
||||
@@ -0,0 +1,4 @@
|
||||
import types
|
||||
from typing import Optional, Text
|
||||
|
||||
def import_module(name: Text, package: Optional[Text] = ...) -> types.ModuleType: ...
|
||||
@@ -0,0 +1,61 @@
|
||||
from typing import AnyStr, List, Dict, Pattern
|
||||
|
||||
class TextWrapper(object):
|
||||
width: int = ...
|
||||
initial_indent: str = ...
|
||||
subsequent_indent: str = ...
|
||||
expand_tabs: bool = ...
|
||||
replace_whitespace: bool = ...
|
||||
fix_sentence_endings: bool = ...
|
||||
drop_whitespace: bool = ...
|
||||
break_long_words: bool = ...
|
||||
break_on_hyphens: bool = ...
|
||||
|
||||
# Attributes not present in documentation
|
||||
sentence_end_re: Pattern[str] = ...
|
||||
wordsep_re: Pattern[str] = ...
|
||||
wordsep_simple_re: Pattern[str] = ...
|
||||
whitespace_trans: str = ...
|
||||
unicode_whitespace_trans: Dict[int, int] = ...
|
||||
uspace: int = ...
|
||||
x: int = ...
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
width: int = ...,
|
||||
initial_indent: str = ...,
|
||||
subsequent_indent: str = ...,
|
||||
expand_tabs: bool = ...,
|
||||
replace_whitespace: bool = ...,
|
||||
fix_sentence_endings: bool = ...,
|
||||
break_long_words: bool = ...,
|
||||
drop_whitespace: bool = ...,
|
||||
break_on_hyphens: bool = ...) -> None:
|
||||
...
|
||||
|
||||
def wrap(self, text: AnyStr) -> List[AnyStr]: ...
|
||||
def fill(self, text: AnyStr) -> AnyStr: ...
|
||||
|
||||
def wrap(text: AnyStr,
|
||||
width: int = ...,
|
||||
initial_indent: AnyStr = ...,
|
||||
subsequent_indent: AnyStr = ...,
|
||||
expand_tabs: bool = ...,
|
||||
replace_whitespace: bool = ...,
|
||||
fix_sentence_endings: bool = ...,
|
||||
break_long_words: bool = ...,
|
||||
drop_whitespace: bool = ...,
|
||||
break_on_hyphens: bool = ...) -> List[AnyStr]: ...
|
||||
|
||||
def fill(text: AnyStr,
|
||||
width: int = ...,
|
||||
initial_indent: AnyStr = ...,
|
||||
subsequent_indent: AnyStr = ...,
|
||||
expand_tabs: bool = ...,
|
||||
replace_whitespace: bool = ...,
|
||||
fix_sentence_endings: bool = ...,
|
||||
break_long_words: bool = ...,
|
||||
drop_whitespace: bool = ...,
|
||||
break_on_hyphens: bool = ...) -> AnyStr: ...
|
||||
|
||||
def dedent(text: AnyStr) -> AnyStr: ...
|
||||
@@ -0,0 +1,197 @@
|
||||
|
||||
from typing import (
|
||||
Any, Callable, Iterable, List, Mapping, Optional, Tuple, Type, Union,
|
||||
TypeVar,
|
||||
)
|
||||
from types import FrameType, TracebackType
|
||||
import sys
|
||||
|
||||
# TODO recursive type
|
||||
_TF = Callable[[FrameType, str, Any], Optional[Callable[..., Any]]]
|
||||
|
||||
_PF = Callable[[FrameType, str, Any], None]
|
||||
_T = TypeVar('_T')
|
||||
|
||||
|
||||
__all__: List[str]
|
||||
|
||||
def active_count() -> int: ...
|
||||
if sys.version_info < (3,):
|
||||
def activeCount() -> int: ...
|
||||
|
||||
def current_thread() -> Thread: ...
|
||||
def currentThread() -> Thread: ...
|
||||
|
||||
if sys.version_info >= (3,):
|
||||
def get_ident() -> int: ...
|
||||
|
||||
def enumerate() -> List[Thread]: ...
|
||||
|
||||
if sys.version_info >= (3, 4):
|
||||
def main_thread() -> Thread: ...
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
from _thread import get_native_id as get_native_id
|
||||
|
||||
def settrace(func: _TF) -> None: ...
|
||||
def setprofile(func: Optional[_PF]) -> None: ...
|
||||
def stack_size(size: int = ...) -> int: ...
|
||||
|
||||
if sys.version_info >= (3,):
|
||||
TIMEOUT_MAX: float
|
||||
|
||||
class ThreadError(Exception): ...
|
||||
|
||||
|
||||
class local(object):
|
||||
def __getattribute__(self, name: str) -> Any: ...
|
||||
def __setattr__(self, name: str, value: Any) -> None: ...
|
||||
def __delattr__(self, name: str) -> None: ...
|
||||
|
||||
|
||||
class Thread:
|
||||
name: str
|
||||
ident: Optional[int]
|
||||
daemon: bool
|
||||
if sys.version_info >= (3,):
|
||||
def __init__(self, group: None = ...,
|
||||
target: Optional[Callable[..., Any]] = ...,
|
||||
name: Optional[str] = ...,
|
||||
args: Iterable[Any] = ...,
|
||||
kwargs: Mapping[str, Any] = ...,
|
||||
*, daemon: Optional[bool] = ...) -> None: ...
|
||||
else:
|
||||
def __init__(self, group: None = ...,
|
||||
target: Optional[Callable[..., Any]] = ...,
|
||||
name: Optional[str] = ...,
|
||||
args: Iterable[Any] = ...,
|
||||
kwargs: Mapping[str, Any] = ...) -> None: ...
|
||||
def start(self) -> None: ...
|
||||
def run(self) -> None: ...
|
||||
def join(self, timeout: Optional[float] = ...) -> None: ...
|
||||
def getName(self) -> str: ...
|
||||
def setName(self, name: str) -> None: ...
|
||||
if sys.version_info >= (3, 8):
|
||||
@property
|
||||
def native_id(self) -> Optional[int]: ... # only available on some platforms
|
||||
def is_alive(self) -> bool: ...
|
||||
def isAlive(self) -> bool: ...
|
||||
def isDaemon(self) -> bool: ...
|
||||
def setDaemon(self, daemonic: bool) -> None: ...
|
||||
|
||||
|
||||
class _DummyThread(Thread): ...
|
||||
|
||||
|
||||
class Lock:
|
||||
def __init__(self) -> None: ...
|
||||
def __enter__(self) -> bool: ...
|
||||
def __exit__(self, exc_type: Optional[Type[BaseException]],
|
||||
exc_val: Optional[BaseException],
|
||||
exc_tb: Optional[TracebackType]) -> Optional[bool]: ...
|
||||
if sys.version_info >= (3,):
|
||||
def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
|
||||
else:
|
||||
def acquire(self, blocking: bool = ...) -> bool: ...
|
||||
def release(self) -> None: ...
|
||||
def locked(self) -> bool: ...
|
||||
|
||||
|
||||
class _RLock:
|
||||
def __init__(self) -> None: ...
|
||||
def __enter__(self) -> bool: ...
|
||||
def __exit__(self, exc_type: Optional[Type[BaseException]],
|
||||
exc_val: Optional[BaseException],
|
||||
exc_tb: Optional[TracebackType]) -> Optional[bool]: ...
|
||||
if sys.version_info >= (3,):
|
||||
def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
|
||||
else:
|
||||
def acquire(self, blocking: bool = ...) -> bool: ...
|
||||
def release(self) -> None: ...
|
||||
|
||||
|
||||
RLock = _RLock
|
||||
|
||||
|
||||
class Condition:
|
||||
def __init__(self, lock: Union[Lock, _RLock, None] = ...) -> None: ...
|
||||
def __enter__(self) -> bool: ...
|
||||
def __exit__(self, exc_type: Optional[Type[BaseException]],
|
||||
exc_val: Optional[BaseException],
|
||||
exc_tb: Optional[TracebackType]) -> Optional[bool]: ...
|
||||
if sys.version_info >= (3,):
|
||||
def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
|
||||
else:
|
||||
def acquire(self, blocking: bool = ...) -> bool: ...
|
||||
def release(self) -> None: ...
|
||||
def wait(self, timeout: Optional[float] = ...) -> bool: ...
|
||||
if sys.version_info >= (3,):
|
||||
def wait_for(self, predicate: Callable[[], _T],
|
||||
timeout: Optional[float] = ...) -> _T: ...
|
||||
def notify(self, n: int = ...) -> None: ...
|
||||
def notify_all(self) -> None: ...
|
||||
def notifyAll(self) -> None: ...
|
||||
|
||||
|
||||
class Semaphore:
|
||||
def __init__(self, value: int = ...) -> None: ...
|
||||
def __enter__(self) -> bool: ...
|
||||
def __exit__(self, exc_type: Optional[Type[BaseException]],
|
||||
exc_val: Optional[BaseException],
|
||||
exc_tb: Optional[TracebackType]) -> Optional[bool]: ...
|
||||
if sys.version_info >= (3,):
|
||||
def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
|
||||
else:
|
||||
def acquire(self, blocking: bool = ...) -> bool: ...
|
||||
def release(self) -> None: ...
|
||||
|
||||
class BoundedSemaphore:
|
||||
def __init__(self, value: int = ...) -> None: ...
|
||||
def __enter__(self) -> bool: ...
|
||||
def __exit__(self, exc_type: Optional[Type[BaseException]],
|
||||
exc_val: Optional[BaseException],
|
||||
exc_tb: Optional[TracebackType]) -> Optional[bool]: ...
|
||||
if sys.version_info >= (3,):
|
||||
def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
|
||||
else:
|
||||
def acquire(self, blocking: bool = ...) -> bool: ...
|
||||
def release(self) -> None: ...
|
||||
|
||||
|
||||
class Event:
|
||||
def __init__(self) -> None: ...
|
||||
def is_set(self) -> bool: ...
|
||||
if sys.version_info < (3,):
|
||||
def isSet(self) -> bool: ...
|
||||
def set(self) -> None: ...
|
||||
def clear(self) -> None: ...
|
||||
def wait(self, timeout: Optional[float] = ...) -> bool: ...
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
from _thread import _ExceptHookArgs as ExceptHookArgs, ExceptHookArgs as _ExceptHookArgs # don't ask
|
||||
excepthook: Callable[[_ExceptHookArgs], Any]
|
||||
|
||||
class Timer(Thread):
|
||||
if sys.version_info >= (3,):
|
||||
def __init__(self, interval: float, function: Callable[..., Any],
|
||||
args: Optional[Iterable[Any]] = ...,
|
||||
kwargs: Optional[Mapping[str, Any]] = ...) -> None: ...
|
||||
else:
|
||||
def __init__(self, interval: float, function: Callable[..., Any],
|
||||
args: Iterable[Any] = ...,
|
||||
kwargs: Mapping[str, Any] = ...) -> None: ...
|
||||
def cancel(self) -> None: ...
|
||||
|
||||
|
||||
if sys.version_info >= (3,):
|
||||
class Barrier:
|
||||
parties: int
|
||||
n_waiting: int
|
||||
broken: bool
|
||||
def __init__(self, parties: int, action: Optional[Callable[[], None]] = ...,
|
||||
timeout: Optional[float] = ...) -> None: ...
|
||||
def wait(self, timeout: Optional[float] = ...) -> int: ...
|
||||
def reset(self) -> None: ...
|
||||
def abort(self) -> None: ...
|
||||
|
||||
class BrokenBarrierError(RuntimeError): ...
|
||||
@@ -0,0 +1,10 @@
|
||||
# These types are for typeshed-only objects that don't exist at runtime
|
||||
|
||||
from typing import type_check_only, Protocol, Union
|
||||
|
||||
@type_check_only
|
||||
class HasFileno(Protocol):
|
||||
def fileno(self) -> int: ...
|
||||
|
||||
FileDescriptor = int
|
||||
FileDescriptorLike = Union[int, HasFileno]
|
||||
@@ -0,0 +1,64 @@
|
||||
import sys
|
||||
from typing import Any, Dict, List, Optional, Tuple, Type, Union, overload
|
||||
|
||||
if sys.version_info >= (3, 0):
|
||||
_defaultaction: str
|
||||
_onceregistry: Dict[Any, Any]
|
||||
else:
|
||||
default_action: str
|
||||
once_registry: Dict[Any, Any]
|
||||
|
||||
filters: List[Tuple[Any, ...]]
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
@overload
|
||||
def warn(message: str, category: Optional[Type[Warning]] = ..., stacklevel: int = ..., source: Optional[Any] = ...) -> None: ...
|
||||
@overload
|
||||
def warn(message: Warning, category: Any = ..., stacklevel: int = ..., source: Optional[Any] = ...) -> None: ...
|
||||
@overload
|
||||
def warn_explicit(
|
||||
message: str,
|
||||
category: Type[Warning],
|
||||
filename: str,
|
||||
lineno: int,
|
||||
module: Optional[str] = ...,
|
||||
registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ...,
|
||||
module_globals: Optional[Dict[str, Any]] = ...,
|
||||
source: Optional[Any] = ...,
|
||||
) -> None: ...
|
||||
@overload
|
||||
def warn_explicit(
|
||||
message: Warning,
|
||||
category: Any,
|
||||
filename: str,
|
||||
lineno: int,
|
||||
module: Optional[str] = ...,
|
||||
registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ...,
|
||||
module_globals: Optional[Dict[str, Any]] = ...,
|
||||
source: Optional[Any] = ...,
|
||||
) -> None: ...
|
||||
else:
|
||||
@overload
|
||||
def warn(message: str, category: Optional[Type[Warning]] = ..., stacklevel: int = ...) -> None: ...
|
||||
@overload
|
||||
def warn(message: Warning, category: Any = ..., stacklevel: int = ...) -> None: ...
|
||||
@overload
|
||||
def warn_explicit(
|
||||
message: str,
|
||||
category: Type[Warning],
|
||||
filename: str,
|
||||
lineno: int,
|
||||
module: Optional[str] = ...,
|
||||
registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ...,
|
||||
module_globals: Optional[Dict[str, Any]] = ...,
|
||||
) -> None: ...
|
||||
@overload
|
||||
def warn_explicit(
|
||||
message: Warning,
|
||||
category: Any,
|
||||
filename: str,
|
||||
lineno: int,
|
||||
module: Optional[str] = ...,
|
||||
registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ...,
|
||||
module_globals: Optional[Dict[str, Any]] = ...,
|
||||
) -> None: ...
|
||||
@@ -0,0 +1,5 @@
|
||||
|
||||
import sys
|
||||
|
||||
if sys.version_info >= (3, 0):
|
||||
def geohash(latitude: float, longitude: float, datedow: bytes) -> None: ...
|
||||
@@ -0,0 +1,146 @@
|
||||
from typing import Tuple, Union, Optional, Any, Dict, overload
|
||||
|
||||
import os
|
||||
import select
|
||||
import sys
|
||||
import time
|
||||
import warnings
|
||||
from socket import SocketType
|
||||
from typing import Optional
|
||||
from _types import FileDescriptorLike
|
||||
|
||||
from errno import (EALREADY, EINPROGRESS, EWOULDBLOCK, ECONNRESET, EINVAL,
|
||||
ENOTCONN, ESHUTDOWN, EINTR, EISCONN, EBADF, ECONNABORTED,
|
||||
EPIPE, EAGAIN, errorcode)
|
||||
|
||||
# cyclic dependence with asynchat
|
||||
_maptype = Dict[int, Any]
|
||||
|
||||
socket_map: _maptype = ... # Undocumented
|
||||
|
||||
class ExitNow(Exception): ...
|
||||
|
||||
def read(obj: Any) -> None: ...
|
||||
def write(obj: Any) -> None: ...
|
||||
def readwrite(obj: Any, flags: int) -> None: ...
|
||||
def poll(timeout: float = ..., map: Optional[_maptype] = ...) -> None: ...
|
||||
def poll2(timeout: float = ..., map: Optional[_maptype] = ...) -> None: ...
|
||||
|
||||
poll3 = poll2
|
||||
|
||||
def loop(timeout: float = ..., use_poll: bool = ..., map: Optional[_maptype] = ..., count: Optional[int] = ...) -> None: ...
|
||||
|
||||
|
||||
# Not really subclass of socket.socket; it's only delegation.
|
||||
# It is not covariant to it.
|
||||
class dispatcher:
|
||||
|
||||
debug: bool
|
||||
connected: bool
|
||||
accepting: bool
|
||||
connecting: bool
|
||||
closing: bool
|
||||
ignore_log_types: frozenset[str]
|
||||
socket: Optional[SocketType]
|
||||
|
||||
def __init__(self, sock: Optional[SocketType] = ..., map: Optional[_maptype] = ...) -> None: ...
|
||||
def add_channel(self, map: Optional[_maptype] = ...) -> None: ...
|
||||
def del_channel(self, map: Optional[_maptype] = ...) -> None: ...
|
||||
def create_socket(self, family: int = ..., type: int = ...) -> None: ...
|
||||
def set_socket(self, sock: SocketType, map: Optional[_maptype] = ...) -> None: ...
|
||||
def set_reuse_addr(self) -> None: ...
|
||||
def readable(self) -> bool: ...
|
||||
def writable(self) -> bool: ...
|
||||
def listen(self, num: int) -> None: ...
|
||||
def bind(self, addr: Union[Tuple[Any, ...], str]) -> None: ...
|
||||
def connect(self, address: Union[Tuple[Any, ...], str]) -> None: ...
|
||||
def accept(self) -> Optional[Tuple[SocketType, Any]]: ...
|
||||
def send(self, data: bytes) -> int: ...
|
||||
def recv(self, buffer_size: int) -> bytes: ...
|
||||
def close(self) -> None: ...
|
||||
|
||||
def log(self, message: Any) -> None: ...
|
||||
def log_info(self, message: Any, type: str = ...) -> None: ...
|
||||
def handle_read_event(self) -> None: ...
|
||||
def handle_connect_event(self) -> None: ...
|
||||
def handle_write_event(self) -> None: ...
|
||||
def handle_expt_event(self) -> None: ...
|
||||
def handle_error(self) -> None: ...
|
||||
def handle_expt(self) -> None: ...
|
||||
def handle_read(self) -> None: ...
|
||||
def handle_write(self) -> None: ...
|
||||
def handle_connect(self) -> None: ...
|
||||
def handle_accept(self) -> None: ...
|
||||
def handle_close(self) -> None: ...
|
||||
|
||||
if sys.version_info < (3, 5):
|
||||
# Historically, some methods were "imported" from `self.socket` by
|
||||
# means of `__getattr__`. This was long deprecated, and as of Python
|
||||
# 3.5 has been removed; simply call the relevant methods directly on
|
||||
# self.socket if necessary.
|
||||
|
||||
def detach(self) -> int: ...
|
||||
def fileno(self) -> int: ...
|
||||
|
||||
# return value is an address
|
||||
def getpeername(self) -> Any: ...
|
||||
def getsockname(self) -> Any: ...
|
||||
|
||||
@overload
|
||||
def getsockopt(self, level: int, optname: int, buflen: None = ...) -> int: ...
|
||||
@overload
|
||||
def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
|
||||
|
||||
def gettimeout(self) -> float: ...
|
||||
def ioctl(self, control: object,
|
||||
option: Tuple[int, int, int]) -> None: ...
|
||||
# TODO the return value may be BinaryIO or TextIO, depending on mode
|
||||
def makefile(self, mode: str = ..., buffering: int = ...,
|
||||
encoding: str = ..., errors: str = ...,
|
||||
newline: str = ...) -> Any:
|
||||
...
|
||||
|
||||
# return type is an address
|
||||
def recvfrom(self, bufsize: int, flags: int = ...) -> Any: ...
|
||||
def recvfrom_into(self, buffer: bytes, nbytes: int, flags: int = ...) -> Any: ...
|
||||
def recv_into(self, buffer: bytes, nbytes: int, flags: int = ...) -> Any: ...
|
||||
def sendall(self, data: bytes, flags: int = ...) -> None: ...
|
||||
def sendto(self, data: bytes, address: Union[Tuple[str, int], str], flags: int = ...) -> int: ...
|
||||
def setblocking(self, flag: bool) -> None: ...
|
||||
def settimeout(self, value: Union[float, None]) -> None: ...
|
||||
def setsockopt(self, level: int, optname: int, value: Union[int, bytes]) -> None: ...
|
||||
def shutdown(self, how: int) -> None: ...
|
||||
|
||||
class dispatcher_with_send(dispatcher):
|
||||
def __init__(self, sock: SocketType = ..., map: Optional[_maptype] = ...) -> None: ...
|
||||
def initiate_send(self) -> None: ...
|
||||
def handle_write(self) -> None: ...
|
||||
# incompatible signature:
|
||||
# def send(self, data: bytes) -> Optional[int]: ...
|
||||
|
||||
def compact_traceback() -> Tuple[Tuple[str, str, str], type, type, str]: ...
|
||||
def close_all(map: Optional[_maptype] = ..., ignore_all: bool = ...) -> None: ...
|
||||
|
||||
# if os.name == 'posix':
|
||||
# import fcntl
|
||||
class file_wrapper:
|
||||
fd: int
|
||||
|
||||
def __init__(self, fd: int) -> None: ...
|
||||
def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
|
||||
def send(self, data: bytes, flags: int = ...) -> int: ...
|
||||
|
||||
@overload
|
||||
def getsockopt(self, level: int, optname: int, buflen: None = ...) -> int: ...
|
||||
@overload
|
||||
def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
|
||||
|
||||
def read(self, bufsize: int, flags: int = ...) -> bytes: ...
|
||||
def write(self, data: bytes, flags: int = ...) -> int: ...
|
||||
|
||||
def close(self) -> None: ...
|
||||
def fileno(self) -> int: ...
|
||||
|
||||
class file_dispatcher(dispatcher):
|
||||
def __init__(self, fd: FileDescriptorLike, map: Optional[_maptype] = ...) -> None: ...
|
||||
def set_file(self, fd: int) -> None: ...
|
||||
@@ -0,0 +1,126 @@
|
||||
import sys
|
||||
from typing import Any, AnyStr, Dict, IO, Iterable, List, Mapping, Optional, Tuple, TypeVar, Union
|
||||
|
||||
_T = TypeVar('_T', bound=FieldStorage)
|
||||
|
||||
def parse(fp: Optional[IO[Any]] = ..., environ: Mapping[str, str] = ...,
|
||||
keep_blank_values: bool = ..., strict_parsing: bool = ...) -> Dict[str, List[str]]: ...
|
||||
if sys.version_info < (3, 8):
|
||||
def parse_qs(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ...) -> Dict[str, List[str]]: ...
|
||||
def parse_qsl(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ...) -> Dict[str, List[str]]: ...
|
||||
if sys.version_info >= (3, 7):
|
||||
def parse_multipart(fp: IO[Any], pdict: Mapping[str, bytes], encoding: str = ..., errors: str = ...) -> Dict[str, List[Any]]: ...
|
||||
else:
|
||||
def parse_multipart(fp: IO[Any], pdict: Mapping[str, bytes]) -> Dict[str, List[bytes]]: ...
|
||||
def parse_header(line: str) -> Tuple[str, Dict[str, str]]: ...
|
||||
def test(environ: Mapping[str, str] = ...) -> None: ...
|
||||
def print_environ(environ: Mapping[str, str] = ...) -> None: ...
|
||||
def print_form(form: Dict[str, Any]) -> None: ...
|
||||
def print_directory() -> None: ...
|
||||
def print_environ_usage() -> None: ...
|
||||
if sys.version_info < (3,):
|
||||
def escape(s: AnyStr, quote: bool = ...) -> AnyStr: ...
|
||||
elif sys.version_info < (3, 8):
|
||||
def escape(s: str, quote: Optional[bool] = ...) -> str: ...
|
||||
|
||||
class MiniFieldStorage:
|
||||
# The first five "Any" attributes here are always None, but mypy doesn't support that
|
||||
filename: Any
|
||||
list: Any
|
||||
type: Any
|
||||
file: Optional[IO[bytes]]
|
||||
type_options: Dict[Any, Any]
|
||||
disposition: Any
|
||||
disposition_options: Dict[Any, Any]
|
||||
headers: Dict[Any, Any]
|
||||
name: Any
|
||||
value: Any
|
||||
|
||||
def __init__(self, name: Any, value: Any) -> None: ...
|
||||
def __repr__(self) -> str: ...
|
||||
|
||||
|
||||
class FieldStorage(object):
|
||||
FieldStorageClass: Optional[type]
|
||||
keep_blank_values: int
|
||||
strict_parsing: int
|
||||
qs_on_post: Optional[str]
|
||||
headers: Mapping[str, str]
|
||||
fp: IO[bytes]
|
||||
encoding: str
|
||||
errors: str
|
||||
outerboundary: bytes
|
||||
bytes_read: int
|
||||
limit: Optional[int]
|
||||
disposition: str
|
||||
disposition_options: Dict[str, str]
|
||||
filename: Optional[str]
|
||||
file: Optional[IO[bytes]]
|
||||
type: str
|
||||
type_options: Dict[str, str]
|
||||
innerboundary: bytes
|
||||
length: int
|
||||
done: int
|
||||
list: Optional[List[Any]]
|
||||
value: Union[None, bytes, List[Any]]
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
def __init__(self, fp: Optional[IO[Any]] = ..., headers: Optional[Mapping[str, str]] = ..., outerboundary: bytes = ...,
|
||||
environ: Mapping[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ...,
|
||||
limit: Optional[int] = ..., encoding: str = ..., errors: str = ..., max_num_fields: Optional[int] = ...) -> None: ...
|
||||
elif sys.version_info >= (3, 0):
|
||||
def __init__(self, fp: Optional[IO[Any]] = ..., headers: Optional[Mapping[str, str]] = ..., outerboundary: bytes = ...,
|
||||
environ: Mapping[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ...,
|
||||
limit: Optional[int] = ..., encoding: str = ..., errors: str = ...) -> None: ...
|
||||
else:
|
||||
def __init__(self, fp: IO[Any] = ..., headers: Mapping[str, str] = ..., outerboundary: bytes = ...,
|
||||
environ: Mapping[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ...) -> None: ...
|
||||
|
||||
if sys.version_info >= (3, 0):
|
||||
def __enter__(self: _T) -> _T: ...
|
||||
def __exit__(self, *args: Any) -> None: ...
|
||||
def __repr__(self) -> str: ...
|
||||
def __iter__(self) -> Iterable[str]: ...
|
||||
def __getitem__(self, key: str) -> Any: ...
|
||||
def getvalue(self, key: str, default: Any = ...) -> Any: ...
|
||||
def getfirst(self, key: str, default: Any = ...) -> Any: ...
|
||||
def getlist(self, key: str) -> List[Any]: ...
|
||||
def keys(self) -> List[str]: ...
|
||||
if sys.version_info < (3, 0):
|
||||
def has_key(self, key: str) -> bool: ...
|
||||
def __contains__(self, key: str) -> bool: ...
|
||||
def __len__(self) -> int: ...
|
||||
if sys.version_info >= (3, 0):
|
||||
def __bool__(self) -> bool: ...
|
||||
else:
|
||||
def __nonzero__(self) -> bool: ...
|
||||
if sys.version_info >= (3, 0):
|
||||
# In Python 3 it returns bytes or str IO depending on an internal flag
|
||||
def make_file(self) -> IO[Any]: ...
|
||||
else:
|
||||
# In Python 2 it always returns bytes and ignores the "binary" flag
|
||||
def make_file(self, binary: Any = ...) -> IO[bytes]: ...
|
||||
|
||||
|
||||
if sys.version_info < (3, 0):
|
||||
from UserDict import UserDict
|
||||
|
||||
class FormContentDict(UserDict[str, List[str]]):
|
||||
query_string: str
|
||||
def __init__(self, environ: Mapping[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ...) -> None: ...
|
||||
|
||||
class SvFormContentDict(FormContentDict):
|
||||
def getlist(self, key: Any) -> Any: ...
|
||||
|
||||
class InterpFormContentDict(SvFormContentDict): ...
|
||||
|
||||
class FormContent(FormContentDict):
|
||||
# TODO this should have
|
||||
# def values(self, key: Any) -> Any: ...
|
||||
# but this is incompatible with the supertype, and adding '# type: ignore' triggers
|
||||
# a parse error in pytype (https://github.com/google/pytype/issues/53)
|
||||
def indexed_value(self, key: Any, location: int) -> Any: ...
|
||||
def value(self, key: Any) -> Any: ...
|
||||
def length(self, key: Any) -> int: ...
|
||||
def stripped(self, key: Any) -> Any: ...
|
||||
def pars(self) -> Dict[Any, Any]: ...
|
||||
@@ -0,0 +1,160 @@
|
||||
from typing import Any, Callable, Dict, List, NamedTuple, Optional, Tuple, Type, Union
|
||||
|
||||
import sys
|
||||
import types
|
||||
import unittest
|
||||
|
||||
class TestResults(NamedTuple):
|
||||
failed: int
|
||||
attempted: int
|
||||
|
||||
OPTIONFLAGS_BY_NAME: Dict[str, int]
|
||||
def register_optionflag(name: str) -> int: ...
|
||||
DONT_ACCEPT_TRUE_FOR_1: int
|
||||
DONT_ACCEPT_BLANKLINE: int
|
||||
NORMALIZE_WHITESPACE: int
|
||||
ELLIPSIS: int
|
||||
SKIP: int
|
||||
IGNORE_EXCEPTION_DETAIL: int
|
||||
|
||||
COMPARISON_FLAGS: int
|
||||
|
||||
REPORT_UDIFF: int
|
||||
REPORT_CDIFF: int
|
||||
REPORT_NDIFF: int
|
||||
REPORT_ONLY_FIRST_FAILURE: int
|
||||
if sys.version_info >= (3, 4):
|
||||
FAIL_FAST: int
|
||||
|
||||
REPORTING_FLAGS: int
|
||||
|
||||
BLANKLINE_MARKER: str
|
||||
ELLIPSIS_MARKER: str
|
||||
|
||||
class Example:
|
||||
source: str
|
||||
want: str
|
||||
exc_msg: Optional[str]
|
||||
lineno: int
|
||||
indent: int
|
||||
options: Dict[int, bool]
|
||||
def __init__(self, source: str, want: str, exc_msg: Optional[str] = ..., lineno: int = ..., indent: int = ...,
|
||||
options: Optional[Dict[int, bool]] = ...) -> None: ...
|
||||
def __hash__(self) -> int: ...
|
||||
|
||||
class DocTest:
|
||||
examples: List[Example]
|
||||
globs: Dict[str, Any]
|
||||
name: str
|
||||
filename: Optional[str]
|
||||
lineno: Optional[int]
|
||||
docstring: Optional[str]
|
||||
def __init__(self, examples: List[Example], globs: Dict[str, Any], name: str, filename: Optional[str], lineno: Optional[int], docstring: Optional[str]) -> None: ...
|
||||
def __hash__(self) -> int: ...
|
||||
def __lt__(self, other: DocTest) -> bool: ...
|
||||
|
||||
class DocTestParser:
|
||||
def parse(self, string: str, name: str = ...) -> List[Union[str, Example]]: ...
|
||||
def get_doctest(self, string: str, globs: Dict[str, Any], name: str, filename: Optional[str], lineno: Optional[int]) -> DocTest: ...
|
||||
def get_examples(self, string: str, name: str = ...) -> List[Example]: ...
|
||||
|
||||
class DocTestFinder:
|
||||
def __init__(self, verbose: bool = ..., parser: DocTestParser = ...,
|
||||
recurse: bool = ..., exclude_empty: bool = ...) -> None: ...
|
||||
def find(self, obj: object, name: Optional[str] = ..., module: Union[None, bool, types.ModuleType] = ...,
|
||||
globs: Optional[Dict[str, Any]] = ..., extraglobs: Optional[Dict[str, Any]] = ...) -> List[DocTest]: ...
|
||||
|
||||
_Out = Callable[[str], Any]
|
||||
_ExcInfo = Tuple[Type[BaseException], BaseException, types.TracebackType]
|
||||
|
||||
class DocTestRunner:
|
||||
DIVIDER: str
|
||||
optionflags: int
|
||||
original_optionflags: int
|
||||
tries: int
|
||||
failures: int
|
||||
test: DocTest
|
||||
|
||||
def __init__(self, checker: Optional[OutputChecker] = ..., verbose: Optional[bool] = ..., optionflags: int = ...) -> None: ...
|
||||
def report_start(self, out: _Out, test: DocTest, example: Example) -> None: ...
|
||||
def report_success(self, out: _Out, test: DocTest, example: Example, got: str) -> None: ...
|
||||
def report_failure(self, out: _Out, test: DocTest, example: Example, got: str) -> None: ...
|
||||
def report_unexpected_exception(self, out: _Out, test: DocTest, example: Example, exc_info: _ExcInfo) -> None: ...
|
||||
def run(self, test: DocTest, compileflags: Optional[int] = ..., out: Optional[_Out] = ..., clear_globs: bool = ...) -> TestResults: ...
|
||||
def summarize(self, verbose: Optional[bool] = ...) -> TestResults: ...
|
||||
def merge(self, other: DocTestRunner) -> None: ...
|
||||
|
||||
class OutputChecker:
|
||||
def check_output(self, want: str, got: str, optionflags: int) -> bool: ...
|
||||
def output_difference(self, example: Example, got: str, optionflags: int) -> str: ...
|
||||
|
||||
class DocTestFailure(Exception):
|
||||
test: DocTest
|
||||
example: Example
|
||||
got: str
|
||||
|
||||
def __init__(self, test: DocTest, example: Example, got: str) -> None: ...
|
||||
|
||||
class UnexpectedException(Exception):
|
||||
test: DocTest
|
||||
example: Example
|
||||
exc_info: _ExcInfo
|
||||
|
||||
def __init__(self, test: DocTest, example: Example, exc_info: _ExcInfo) -> None: ...
|
||||
|
||||
class DebugRunner(DocTestRunner): ...
|
||||
|
||||
master: Optional[DocTestRunner]
|
||||
|
||||
def testmod(m: Optional[types.ModuleType] = ..., name: Optional[str] = ..., globs: Optional[Dict[str, Any]] = ..., verbose: Optional[bool] = ...,
|
||||
report: bool = ..., optionflags: int = ..., extraglobs: Optional[Dict[str, Any]] = ...,
|
||||
raise_on_error: bool = ..., exclude_empty: bool = ...) -> TestResults: ...
|
||||
def testfile(filename: str, module_relative: bool = ..., name: Optional[str] = ..., package: Union[None, str, types.ModuleType] = ...,
|
||||
globs: Optional[Dict[str, Any]] = ..., verbose: Optional[bool] = ..., report: bool = ..., optionflags: int = ...,
|
||||
extraglobs: Optional[Dict[str, Any]] = ..., raise_on_error: bool = ..., parser: DocTestParser = ...,
|
||||
encoding: Optional[str] = ...) -> TestResults: ...
|
||||
def run_docstring_examples(f: object, globs: Dict[str, Any], verbose: bool = ..., name: str = ...,
|
||||
compileflags: Optional[int] = ..., optionflags: int = ...) -> None: ...
|
||||
def set_unittest_reportflags(flags: int) -> int: ...
|
||||
|
||||
class DocTestCase(unittest.TestCase):
|
||||
def __init__(self, test: DocTest, optionflags: int = ..., setUp: Optional[Callable[[DocTest], Any]] = ...,
|
||||
tearDown: Optional[Callable[[DocTest], Any]] = ...,
|
||||
checker: Optional[OutputChecker] = ...) -> None: ...
|
||||
def setUp(self) -> None: ...
|
||||
def tearDown(self) -> None: ...
|
||||
def runTest(self) -> None: ...
|
||||
def format_failure(self, err: str) -> str: ...
|
||||
def debug(self) -> None: ...
|
||||
def id(self) -> str: ...
|
||||
def __hash__(self) -> int: ...
|
||||
def shortDescription(self) -> str: ...
|
||||
|
||||
class SkipDocTestCase(DocTestCase):
|
||||
def __init__(self, module: types.ModuleType) -> None: ...
|
||||
def setUp(self) -> None: ...
|
||||
def test_skip(self) -> None: ...
|
||||
def shortDescription(self) -> str: ...
|
||||
|
||||
if sys.version_info >= (3, 4):
|
||||
class _DocTestSuite(unittest.TestSuite): ...
|
||||
else:
|
||||
_DocTestSuite = unittest.TestSuite
|
||||
|
||||
def DocTestSuite(module: Union[None, str, types.ModuleType] = ..., globs: Optional[Dict[str, Any]] = ...,
|
||||
extraglobs: Optional[Dict[str, Any]] = ..., test_finder: Optional[DocTestFinder] = ...,
|
||||
**options: Any) -> _DocTestSuite: ...
|
||||
|
||||
class DocFileCase(DocTestCase):
|
||||
def id(self) -> str: ...
|
||||
def format_failure(self, err: str) -> str: ...
|
||||
|
||||
def DocFileTest(path: str, module_relative: bool = ..., package: Union[None, str, types.ModuleType] = ...,
|
||||
globs: Optional[Dict[str, Any]] = ..., parser: DocTestParser = ...,
|
||||
encoding: Optional[str] = ..., **options: Any) -> DocFileCase: ...
|
||||
def DocFileSuite(*paths: str, **kw: Any) -> _DocTestSuite: ...
|
||||
def script_from_examples(s: str) -> str: ...
|
||||
def testsource(module: Union[None, str, types.ModuleType], name: str) -> str: ...
|
||||
def debug_src(src: str, pm: bool = ..., globs: Optional[Dict[str, Any]] = ...) -> None: ...
|
||||
def debug_script(src: str, pm: bool = ..., globs: Optional[Dict[str, Any]] = ...) -> None: ...
|
||||
def debug(module: Union[None, str, types.ModuleType], name: str, pm: bool = ...) -> None: ...
|
||||
@@ -0,0 +1,61 @@
|
||||
# Stubs for filecmp (Python 2/3)
|
||||
import sys
|
||||
from typing import AnyStr, Callable, Dict, Generic, Iterable, List, Optional, Sequence, Tuple, Union, Text
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
from os import PathLike
|
||||
|
||||
DEFAULT_IGNORES: List[str]
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
def cmp(f1: Union[bytes, Text, PathLike[AnyStr]], f2: Union[bytes, Text, PathLike[AnyStr]], shallow: Union[int, bool] = ...) -> bool: ...
|
||||
def cmpfiles(a: Union[AnyStr, PathLike[AnyStr]], b: Union[AnyStr, PathLike[AnyStr]], common: Iterable[AnyStr],
|
||||
shallow: Union[int, bool] = ...) -> Tuple[List[AnyStr], List[AnyStr], List[AnyStr]]: ...
|
||||
else:
|
||||
def cmp(f1: Union[bytes, Text], f2: Union[bytes, Text], shallow: Union[int, bool] = ...) -> bool: ...
|
||||
def cmpfiles(a: AnyStr, b: AnyStr, common: Iterable[AnyStr],
|
||||
shallow: Union[int, bool] = ...) -> Tuple[List[AnyStr], List[AnyStr], List[AnyStr]]: ...
|
||||
|
||||
class dircmp(Generic[AnyStr]):
|
||||
if sys.version_info >= (3, 6):
|
||||
def __init__(self, a: Union[AnyStr, PathLike[AnyStr]], b: Union[AnyStr, PathLike[AnyStr]],
|
||||
ignore: Optional[Sequence[AnyStr]] = ...,
|
||||
hide: Optional[Sequence[AnyStr]] = ...) -> None: ...
|
||||
else:
|
||||
def __init__(self, a: AnyStr, b: AnyStr,
|
||||
ignore: Optional[Sequence[AnyStr]] = ...,
|
||||
hide: Optional[Sequence[AnyStr]] = ...) -> None: ...
|
||||
|
||||
left: AnyStr
|
||||
right: AnyStr
|
||||
hide: Sequence[AnyStr]
|
||||
ignore: Sequence[AnyStr]
|
||||
|
||||
# These properties are created at runtime by __getattr__
|
||||
subdirs: Dict[AnyStr, dircmp[AnyStr]]
|
||||
same_files: List[AnyStr]
|
||||
diff_files: List[AnyStr]
|
||||
funny_files: List[AnyStr]
|
||||
common_dirs: List[AnyStr]
|
||||
common_files: List[AnyStr]
|
||||
common_funny: List[AnyStr]
|
||||
common: List[AnyStr]
|
||||
left_only: List[AnyStr]
|
||||
right_only: List[AnyStr]
|
||||
left_list: List[AnyStr]
|
||||
right_list: List[AnyStr]
|
||||
|
||||
def report(self) -> None: ...
|
||||
def report_partial_closure(self) -> None: ...
|
||||
def report_full_closure(self) -> None: ...
|
||||
|
||||
methodmap: Dict[str, Callable[[], None]]
|
||||
def phase0(self) -> None: ...
|
||||
def phase1(self) -> None: ...
|
||||
def phase2(self) -> None: ...
|
||||
def phase3(self) -> None: ...
|
||||
def phase4(self) -> None: ...
|
||||
def phase4_closure(self) -> None: ...
|
||||
|
||||
if sys.version_info >= (3,):
|
||||
def clear_cache() -> None: ...
|
||||
@@ -0,0 +1,21 @@
|
||||
import os
|
||||
import sys
|
||||
from typing import Any, BinaryIO, Callable, List, Optional, Protocol, Text, Union, overload
|
||||
|
||||
class _ReadableBinary(Protocol):
|
||||
def tell(self) -> int: ...
|
||||
def read(self, size: int) -> bytes: ...
|
||||
def seek(self, offset: int) -> Any: ...
|
||||
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
_File = Union[Text, os.PathLike[Text], _ReadableBinary]
|
||||
else:
|
||||
_File = Union[Text, _ReadableBinary]
|
||||
|
||||
|
||||
@overload
|
||||
def what(file: _File, h: None = ...) -> Optional[str]: ...
|
||||
@overload
|
||||
def what(file: Any, h: bytes) -> Optional[str]: ...
|
||||
tests: List[Callable[[bytes, Optional[BinaryIO]], Optional[str]]]
|
||||
@@ -0,0 +1,113 @@
|
||||
# Stubs for locale
|
||||
|
||||
from decimal import Decimal
|
||||
from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Union
|
||||
import sys
|
||||
|
||||
# workaround for mypy#2010
|
||||
if sys.version_info < (3,):
|
||||
from __builtin__ import str as _str
|
||||
else:
|
||||
from builtins import str as _str
|
||||
|
||||
CODESET: int
|
||||
D_T_FMT: int
|
||||
D_FMT: int
|
||||
T_FMT: int
|
||||
T_FMT_AMPM: int
|
||||
|
||||
DAY_1: int
|
||||
DAY_2: int
|
||||
DAY_3: int
|
||||
DAY_4: int
|
||||
DAY_5: int
|
||||
DAY_6: int
|
||||
DAY_7: int
|
||||
ABDAY_1: int
|
||||
ABDAY_2: int
|
||||
ABDAY_3: int
|
||||
ABDAY_4: int
|
||||
ABDAY_5: int
|
||||
ABDAY_6: int
|
||||
ABDAY_7: int
|
||||
|
||||
MON_1: int
|
||||
MON_2: int
|
||||
MON_3: int
|
||||
MON_4: int
|
||||
MON_5: int
|
||||
MON_6: int
|
||||
MON_7: int
|
||||
MON_8: int
|
||||
MON_9: int
|
||||
MON_10: int
|
||||
MON_11: int
|
||||
MON_12: int
|
||||
ABMON_1: int
|
||||
ABMON_2: int
|
||||
ABMON_3: int
|
||||
ABMON_4: int
|
||||
ABMON_5: int
|
||||
ABMON_6: int
|
||||
ABMON_7: int
|
||||
ABMON_8: int
|
||||
ABMON_9: int
|
||||
ABMON_10: int
|
||||
ABMON_11: int
|
||||
ABMON_12: int
|
||||
|
||||
RADIXCHAR: int
|
||||
THOUSEP: int
|
||||
YESEXPR: int
|
||||
NOEXPR: int
|
||||
CRNCYSTR: int
|
||||
|
||||
ERA: int
|
||||
ERA_D_T_FMT: int
|
||||
ERA_D_FMT: int
|
||||
ERA_T_FMT: int
|
||||
|
||||
ALT_DIGITS: int
|
||||
|
||||
LC_CTYPE: int
|
||||
LC_COLLATE: int
|
||||
LC_TIME: int
|
||||
LC_MONETARY: int
|
||||
LC_MESSAGES: int
|
||||
LC_NUMERIC: int
|
||||
LC_ALL: int
|
||||
|
||||
CHAR_MAX: int
|
||||
|
||||
class Error(Exception): ...
|
||||
|
||||
def setlocale(category: int,
|
||||
locale: Union[_str, Iterable[_str], None] = ...) -> _str: ...
|
||||
def localeconv() -> Mapping[_str, Union[int, _str, List[int]]]: ...
|
||||
def nl_langinfo(option: int) -> _str: ...
|
||||
def getdefaultlocale(envvars: Tuple[_str, ...] = ...) -> Tuple[Optional[_str], Optional[_str]]: ...
|
||||
def getlocale(category: int = ...) -> Sequence[_str]: ...
|
||||
def getpreferredencoding(do_setlocale: bool = ...) -> _str: ...
|
||||
def normalize(localename: _str) -> _str: ...
|
||||
def resetlocale(category: int = ...) -> None: ...
|
||||
def strcoll(string1: _str, string2: _str) -> int: ...
|
||||
def strxfrm(string: _str) -> _str: ...
|
||||
def format(percent: _str, value: Union[float, Decimal], grouping: bool = ...,
|
||||
monetary: bool = ..., *additional: Any) -> _str: ...
|
||||
if sys.version_info >= (3, 7):
|
||||
def format_string(f: _str, val: Any,
|
||||
grouping: bool = ..., monetary: bool = ...) -> _str: ...
|
||||
else:
|
||||
def format_string(f: _str, val: Any,
|
||||
grouping: bool = ...) -> _str: ...
|
||||
def currency(val: Union[int, float, Decimal], symbol: bool = ..., grouping: bool = ...,
|
||||
international: bool = ...) -> _str: ...
|
||||
if sys.version_info >= (3, 5):
|
||||
def delocalize(string: _str) -> _str: ...
|
||||
def atof(string: _str, func: Callable[[_str], float] = ...) -> float: ...
|
||||
def atoi(string: _str) -> int: ...
|
||||
def str(val: float) -> _str: ...
|
||||
|
||||
locale_alias: Dict[_str, _str] # undocumented
|
||||
locale_encoding_alias: Dict[_str, _str] # undocumented
|
||||
windows_locale: Dict[int, _str] # undocumented
|
||||
@@ -0,0 +1,44 @@
|
||||
# Stubs for mimetypes
|
||||
|
||||
from typing import Dict, IO, List, Optional, Sequence, Text, Tuple, AnyStr, Union
|
||||
import sys
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
from os import PathLike
|
||||
def guess_type(url: Union[Text, PathLike[str]],
|
||||
strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ...
|
||||
else:
|
||||
def guess_type(url: Text,
|
||||
strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ...
|
||||
|
||||
def guess_all_extensions(type: str, strict: bool = ...) -> List[str]: ...
|
||||
def guess_extension(type: str, strict: bool = ...) -> Optional[str]: ...
|
||||
|
||||
def init(files: Optional[Sequence[str]] = ...) -> None: ...
|
||||
def read_mime_types(filename: str) -> Optional[Dict[str, str]]: ...
|
||||
def add_type(type: str, ext: str, strict: bool = ...) -> None: ...
|
||||
|
||||
inited: bool
|
||||
knownfiles: List[str]
|
||||
suffix_map: Dict[str, str]
|
||||
encodings_map: Dict[str, str]
|
||||
types_map: Dict[str, str]
|
||||
common_types: Dict[str, str]
|
||||
|
||||
class MimeTypes:
|
||||
suffix_map: Dict[str, str]
|
||||
encodings_map: Dict[str, str]
|
||||
types_map: Tuple[Dict[str, str], Dict[str, str]]
|
||||
types_map_inv: Tuple[Dict[str, str], Dict[str, str]]
|
||||
def __init__(self, filenames: Tuple[str, ...] = ...,
|
||||
strict: bool = ...) -> None: ...
|
||||
def guess_extension(self, type: str,
|
||||
strict: bool = ...) -> Optional[str]: ...
|
||||
def guess_type(self, url: str,
|
||||
strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ...
|
||||
def guess_all_extensions(self, type: str,
|
||||
strict: bool = ...) -> List[str]: ...
|
||||
def read(self, filename: str, strict: bool = ...) -> None: ...
|
||||
def readfp(self, fp: IO[str], strict: bool = ...) -> None: ...
|
||||
if sys.platform == 'win32':
|
||||
def read_windows_registry(self, strict: bool = ...) -> None: ...
|
||||
@@ -0,0 +1,29 @@
|
||||
from typing import Any, List, Sequence, Text, Tuple, Union
|
||||
from types import CodeType
|
||||
|
||||
import sys
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
from builtins import _PathLike
|
||||
_Path = Union[str, bytes, _PathLike]
|
||||
else:
|
||||
_Path = Union[str, bytes]
|
||||
|
||||
def expr(source: Text) -> STType: ...
|
||||
def suite(source: Text) -> STType: ...
|
||||
def sequence2st(sequence: Sequence[Any]) -> STType: ...
|
||||
def tuple2st(sequence: Sequence[Any]) -> STType: ...
|
||||
def st2list(st: STType, line_info: bool = ..., col_info: bool = ...) -> List[Any]: ...
|
||||
def st2tuple(st: STType, line_info: bool = ..., col_info: bool = ...) -> Tuple[Any]: ...
|
||||
def compilest(st: STType, filename: _Path = ...) -> CodeType: ...
|
||||
def isexpr(st: STType) -> bool: ...
|
||||
def issuite(st: STType) -> bool: ...
|
||||
|
||||
class ParserError(Exception): ...
|
||||
|
||||
class STType:
|
||||
def compile(self, filename: _Path) -> CodeType: ...
|
||||
def isexpr(self) -> bool: ...
|
||||
def issuite(self) -> bool: ...
|
||||
def tolist(self, line_info: bool = ..., col_info: bool = ...) -> List[Any]: ...
|
||||
def totuple(self, line_info: bool = ..., col_info: bool = ...) -> Tuple[Any]: ...
|
||||
@@ -0,0 +1,40 @@
|
||||
from profile import Profile
|
||||
from cProfile import Profile as _cProfile
|
||||
import os
|
||||
import sys
|
||||
from typing import Any, Dict, IO, Iterable, List, Optional, Text, Tuple, TypeVar, Union, overload
|
||||
|
||||
_Selector = Union[str, float, int]
|
||||
_T = TypeVar('_T', bound=Stats)
|
||||
if sys.version_info >= (3, 6):
|
||||
_Path = Union[bytes, Text, os.PathLike[Any]]
|
||||
else:
|
||||
_Path = Union[bytes, Text]
|
||||
|
||||
class Stats:
|
||||
sort_arg_dict_default: Dict[str, Tuple[Any, str]]
|
||||
def __init__(self: _T, __arg: Union[None, str, Text, Profile, _cProfile] = ...,
|
||||
*args: Union[None, str, Text, Profile, _cProfile, _T],
|
||||
stream: Optional[IO[Any]] = ...) -> None: ...
|
||||
def init(self, arg: Union[None, str, Text, Profile, _cProfile]) -> None: ...
|
||||
def load_stats(self, arg: Union[None, str, Text, Profile, _cProfile]) -> None: ...
|
||||
def get_top_level_stats(self) -> None: ...
|
||||
def add(self: _T, *arg_list: Union[None, str, Text, Profile, _cProfile, _T]) -> _T: ...
|
||||
def dump_stats(self, filename: _Path) -> None: ...
|
||||
def get_sort_arg_defs(self) -> Dict[str, Tuple[Tuple[Tuple[int, int], ...], str]]: ...
|
||||
@overload
|
||||
def sort_stats(self: _T, field: int) -> _T: ...
|
||||
@overload
|
||||
def sort_stats(self: _T, *field: str) -> _T: ...
|
||||
def reverse_order(self: _T) -> _T: ...
|
||||
def strip_dirs(self: _T) -> _T: ...
|
||||
def calc_callees(self) -> None: ...
|
||||
def eval_print_amount(self, sel: _Selector, list: List[str], msg: str) -> Tuple[List[str], str]: ...
|
||||
def get_print_list(self, sel_list: Iterable[_Selector]) -> Tuple[int, List[str]]: ...
|
||||
def print_stats(self: _T, *amount: _Selector) -> _T: ...
|
||||
def print_callees(self: _T, *amount: _Selector) -> _T: ...
|
||||
def print_callers(self: _T, *amount: _Selector) -> _T: ...
|
||||
def print_call_heading(self, name_size: int, column_title: str) -> None: ...
|
||||
def print_call_line(self, name_size: int, source: str, call_dict: Dict[str, Any], arrow: str = ...) -> None: ...
|
||||
def print_title(self) -> None: ...
|
||||
def print_line(self, func: str) -> None: ...
|
||||
@@ -0,0 +1,186 @@
|
||||
import sys
|
||||
from typing import Any, AnyStr, Callable, Container, Dict, IO, List, Mapping, MutableMapping, NoReturn, Optional, Protocol, Text, Tuple, Type, Union
|
||||
from types import FunctionType, MethodType, ModuleType, TracebackType
|
||||
if sys.version_info >= (3,):
|
||||
from reprlib import Repr
|
||||
else:
|
||||
from repr import Repr
|
||||
|
||||
# the return type of sys.exc_info(), used by ErrorDuringImport.__init__
|
||||
_Exc_Info = Tuple[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]]
|
||||
|
||||
__author__: str
|
||||
__date__: str
|
||||
__version__: str
|
||||
__credits__: str
|
||||
|
||||
def pathdirs() -> List[str]: ...
|
||||
def getdoc(object: object) -> Text: ...
|
||||
def splitdoc(doc: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
|
||||
def classname(object: object, modname: str) -> str: ...
|
||||
def isdata(object: object) -> bool: ...
|
||||
def replace(text: AnyStr, *pairs: AnyStr) -> AnyStr: ...
|
||||
def cram(text: str, maxlen: int) -> str: ...
|
||||
def stripid(text: str) -> str: ...
|
||||
def allmethods(cl: type) -> MutableMapping[str, MethodType]: ...
|
||||
def visiblename(name: str, all: Optional[Container[str]] = ..., obj: Optional[object] = ...) -> bool: ...
|
||||
def classify_class_attrs(object: object) -> List[Tuple[str, str, type, str]]: ...
|
||||
|
||||
def ispackage(path: str) -> bool: ...
|
||||
def source_synopsis(file: IO[AnyStr]) -> Optional[AnyStr]: ...
|
||||
def synopsis(filename: str, cache: MutableMapping[str, Tuple[int, str]] = ...) -> Optional[str]: ...
|
||||
|
||||
class ErrorDuringImport(Exception):
|
||||
filename: str
|
||||
exc: Optional[Type[BaseException]]
|
||||
value: Optional[BaseException]
|
||||
tb: Optional[TracebackType]
|
||||
def __init__(self, filename: str, exc_info: _Exc_Info) -> None: ...
|
||||
|
||||
def importfile(path: str) -> ModuleType: ...
|
||||
def safeimport(path: str, forceload: bool = ..., cache: MutableMapping[str, ModuleType] = ...) -> ModuleType: ...
|
||||
|
||||
class Doc:
|
||||
PYTHONDOCS: str
|
||||
def document(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ...
|
||||
def fail(self, object: object, name: Optional[str] = ..., *args: Any) -> NoReturn: ...
|
||||
def docmodule(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ...
|
||||
def docclass(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ...
|
||||
def docroutine(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ...
|
||||
def docother(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ...
|
||||
def docproperty(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ...
|
||||
def docdata(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ...
|
||||
def getdocloc(self, object: object, basedir: str = ...) -> Optional[str]: ...
|
||||
|
||||
class HTMLRepr(Repr):
|
||||
maxlist: int
|
||||
maxtuple: int
|
||||
maxdict: int
|
||||
maxstring: int
|
||||
maxother: int
|
||||
def __init__(self) -> None: ...
|
||||
def escape(self, text: str) -> str: ...
|
||||
def repr(self, object: object) -> str: ...
|
||||
def repr1(self, x: object, level: complex) -> str: ...
|
||||
def repr_string(self, x: Text, level: complex) -> str: ...
|
||||
def repr_str(self, x: Text, level: complex) -> str: ...
|
||||
def repr_instance(self, x: object, level: complex) -> str: ...
|
||||
def repr_unicode(self, x: AnyStr, level: complex) -> str: ...
|
||||
|
||||
class HTMLDoc(Doc):
|
||||
repr: Callable[[object], str]
|
||||
escape: Callable[[str], str]
|
||||
def page(self, title: str, contents: str) -> str: ...
|
||||
def heading(self, title: str, fgcol: str, bgcol: str, extras: str = ...) -> str: ...
|
||||
def section(self, title: str, fgcol: str, bgcol: str, contents: str, width: int = ..., prelude: str = ..., marginalia: Optional[str] = ..., gap: str = ...) -> str: ...
|
||||
def bigsection(self, title: str, *args) -> str: ...
|
||||
def preformat(self, text: str) -> str: ...
|
||||
def multicolumn(self, list: List[Any], format: Callable[[Any], str], cols: int = ...) -> str: ...
|
||||
def grey(self, text: str) -> str: ...
|
||||
def namelink(self, name: str, *dicts: MutableMapping[str, str]) -> str: ...
|
||||
def classlink(self, object: object, modname: str) -> str: ...
|
||||
def modulelink(self, object: object) -> str: ...
|
||||
def modpkglink(self, modpkginfo: Tuple[str, str, bool, bool]) -> str: ...
|
||||
def markup(self, text: str, escape: Optional[Callable[[str], str]] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., methods: Mapping[str, str] = ...) -> str: ...
|
||||
def formattree(self, tree: List[Union[Tuple[type, Tuple[type, ...]], List[Any]]], modname: str, parent: Optional[type] = ...) -> str: ...
|
||||
def docmodule(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., *ignored) -> str: ...
|
||||
def docclass(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., *ignored) -> str: ...
|
||||
def formatvalue(self, object: object) -> str: ...
|
||||
def docroutine(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., methods: Mapping[str, str] = ..., cl: Optional[type] = ..., *ignored) -> str: ...
|
||||
def docproperty(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., cl: Optional[Any] = ..., *ignored) -> str: ...
|
||||
def docother(self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., *ignored) -> str: ...
|
||||
def docdata(self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., cl: Optional[Any] = ..., *ignored) -> str: ...
|
||||
def index(self, dir: str, shadowed: Optional[MutableMapping[str, bool]] = ...) -> str: ...
|
||||
def filelink(self, url: str, path: str) -> str: ...
|
||||
|
||||
class TextRepr(Repr):
|
||||
maxlist: int
|
||||
maxtuple: int
|
||||
maxdict: int
|
||||
maxstring: int
|
||||
maxother: int
|
||||
def __init__(self) -> None: ...
|
||||
def repr1(self, x: object, level: complex) -> str: ...
|
||||
def repr_string(self, x: str, level: complex) -> str: ...
|
||||
def repr_str(self, x: str, level: complex) -> str: ...
|
||||
def repr_instance(self, x: object, level: complex) -> str: ...
|
||||
|
||||
class TextDoc(Doc):
|
||||
repr: Callable[[object], str]
|
||||
def bold(self, text: str) -> str: ...
|
||||
def indent(self, text: str, prefix: str = ...) -> str: ...
|
||||
def section(self, title: str, contents: str) -> str: ...
|
||||
def formattree(self, tree: List[Union[Tuple[type, Tuple[type, ...]], List[Any]]], modname: str, parent: Optional[type] = ..., prefix: str = ...) -> str: ...
|
||||
def docmodule(self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., *ignored) -> str: ...
|
||||
def docclass(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., *ignored) -> str: ...
|
||||
def formatvalue(self, object: object) -> str: ...
|
||||
def docroutine(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., cl: Optional[Any] = ..., *ignored) -> str: ...
|
||||
def docproperty(self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., cl: Optional[Any] = ..., *ignored) -> str: ...
|
||||
def docdata(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., cl: Optional[Any] = ..., *ignored) -> str: ...
|
||||
def docother(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., parent: Optional[str] = ..., maxlen: Optional[int] = ..., doc: Optional[Any] = ..., *ignored) -> str: ...
|
||||
|
||||
def pager(text: str) -> None: ...
|
||||
def getpager() -> Callable[[str], None]: ...
|
||||
def plain(text: str) -> str: ...
|
||||
def pipepager(text: str, cmd: str) -> None: ...
|
||||
def tempfilepager(text: str, cmd: str) -> None: ...
|
||||
def ttypager(text: str) -> None: ...
|
||||
def plainpager(text: str) -> None: ...
|
||||
def describe(thing: Any) -> str: ...
|
||||
def locate(path: str, forceload: bool = ...) -> object: ...
|
||||
|
||||
text: TextDoc
|
||||
html: HTMLDoc
|
||||
|
||||
class _OldStyleClass: ...
|
||||
class _Writable(Protocol):
|
||||
def write(self, __obj: str) -> Any: ...
|
||||
|
||||
def resolve(thing: Union[str, object], forceload: bool = ...) -> Optional[Tuple[object, str]]: ...
|
||||
def render_doc(thing: Union[str, object], title: str = ..., forceload: bool = ..., renderer: Optional[Doc] = ...) -> str: ...
|
||||
def doc(thing: Union[str, object], title: str = ..., forceload: bool = ..., output: Optional[_Writable] = ...) -> None: ...
|
||||
def writedoc(thing: Union[str, object], forceload: bool = ...) -> None: ...
|
||||
def writedocs(dir: str, pkgpath: str = ..., done: Optional[Any] = ...) -> None: ...
|
||||
|
||||
class Helper:
|
||||
keywords: Dict[str, Union[str, Tuple[str, str]]]
|
||||
symbols: Dict[str, str]
|
||||
topics: Dict[str, Union[str, Tuple[str, ...]]]
|
||||
def __init__(self, input: Optional[IO[str]] = ..., output: Optional[IO[str]] = ...) -> None: ...
|
||||
input: IO[str]
|
||||
output: IO[str]
|
||||
def __call__(self, request: Union[str, Helper, object] = ...) -> None: ...
|
||||
def interact(self) -> None: ...
|
||||
def getline(self, prompt: str) -> str: ...
|
||||
def help(self, request: Any) -> None: ...
|
||||
def intro(self) -> None: ...
|
||||
def list(self, items: List[str], columns: int = ..., width: int = ...) -> None: ...
|
||||
def listkeywords(self) -> None: ...
|
||||
def listsymbols(self) -> None: ...
|
||||
def listtopics(self) -> None: ...
|
||||
def showtopic(self, topic: str, more_xrefs: str = ...) -> None: ...
|
||||
def showsymbol(self, symbol: str) -> None: ...
|
||||
def listmodules(self, key: str = ...) -> None: ...
|
||||
|
||||
help: Helper
|
||||
|
||||
# See Python issue #11182: "remove the unused and undocumented pydoc.Scanner class"
|
||||
# class Scanner:
|
||||
# roots = ... # type: Any
|
||||
# state = ... # type: Any
|
||||
# children = ... # type: Any
|
||||
# descendp = ... # type: Any
|
||||
# def __init__(self, roots, children, descendp) -> None: ...
|
||||
# def next(self): ...
|
||||
|
||||
class ModuleScanner:
|
||||
quit: bool
|
||||
def run(self, callback: Callable[[Optional[str], str, str], None], key: Optional[Any] = ..., completer: Optional[Callable[[], None]] = ..., onerror: Optional[Callable[[str], None]] = ...) -> None: ...
|
||||
|
||||
def apropos(key: str) -> None: ...
|
||||
def ispath(x: Any) -> bool: ...
|
||||
def cli() -> None: ...
|
||||
|
||||
if sys.version_info < (3,):
|
||||
def serve(port: int, callback: Optional[Callable[[Any], None]] = ..., completer: Optional[Callable[[], None]] = ...) -> None: ...
|
||||
def gui() -> None: ...
|
||||
@@ -0,0 +1,139 @@
|
||||
import sys
|
||||
from typing import Any, Iterable, List, Optional, Protocol, Tuple, Type, Union
|
||||
from types import TracebackType
|
||||
from _types import FileDescriptorLike
|
||||
|
||||
|
||||
PIPE_BUF: int
|
||||
POLLERR: int
|
||||
POLLHUP: int
|
||||
POLLIN: int
|
||||
POLLMSG: int
|
||||
POLLNVAL: int
|
||||
POLLOUT: int
|
||||
POLLPRI: int
|
||||
POLLRDBAND: int
|
||||
POLLRDNORM: int
|
||||
POLLWRBAND: int
|
||||
POLLWRNORM: int
|
||||
|
||||
class poll:
|
||||
def __init__(self) -> None: ...
|
||||
def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ...
|
||||
def modify(self, fd: FileDescriptorLike, eventmask: int) -> None: ...
|
||||
def unregister(self, fd: FileDescriptorLike) -> None: ...
|
||||
def poll(self, timeout: Optional[float] = ...) -> List[Tuple[int, int]]: ...
|
||||
|
||||
def select(__rlist: Iterable[Any], __wlist: Iterable[Any], __xlist: Iterable[Any],
|
||||
__timeout: Optional[float] = ...) -> Tuple[List[Any], List[Any], List[Any]]: ...
|
||||
|
||||
if sys.version_info >= (3, 3):
|
||||
error = OSError
|
||||
else:
|
||||
class error(Exception): ...
|
||||
|
||||
if sys.platform != "linux" and sys.platform != "win32":
|
||||
# BSD only
|
||||
class kevent(object):
|
||||
data: Any
|
||||
fflags: int
|
||||
filter: int
|
||||
flags: int
|
||||
ident: int
|
||||
udata: Any
|
||||
def __init__(self, ident: FileDescriptorLike, filter: int = ..., flags: int = ..., fflags: int = ..., data: Any = ..., udata: Any = ...) -> None: ...
|
||||
|
||||
# BSD only
|
||||
class kqueue(object):
|
||||
closed: bool
|
||||
def __init__(self) -> None: ...
|
||||
def close(self) -> None: ...
|
||||
def control(self, __changelist: Optional[Iterable[kevent]], __maxevents: int, __timeout: Optional[float] = ...) -> List[kevent]: ...
|
||||
def fileno(self) -> int: ...
|
||||
@classmethod
|
||||
def fromfd(cls, __fd: FileDescriptorLike) -> kqueue: ...
|
||||
|
||||
KQ_EV_ADD: int
|
||||
KQ_EV_CLEAR: int
|
||||
KQ_EV_DELETE: int
|
||||
KQ_EV_DISABLE: int
|
||||
KQ_EV_ENABLE: int
|
||||
KQ_EV_EOF: int
|
||||
KQ_EV_ERROR: int
|
||||
KQ_EV_FLAG1: int
|
||||
KQ_EV_ONESHOT: int
|
||||
KQ_EV_SYSFLAGS: int
|
||||
KQ_FILTER_AIO: int
|
||||
KQ_FILTER_NETDEV: int
|
||||
KQ_FILTER_PROC: int
|
||||
KQ_FILTER_READ: int
|
||||
KQ_FILTER_SIGNAL: int
|
||||
KQ_FILTER_TIMER: int
|
||||
KQ_FILTER_VNODE: int
|
||||
KQ_FILTER_WRITE: int
|
||||
KQ_NOTE_ATTRIB: int
|
||||
KQ_NOTE_CHILD: int
|
||||
KQ_NOTE_DELETE: int
|
||||
KQ_NOTE_EXEC: int
|
||||
KQ_NOTE_EXIT: int
|
||||
KQ_NOTE_EXTEND: int
|
||||
KQ_NOTE_FORK: int
|
||||
KQ_NOTE_LINK: int
|
||||
if sys.platform != "darwin":
|
||||
KQ_NOTE_LINKDOWN: int
|
||||
KQ_NOTE_LINKINV: int
|
||||
KQ_NOTE_LINKUP: int
|
||||
KQ_NOTE_LOWAT: int
|
||||
KQ_NOTE_PCTRLMASK: int
|
||||
KQ_NOTE_PDATAMASK: int
|
||||
KQ_NOTE_RENAME: int
|
||||
KQ_NOTE_REVOKE: int
|
||||
KQ_NOTE_TRACK: int
|
||||
KQ_NOTE_TRACKERR: int
|
||||
KQ_NOTE_WRITE: int
|
||||
|
||||
if sys.platform == "linux":
|
||||
class epoll(object):
|
||||
if sys.version_info >= (3, 3):
|
||||
def __init__(self, sizehint: int = ..., flags: int = ...) -> None: ...
|
||||
else:
|
||||
def __init__(self, sizehint: int = ...) -> None: ...
|
||||
if sys.version_info >= (3, 4):
|
||||
def __enter__(self) -> epoll: ...
|
||||
def __exit__(self, exc_type: Optional[Type[BaseException]] = ..., exc_val: Optional[BaseException] = ..., exc_tb: Optional[TracebackType] = ...) -> None: ...
|
||||
def close(self) -> None: ...
|
||||
closed: bool
|
||||
def fileno(self) -> int: ...
|
||||
def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ...
|
||||
def modify(self, fd: FileDescriptorLike, eventmask: int) -> None: ...
|
||||
def unregister(self, fd: FileDescriptorLike) -> None: ...
|
||||
def poll(self, timeout: Optional[float] = ..., maxevents: int = ...) -> List[Tuple[int, int]]: ...
|
||||
@classmethod
|
||||
def fromfd(cls, __fd: FileDescriptorLike) -> epoll: ...
|
||||
|
||||
EPOLLERR: int
|
||||
EPOLLET: int
|
||||
EPOLLHUP: int
|
||||
EPOLLIN: int
|
||||
EPOLLMSG: int
|
||||
EPOLLONESHOT: int
|
||||
EPOLLOUT: int
|
||||
EPOLLPRI: int
|
||||
EPOLLRDBAND: int
|
||||
EPOLLRDNORM: int
|
||||
EPOLLWRBAND: int
|
||||
EPOLLWRNORM: int
|
||||
EPOLL_RDHUP: int
|
||||
|
||||
if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
|
||||
if sys.version_info >= (3, 3):
|
||||
# Solaris only
|
||||
class devpoll:
|
||||
if sys.version_info >= (3, 4):
|
||||
def close(self) -> None: ...
|
||||
closed: bool
|
||||
def fileno(self) -> int: ...
|
||||
def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ...
|
||||
def modify(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ...
|
||||
def unregister(self, fd: FileDescriptorLike) -> None: ...
|
||||
def poll(self, timeout: Optional[float] = ...) -> List[Tuple[int, int]]: ...
|
||||
@@ -0,0 +1,44 @@
|
||||
# Stubs for struct
|
||||
|
||||
# Based on http://docs.python.org/3.2/library/struct.html
|
||||
# Based on http://docs.python.org/2/library/struct.html
|
||||
|
||||
import sys
|
||||
from typing import Any, Tuple, Text, Union, Iterator
|
||||
from array import array
|
||||
from mmap import mmap
|
||||
|
||||
class error(Exception): ...
|
||||
|
||||
_FmtType = Union[bytes, Text]
|
||||
if sys.version_info >= (3,):
|
||||
_BufferType = Union[array[int], bytes, bytearray, memoryview, mmap]
|
||||
_WriteBufferType = Union[array, bytearray, memoryview, mmap]
|
||||
else:
|
||||
_BufferType = Union[array[int], bytes, bytearray, buffer, memoryview, mmap]
|
||||
_WriteBufferType = Union[array[Any], bytearray, buffer, memoryview, mmap]
|
||||
|
||||
def pack(fmt: _FmtType, *v: Any) -> bytes: ...
|
||||
def pack_into(fmt: _FmtType, buffer: _WriteBufferType, offset: int, *v: Any) -> None: ...
|
||||
def unpack(__format: _FmtType, __buffer: _BufferType) -> Tuple[Any, ...]: ...
|
||||
def unpack_from(__format: _FmtType, buffer: _BufferType, offset: int = ...) -> Tuple[Any, ...]: ...
|
||||
if sys.version_info >= (3, 4):
|
||||
def iter_unpack(__format: _FmtType, __buffer: _BufferType) -> Iterator[Tuple[Any, ...]]: ...
|
||||
|
||||
def calcsize(__format: _FmtType) -> int: ...
|
||||
|
||||
class Struct:
|
||||
if sys.version_info >= (3, 7):
|
||||
format: str
|
||||
else:
|
||||
format: bytes
|
||||
size: int
|
||||
|
||||
def __init__(self, format: _FmtType) -> None: ...
|
||||
|
||||
def pack(self, *v: Any) -> bytes: ...
|
||||
def pack_into(self, buffer: _WriteBufferType, offset: int, *v: Any) -> None: ...
|
||||
def unpack(self, __buffer: _BufferType) -> Tuple[Any, ...]: ...
|
||||
def unpack_from(self, buffer: _BufferType, offset: int = ...) -> Tuple[Any, ...]: ...
|
||||
if sys.version_info >= (3, 4):
|
||||
def iter_unpack(self, __buffer: _BufferType) -> Iterator[Tuple[Any, ...]]: ...
|
||||
@@ -0,0 +1,186 @@
|
||||
# Stubs for tarfile
|
||||
|
||||
from typing import (
|
||||
Callable, IO, Iterable, Iterator, List, Mapping, Optional, Type,
|
||||
Union,
|
||||
)
|
||||
import os
|
||||
import sys
|
||||
from types import TracebackType
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
_Path = Union[bytes, str, os.PathLike]
|
||||
elif sys.version_info >= (3,):
|
||||
_Path = Union[bytes, str]
|
||||
else:
|
||||
_Path = Union[str, unicode]
|
||||
|
||||
ENCODING: str
|
||||
|
||||
USTAR_FORMAT: int
|
||||
GNU_FORMAT: int
|
||||
PAX_FORMAT: int
|
||||
DEFAULT_FORMAT: int
|
||||
|
||||
REGTYPE: bytes
|
||||
AREGTYPE: bytes
|
||||
LNKTYPE: bytes
|
||||
SYMTYPE: bytes
|
||||
DIRTYPE: bytes
|
||||
FIFOTYPE: bytes
|
||||
CONTTYPE: bytes
|
||||
CHRTYPE: bytes
|
||||
BLKTYPE: bytes
|
||||
GNUTYPE_SPARSE: bytes
|
||||
|
||||
if sys.version_info < (3,):
|
||||
TAR_PLAIN: int
|
||||
TAR_GZIPPED: int
|
||||
|
||||
def open(name: Optional[_Path] = ..., mode: str = ...,
|
||||
fileobj: Optional[IO[bytes]] = ..., bufsize: int = ...,
|
||||
*, format: Optional[int] = ..., tarinfo: Optional[TarInfo] = ...,
|
||||
dereference: Optional[bool] = ...,
|
||||
ignore_zeros: Optional[bool] = ...,
|
||||
encoding: Optional[str] = ..., errors: str = ...,
|
||||
pax_headers: Optional[Mapping[str, str]] = ...,
|
||||
debug: Optional[int] = ...,
|
||||
errorlevel: Optional[int] = ...,
|
||||
compresslevel: Optional[int] = ...) -> TarFile: ...
|
||||
|
||||
class TarFile(Iterable[TarInfo]):
|
||||
name: Optional[_Path]
|
||||
mode: str
|
||||
fileobj: Optional[IO[bytes]]
|
||||
format: Optional[int]
|
||||
tarinfo: Optional[TarInfo]
|
||||
dereference: Optional[bool]
|
||||
ignore_zeros: Optional[bool]
|
||||
encoding: Optional[str]
|
||||
errors: str
|
||||
pax_headers: Optional[Mapping[str, str]]
|
||||
debug: Optional[int]
|
||||
errorlevel: Optional[int]
|
||||
if sys.version_info < (3,):
|
||||
posix: bool
|
||||
def __init__(self, name: Optional[_Path] = ..., mode: str = ...,
|
||||
fileobj: Optional[IO[bytes]] = ...,
|
||||
format: Optional[int] = ..., tarinfo: Optional[TarInfo] = ...,
|
||||
dereference: Optional[bool] = ...,
|
||||
ignore_zeros: Optional[bool] = ...,
|
||||
encoding: Optional[str] = ..., errors: str = ...,
|
||||
pax_headers: Optional[Mapping[str, str]] = ...,
|
||||
debug: Optional[int] = ...,
|
||||
errorlevel: Optional[int] = ...,
|
||||
compresslevel: Optional[int] = ...) -> None: ...
|
||||
def __enter__(self) -> TarFile: ...
|
||||
def __exit__(self,
|
||||
exc_type: Optional[Type[BaseException]],
|
||||
exc_val: Optional[BaseException],
|
||||
exc_tb: Optional[TracebackType]) -> None: ...
|
||||
def __iter__(self) -> Iterator[TarInfo]: ...
|
||||
@classmethod
|
||||
def open(cls, name: Optional[_Path] = ..., mode: str = ...,
|
||||
fileobj: Optional[IO[bytes]] = ..., bufsize: int = ...,
|
||||
*, format: Optional[int] = ..., tarinfo: Optional[TarInfo] = ...,
|
||||
dereference: Optional[bool] = ...,
|
||||
ignore_zeros: Optional[bool] = ...,
|
||||
encoding: Optional[str] = ..., errors: str = ...,
|
||||
pax_headers: Optional[Mapping[str, str]] = ...,
|
||||
debug: Optional[int] = ...,
|
||||
errorlevel: Optional[int] = ...) -> TarFile: ...
|
||||
def getmember(self, name: str) -> TarInfo: ...
|
||||
def getmembers(self) -> List[TarInfo]: ...
|
||||
def getnames(self) -> List[str]: ...
|
||||
if sys.version_info >= (3, 5):
|
||||
def list(self, verbose: bool = ...,
|
||||
*, members: Optional[List[TarInfo]] = ...) -> None: ...
|
||||
else:
|
||||
def list(self, verbose: bool = ...) -> None: ...
|
||||
def next(self) -> Optional[TarInfo]: ...
|
||||
if sys.version_info >= (3, 5):
|
||||
def extractall(self, path: _Path = ...,
|
||||
members: Optional[List[TarInfo]] = ...,
|
||||
*, numeric_owner: bool = ...) -> None: ...
|
||||
else:
|
||||
def extractall(self, path: _Path = ...,
|
||||
members: Optional[List[TarInfo]] = ...) -> None: ...
|
||||
if sys.version_info >= (3, 5):
|
||||
def extract(self, member: Union[str, TarInfo], path: _Path = ...,
|
||||
set_attrs: bool = ...,
|
||||
*, numeric_owner: bool = ...) -> None: ...
|
||||
else:
|
||||
def extract(self, member: Union[str, TarInfo],
|
||||
path: _Path = ...) -> None: ...
|
||||
def extractfile(self,
|
||||
member: Union[str, TarInfo]) -> Optional[IO[bytes]]: ...
|
||||
if sys.version_info >= (3, 7):
|
||||
def add(self, name: str, arcname: Optional[str] = ...,
|
||||
recursive: bool = ..., *,
|
||||
filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ...) -> None: ...
|
||||
elif sys.version_info >= (3,):
|
||||
def add(self, name: str, arcname: Optional[str] = ...,
|
||||
recursive: bool = ...,
|
||||
exclude: Optional[Callable[[str], bool]] = ..., *,
|
||||
filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ...) -> None: ...
|
||||
else:
|
||||
def add(self, name: str, arcname: Optional[str] = ...,
|
||||
recursive: bool = ...,
|
||||
exclude: Optional[Callable[[str], bool]] = ...,
|
||||
filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ...) -> None: ...
|
||||
def addfile(self, tarinfo: TarInfo,
|
||||
fileobj: Optional[IO[bytes]] = ...) -> None: ...
|
||||
def gettarinfo(self, name: Optional[str] = ...,
|
||||
arcname: Optional[str] = ...,
|
||||
fileobj: Optional[IO[bytes]] = ...) -> TarInfo: ...
|
||||
def close(self) -> None: ...
|
||||
|
||||
def is_tarfile(name: str) -> bool: ...
|
||||
|
||||
if sys.version_info < (3, 8):
|
||||
def filemode(mode: int) -> str: ... # undocumented
|
||||
|
||||
if sys.version_info < (3,):
|
||||
class TarFileCompat:
|
||||
def __init__(self, filename: str, mode: str = ...,
|
||||
compression: int = ...) -> None: ...
|
||||
|
||||
class TarError(Exception): ...
|
||||
class ReadError(TarError): ...
|
||||
class CompressionError(TarError): ...
|
||||
class StreamError(TarError): ...
|
||||
class ExtractError(TarError): ...
|
||||
class HeaderError(TarError): ...
|
||||
|
||||
class TarInfo:
|
||||
name: str
|
||||
size: int
|
||||
mtime: int
|
||||
mode: int
|
||||
type: bytes
|
||||
linkname: str
|
||||
uid: int
|
||||
gid: int
|
||||
uname: str
|
||||
gname: str
|
||||
pax_headers: Mapping[str, str]
|
||||
def __init__(self, name: str = ...) -> None: ...
|
||||
if sys.version_info >= (3,):
|
||||
@classmethod
|
||||
def frombuf(cls, buf: bytes, encoding: str, errors: str) -> TarInfo: ...
|
||||
else:
|
||||
@classmethod
|
||||
def frombuf(cls, buf: bytes) -> TarInfo: ...
|
||||
@classmethod
|
||||
def fromtarfile(cls, tarfile: TarFile) -> TarInfo: ...
|
||||
def tobuf(self, format: Optional[int] = ...,
|
||||
encoding: Optional[str] = ..., errors: str = ...) -> bytes: ...
|
||||
def isfile(self) -> bool: ...
|
||||
def isreg(self) -> bool: ...
|
||||
def isdir(self) -> bool: ...
|
||||
def issym(self) -> bool: ...
|
||||
def islnk(self) -> bool: ...
|
||||
def ischr(self) -> bool: ...
|
||||
def isblk(self) -> bool: ...
|
||||
def isfifo(self) -> bool: ...
|
||||
def isdev(self) -> bool: ...
|
||||
@@ -0,0 +1,248 @@
|
||||
# Stubs for termios
|
||||
|
||||
from typing import IO, List, Union
|
||||
from _types import FileDescriptorLike
|
||||
|
||||
_Attr = List[Union[int, List[bytes]]]
|
||||
|
||||
# TODO constants not really documented
|
||||
B0: int
|
||||
B1000000: int
|
||||
B110: int
|
||||
B115200: int
|
||||
B1152000: int
|
||||
B1200: int
|
||||
B134: int
|
||||
B150: int
|
||||
B1500000: int
|
||||
B1800: int
|
||||
B19200: int
|
||||
B200: int
|
||||
B2000000: int
|
||||
B230400: int
|
||||
B2400: int
|
||||
B2500000: int
|
||||
B300: int
|
||||
B3000000: int
|
||||
B3500000: int
|
||||
B38400: int
|
||||
B4000000: int
|
||||
B460800: int
|
||||
B4800: int
|
||||
B50: int
|
||||
B500000: int
|
||||
B57600: int
|
||||
B576000: int
|
||||
B600: int
|
||||
B75: int
|
||||
B921600: int
|
||||
B9600: int
|
||||
BRKINT: int
|
||||
BS0: int
|
||||
BS1: int
|
||||
BSDLY: int
|
||||
CBAUD: int
|
||||
CBAUDEX: int
|
||||
CDSUSP: int
|
||||
CEOF: int
|
||||
CEOL: int
|
||||
CEOT: int
|
||||
CERASE: int
|
||||
CFLUSH: int
|
||||
CIBAUD: int
|
||||
CINTR: int
|
||||
CKILL: int
|
||||
CLNEXT: int
|
||||
CLOCAL: int
|
||||
CQUIT: int
|
||||
CR0: int
|
||||
CR1: int
|
||||
CR2: int
|
||||
CR3: int
|
||||
CRDLY: int
|
||||
CREAD: int
|
||||
CRPRNT: int
|
||||
CRTSCTS: int
|
||||
CS5: int
|
||||
CS6: int
|
||||
CS7: int
|
||||
CS8: int
|
||||
CSIZE: int
|
||||
CSTART: int
|
||||
CSTOP: int
|
||||
CSTOPB: int
|
||||
CSUSP: int
|
||||
CWERASE: int
|
||||
ECHO: int
|
||||
ECHOCTL: int
|
||||
ECHOE: int
|
||||
ECHOK: int
|
||||
ECHOKE: int
|
||||
ECHONL: int
|
||||
ECHOPRT: int
|
||||
EXTA: int
|
||||
EXTB: int
|
||||
FF0: int
|
||||
FF1: int
|
||||
FFDLY: int
|
||||
FIOASYNC: int
|
||||
FIOCLEX: int
|
||||
FIONBIO: int
|
||||
FIONCLEX: int
|
||||
FIONREAD: int
|
||||
FLUSHO: int
|
||||
HUPCL: int
|
||||
ICANON: int
|
||||
ICRNL: int
|
||||
IEXTEN: int
|
||||
IGNBRK: int
|
||||
IGNCR: int
|
||||
IGNPAR: int
|
||||
IMAXBEL: int
|
||||
INLCR: int
|
||||
INPCK: int
|
||||
IOCSIZE_MASK: int
|
||||
IOCSIZE_SHIFT: int
|
||||
ISIG: int
|
||||
ISTRIP: int
|
||||
IUCLC: int
|
||||
IXANY: int
|
||||
IXOFF: int
|
||||
IXON: int
|
||||
NCC: int
|
||||
NCCS: int
|
||||
NL0: int
|
||||
NL1: int
|
||||
NLDLY: int
|
||||
NOFLSH: int
|
||||
N_MOUSE: int
|
||||
N_PPP: int
|
||||
N_SLIP: int
|
||||
N_STRIP: int
|
||||
N_TTY: int
|
||||
OCRNL: int
|
||||
OFDEL: int
|
||||
OFILL: int
|
||||
OLCUC: int
|
||||
ONLCR: int
|
||||
ONLRET: int
|
||||
ONOCR: int
|
||||
OPOST: int
|
||||
PARENB: int
|
||||
PARMRK: int
|
||||
PARODD: int
|
||||
PENDIN: int
|
||||
TAB0: int
|
||||
TAB1: int
|
||||
TAB2: int
|
||||
TAB3: int
|
||||
TABDLY: int
|
||||
TCFLSH: int
|
||||
TCGETA: int
|
||||
TCGETS: int
|
||||
TCIFLUSH: int
|
||||
TCIOFF: int
|
||||
TCIOFLUSH: int
|
||||
TCION: int
|
||||
TCOFLUSH: int
|
||||
TCOOFF: int
|
||||
TCOON: int
|
||||
TCSADRAIN: int
|
||||
TCSAFLUSH: int
|
||||
TCSANOW: int
|
||||
TCSBRK: int
|
||||
TCSBRKP: int
|
||||
TCSETA: int
|
||||
TCSETAF: int
|
||||
TCSETAW: int
|
||||
TCSETS: int
|
||||
TCSETSF: int
|
||||
TCSETSW: int
|
||||
TCXONC: int
|
||||
TIOCCONS: int
|
||||
TIOCEXCL: int
|
||||
TIOCGETD: int
|
||||
TIOCGICOUNT: int
|
||||
TIOCGLCKTRMIOS: int
|
||||
TIOCGPGRP: int
|
||||
TIOCGSERIAL: int
|
||||
TIOCGSOFTCAR: int
|
||||
TIOCGWINSZ: int
|
||||
TIOCINQ: int
|
||||
TIOCLINUX: int
|
||||
TIOCMBIC: int
|
||||
TIOCMBIS: int
|
||||
TIOCMGET: int
|
||||
TIOCMIWAIT: int
|
||||
TIOCMSET: int
|
||||
TIOCM_CAR: int
|
||||
TIOCM_CD: int
|
||||
TIOCM_CTS: int
|
||||
TIOCM_DSR: int
|
||||
TIOCM_DTR: int
|
||||
TIOCM_LE: int
|
||||
TIOCM_RI: int
|
||||
TIOCM_RNG: int
|
||||
TIOCM_RTS: int
|
||||
TIOCM_SR: int
|
||||
TIOCM_ST: int
|
||||
TIOCNOTTY: int
|
||||
TIOCNXCL: int
|
||||
TIOCOUTQ: int
|
||||
TIOCPKT: int
|
||||
TIOCPKT_DATA: int
|
||||
TIOCPKT_DOSTOP: int
|
||||
TIOCPKT_FLUSHREAD: int
|
||||
TIOCPKT_FLUSHWRITE: int
|
||||
TIOCPKT_NOSTOP: int
|
||||
TIOCPKT_START: int
|
||||
TIOCPKT_STOP: int
|
||||
TIOCSCTTY: int
|
||||
TIOCSERCONFIG: int
|
||||
TIOCSERGETLSR: int
|
||||
TIOCSERGETMULTI: int
|
||||
TIOCSERGSTRUCT: int
|
||||
TIOCSERGWILD: int
|
||||
TIOCSERSETMULTI: int
|
||||
TIOCSERSWILD: int
|
||||
TIOCSER_TEMT: int
|
||||
TIOCSETD: int
|
||||
TIOCSLCKTRMIOS: int
|
||||
TIOCSPGRP: int
|
||||
TIOCSSERIAL: int
|
||||
TIOCSSOFTCAR: int
|
||||
TIOCSTI: int
|
||||
TIOCSWINSZ: int
|
||||
TOSTOP: int
|
||||
VDISCARD: int
|
||||
VEOF: int
|
||||
VEOL: int
|
||||
VEOL2: int
|
||||
VERASE: int
|
||||
VINTR: int
|
||||
VKILL: int
|
||||
VLNEXT: int
|
||||
VMIN: int
|
||||
VQUIT: int
|
||||
VREPRINT: int
|
||||
VSTART: int
|
||||
VSTOP: int
|
||||
VSUSP: int
|
||||
VSWTC: int
|
||||
VSWTCH: int
|
||||
VT0: int
|
||||
VT1: int
|
||||
VTDLY: int
|
||||
VTIME: int
|
||||
VWERASE: int
|
||||
XCASE: int
|
||||
XTABS: int
|
||||
|
||||
def tcgetattr(fd: FileDescriptorLike) -> _Attr: ...
|
||||
def tcsetattr(fd: FileDescriptorLike, when: int, attributes: _Attr) -> None: ...
|
||||
def tcsendbreak(fd: FileDescriptorLike, duration: int) -> None: ...
|
||||
def tcdrain(fd: FileDescriptorLike) -> None: ...
|
||||
def tcflush(fd: FileDescriptorLike, queue: int) -> None: ...
|
||||
def tcflow(fd: FileDescriptorLike, action: int) -> None: ...
|
||||
|
||||
class error(Exception): ...
|
||||
@@ -0,0 +1,5 @@
|
||||
|
||||
from typing import Dict
|
||||
|
||||
s: str
|
||||
d: Dict[str, str]
|
||||
@@ -0,0 +1,67 @@
|
||||
import sys
|
||||
from types import ModuleType, TracebackType
|
||||
from typing import Any, List, NamedTuple, Optional, TextIO, Type, overload
|
||||
|
||||
from typing_extensions import Literal
|
||||
|
||||
from _warnings import warn as warn, warn_explicit as warn_explicit
|
||||
|
||||
def showwarning(
|
||||
message: str, category: Type[Warning], filename: str, lineno: int, file: Optional[TextIO] = ..., line: Optional[str] = ...
|
||||
) -> None: ...
|
||||
def formatwarning(message: str, category: Type[Warning], filename: str, lineno: int, line: Optional[str] = ...) -> str: ...
|
||||
def filterwarnings(
|
||||
action: str, message: str = ..., category: Type[Warning] = ..., module: str = ..., lineno: int = ..., append: bool = ...
|
||||
) -> None: ...
|
||||
def simplefilter(action: str, category: Type[Warning] = ..., lineno: int = ..., append: bool = ...) -> None: ...
|
||||
def resetwarnings() -> None: ...
|
||||
|
||||
class _OptionError(Exception): ...
|
||||
|
||||
class WarningMessage:
|
||||
message: Warning
|
||||
category: Type[Warning]
|
||||
filename: str
|
||||
lineno: int
|
||||
file: Optional[TextIO]
|
||||
line: Optional[str]
|
||||
if sys.version_info >= (3, 6):
|
||||
source: Optional[Any]
|
||||
def __init__(
|
||||
self,
|
||||
message: Warning,
|
||||
category: Type[Warning],
|
||||
filename: str,
|
||||
lineno: int,
|
||||
file: Optional[TextIO] = ...,
|
||||
line: Optional[str] = ...,
|
||||
source: Optional[Any] = ...,
|
||||
) -> None: ...
|
||||
else:
|
||||
def __init__(
|
||||
self,
|
||||
message: Warning,
|
||||
category: Type[Warning],
|
||||
filename: str,
|
||||
lineno: int,
|
||||
file: Optional[TextIO] = ...,
|
||||
line: Optional[str] = ...,
|
||||
) -> None: ...
|
||||
|
||||
class catch_warnings:
|
||||
@overload
|
||||
def __new__(cls, *, record: Literal[False] = ..., module: Optional[ModuleType] = ...) -> _catch_warnings_without_records: ...
|
||||
@overload
|
||||
def __new__(cls, *, record: Literal[True], module: Optional[ModuleType] = ...) -> _catch_warnings_with_records: ...
|
||||
@overload
|
||||
def __new__(cls, *, record: bool, module: Optional[ModuleType] = ...) -> catch_warnings: ...
|
||||
def __enter__(self) -> Optional[List[WarningMessage]]: ...
|
||||
def __exit__(
|
||||
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
|
||||
) -> None: ...
|
||||
|
||||
class _catch_warnings_without_records(catch_warnings):
|
||||
def __enter__(self) -> None: ...
|
||||
|
||||
class _catch_warnings_with_records(catch_warnings):
|
||||
def __enter__(self) -> List[WarningMessage]: ...
|
||||
@@ -0,0 +1,32 @@
|
||||
|
||||
import sys
|
||||
from typing import Optional, Union, overload
|
||||
if sys.version_info >= (3, 8):
|
||||
from typing import Literal
|
||||
else:
|
||||
from typing_extensions import Literal
|
||||
|
||||
if sys.platform == "win32":
|
||||
SND_FILENAME: int
|
||||
SND_ALIAS: int
|
||||
SND_LOOP: int
|
||||
SND_MEMORY: int
|
||||
SND_PURGE: int
|
||||
SND_ASYNC: int
|
||||
SND_NODEFAULT: int
|
||||
SND_NOSTOP: int
|
||||
SND_NOWAIT: int
|
||||
|
||||
MB_ICONASTERISK: int
|
||||
MB_ICONEXCLAMATION: int
|
||||
MB_ICONHAND: int
|
||||
MB_ICONQUESTION: int
|
||||
MB_OK: int
|
||||
|
||||
def Beep(frequency: int, duration: int) -> None: ...
|
||||
# Can actually accept anything ORed with 4, and if not it's definitely str, but that's inexpressible
|
||||
@overload
|
||||
def PlaySound(sound: Optional[bytes], flags: Literal[4]) -> None: ...
|
||||
@overload
|
||||
def PlaySound(sound: Optional[Union[str, bytes]], flags: int) -> None: ...
|
||||
def MessageBeep(type: int = ...) -> None: ...
|
||||
@@ -0,0 +1,195 @@
|
||||
# Stubs for zipfile
|
||||
|
||||
from typing import Any, Callable, Dict, IO, Iterable, Iterator, List, Optional, Protocol, Text, Tuple, Type, Union, Sequence, Pattern
|
||||
from types import TracebackType
|
||||
import io
|
||||
import os
|
||||
import sys
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
_Path = Union[os.PathLike[str], str]
|
||||
else:
|
||||
_Path = Text
|
||||
_SZI = Union[Text, ZipInfo]
|
||||
_DT = Tuple[int, int, int, int, int, int]
|
||||
|
||||
if sys.version_info >= (3,):
|
||||
class BadZipFile(Exception): ...
|
||||
BadZipfile = BadZipFile
|
||||
else:
|
||||
class BadZipfile(Exception): ...
|
||||
|
||||
error = BadZipfile
|
||||
|
||||
class LargeZipFile(Exception): ...
|
||||
|
||||
class ZipExtFile(io.BufferedIOBase):
|
||||
MAX_N: int = ...
|
||||
MIN_READ_SIZE: int = ...
|
||||
|
||||
if sys.version_info < (3, 6):
|
||||
PATTERN: Pattern[str] = ...
|
||||
|
||||
if sys.version_info >= (3, 7):
|
||||
MAX_SEEK_READ: int = ...
|
||||
|
||||
newlines: Optional[List[bytes]]
|
||||
mode: str
|
||||
name: str
|
||||
if sys.version_info >= (3, 7):
|
||||
def __init__(
|
||||
self,
|
||||
fileobj: IO[bytes],
|
||||
mode: str,
|
||||
zipinfo: ZipInfo,
|
||||
pwd: Optional[bytes] = ...,
|
||||
close_fileobj: bool = ...,
|
||||
) -> None: ...
|
||||
else:
|
||||
def __init__(
|
||||
self,
|
||||
fileobj: IO[bytes],
|
||||
mode: str,
|
||||
zipinfo: ZipInfo,
|
||||
decrypter: Optional[Callable[[Sequence[int]], bytes]] = ...,
|
||||
close_fileobj: bool = ...,
|
||||
) -> None: ...
|
||||
def __repr__(self) -> str: ...
|
||||
def peek(self, n: int = ...) -> bytes: ...
|
||||
def read1(self, n: Optional[int]) -> bytes: ... # type: ignore
|
||||
|
||||
class _Writer(Protocol):
|
||||
def write(self, __s: str) -> Any: ...
|
||||
|
||||
class ZipFile:
|
||||
filename: Optional[Text]
|
||||
debug: int
|
||||
comment: bytes
|
||||
filelist: List[ZipInfo]
|
||||
fp: Optional[IO[bytes]]
|
||||
NameToInfo: Dict[Text, ZipInfo]
|
||||
start_dir: int # undocumented
|
||||
if sys.version_info >= (3, 8):
|
||||
def __init__(
|
||||
self,
|
||||
file: Union[_Path, IO[bytes]],
|
||||
mode: str = ...,
|
||||
compression: int = ...,
|
||||
allowZip64: bool = ...,
|
||||
compresslevel: Optional[int] = ...,
|
||||
*,
|
||||
strict_timestamps: bool = ...,
|
||||
) -> None: ...
|
||||
elif sys.version_info >= (3, 7):
|
||||
def __init__(
|
||||
self,
|
||||
file: Union[_Path, IO[bytes]],
|
||||
mode: str = ...,
|
||||
compression: int = ...,
|
||||
allowZip64: bool = ...,
|
||||
compresslevel: Optional[int] = ...,
|
||||
) -> None: ...
|
||||
else:
|
||||
def __init__(
|
||||
self, file: Union[_Path, IO[bytes]], mode: Text = ..., compression: int = ..., allowZip64: bool = ...
|
||||
) -> None: ...
|
||||
def __enter__(self) -> ZipFile: ...
|
||||
def __exit__(
|
||||
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
|
||||
) -> None: ...
|
||||
def close(self) -> None: ...
|
||||
def getinfo(self, name: Text) -> ZipInfo: ...
|
||||
def infolist(self) -> List[ZipInfo]: ...
|
||||
def namelist(self) -> List[Text]: ...
|
||||
def open(self, name: _SZI, mode: Text = ..., pwd: Optional[bytes] = ..., *, force_zip64: bool = ...) -> IO[bytes]: ...
|
||||
def extract(self, member: _SZI, path: Optional[_SZI] = ..., pwd: Optional[bytes] = ...) -> str: ...
|
||||
def extractall(
|
||||
self, path: Optional[_Path] = ..., members: Optional[Iterable[Text]] = ..., pwd: Optional[bytes] = ...
|
||||
) -> None: ...
|
||||
if sys.version_info >= (3,):
|
||||
def printdir(self, file: Optional[_Writer] = ...) -> None: ...
|
||||
else:
|
||||
def printdir(self) -> None: ...
|
||||
def setpassword(self, pwd: bytes) -> None: ...
|
||||
def read(self, name: _SZI, pwd: Optional[bytes] = ...) -> bytes: ...
|
||||
def testzip(self) -> Optional[str]: ...
|
||||
if sys.version_info >= (3, 7):
|
||||
def write(self, filename: _Path, arcname: Optional[_Path] = ..., compress_type: Optional[int] = ..., compresslevel: Optional[int] = ...) -> None: ...
|
||||
else:
|
||||
def write(self, filename: _Path, arcname: Optional[_Path] = ..., compress_type: Optional[int] = ...) -> None: ...
|
||||
if sys.version_info >= (3, 7):
|
||||
def writestr(self, zinfo_or_arcname: _SZI, data: Union[bytes, str], compress_type: Optional[int] = ..., compresslevel: Optional[int] = ...) -> None: ...
|
||||
elif sys.version_info >= (3,):
|
||||
def writestr(self, zinfo_or_arcname: _SZI, data: Union[bytes, str], compress_type: Optional[int] = ...) -> None: ...
|
||||
else:
|
||||
def writestr(self, zinfo_or_arcname: _SZI, bytes: bytes, compress_type: Optional[int] = ...) -> None: ...
|
||||
|
||||
class PyZipFile(ZipFile):
|
||||
if sys.version_info >= (3,):
|
||||
def __init__(
|
||||
self, file: Union[str, IO[bytes]], mode: str = ..., compression: int = ..., allowZip64: bool = ..., optimize: int = ...
|
||||
) -> None: ...
|
||||
def writepy(self, pathname: str, basename: str = ..., filterfunc: Optional[Callable[[str], bool]] = ...) -> None: ...
|
||||
else:
|
||||
def writepy(self, pathname: Text, basename: Text = ...) -> None: ...
|
||||
|
||||
class ZipInfo:
|
||||
filename: Text
|
||||
date_time: _DT
|
||||
compress_type: int
|
||||
comment: bytes
|
||||
extra: bytes
|
||||
create_system: int
|
||||
create_version: int
|
||||
extract_version: int
|
||||
reserved: int
|
||||
flag_bits: int
|
||||
volume: int
|
||||
internal_attr: int
|
||||
external_attr: int
|
||||
header_offset: int
|
||||
CRC: int
|
||||
compress_size: int
|
||||
file_size: int
|
||||
def __init__(self, filename: Optional[Text] = ..., date_time: Optional[_DT] = ...) -> None: ...
|
||||
if sys.version_info >= (3, 8):
|
||||
@classmethod
|
||||
def from_file(cls, filename: _Path, arcname: Optional[_Path] = ..., *, strict_timestamps: bool = ...) -> ZipInfo: ...
|
||||
elif sys.version_info >= (3, 6):
|
||||
@classmethod
|
||||
def from_file(cls, filename: _Path, arcname: Optional[_Path] = ...) -> ZipInfo: ...
|
||||
if sys.version_info >= (3, 6):
|
||||
def is_dir(self) -> bool: ...
|
||||
def FileHeader(self, zip64: Optional[bool] = ...) -> bytes: ...
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
class Path:
|
||||
@property
|
||||
def name(self) -> str: ...
|
||||
@property
|
||||
def parent(self) -> Path: ... # undocumented
|
||||
def __init__(self, root: Union[ZipFile, _Path, IO[bytes]], at: str = ...) -> None: ...
|
||||
def open(self, mode: str = ..., pwd: Optional[bytes] = ..., *, force_zip64: bool = ...) -> IO[bytes]: ...
|
||||
def iterdir(self) -> Iterator[Path]: ...
|
||||
def is_dir(self) -> bool: ...
|
||||
def is_file(self) -> bool: ...
|
||||
def exists(self) -> bool: ...
|
||||
def read_text(
|
||||
self,
|
||||
encoding: Optional[str] = ...,
|
||||
errors: Optional[str] = ...,
|
||||
newline: Optional[str] = ...,
|
||||
line_buffering: bool = ...,
|
||||
write_through: bool = ...,
|
||||
) -> str: ...
|
||||
def read_bytes(self) -> bytes: ...
|
||||
def joinpath(self, add: _Path) -> Path: ... # undocumented
|
||||
def __truediv__(self, add: _Path) -> Path: ...
|
||||
|
||||
def is_zipfile(filename: Union[_Path, IO[bytes]]) -> bool: ...
|
||||
|
||||
ZIP_STORED: int
|
||||
ZIP_DEFLATED: int
|
||||
if sys.version_info >= (3, 3):
|
||||
ZIP_BZIP2: int
|
||||
ZIP_LZMA: int
|
||||
@@ -0,0 +1,14 @@
|
||||
import io
|
||||
import sys
|
||||
from typing import Union, Protocol
|
||||
from _types import FileDescriptorLike
|
||||
|
||||
def cancel_dump_traceback_later() -> None: ...
|
||||
def disable() -> None: ...
|
||||
def dump_traceback(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ...
|
||||
def dump_traceback_later(timeout: float, repeat: bool = ..., file: FileDescriptorLike = ..., exit: bool = ...) -> None: ...
|
||||
def enable(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ...
|
||||
def is_enabled() -> bool: ...
|
||||
if sys.platform != "win32":
|
||||
def register(signum: int, file: FileDescriptorLike = ..., all_threads: bool = ..., chain: bool = ...) -> None: ...
|
||||
def unregister(signum: int) -> None: ...
|
||||
@@ -0,0 +1,62 @@
|
||||
import sys
|
||||
from typing import overload, Any, Container, IO, Iterable, Optional, Type, TypeVar
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
from typing import Literal
|
||||
else:
|
||||
from typing_extensions import Literal
|
||||
|
||||
class NullTranslations:
|
||||
def __init__(self, fp: IO[str] = ...) -> None: ...
|
||||
def _parse(self, fp: IO[str]) -> None: ...
|
||||
def add_fallback(self, fallback: NullTranslations) -> None: ...
|
||||
def gettext(self, message: str) -> str: ...
|
||||
def lgettext(self, message: str) -> str: ...
|
||||
def ngettext(self, singular: str, plural: str, n: int) -> str: ...
|
||||
def lngettext(self, singular: str, plural: str, n: int) -> str: ...
|
||||
def pgettext(self, context: str, message: str) -> str: ...
|
||||
def npgettext(self, context: str, msgid1: str, msgid2: str, n: int) -> str: ...
|
||||
def info(self) -> Any: ...
|
||||
def charset(self) -> Any: ...
|
||||
def output_charset(self) -> Any: ...
|
||||
def set_output_charset(self, charset: str) -> None: ...
|
||||
def install(self, names: Optional[Container[str]] = ...) -> None: ...
|
||||
|
||||
class GNUTranslations(NullTranslations):
|
||||
LE_MAGIC: int
|
||||
BE_MAGIC: int
|
||||
|
||||
def find(domain: str, localedir: Optional[str] = ..., languages: Optional[Iterable[str]] = ...,
|
||||
all: bool = ...) -> Any: ...
|
||||
|
||||
_T = TypeVar('_T')
|
||||
@overload
|
||||
def translation(domain: str, localedir: Optional[str] = ..., languages: Optional[Iterable[str]] = ...,
|
||||
class_: None = ..., fallback: bool = ..., codeset: Optional[str] = ...) -> NullTranslations: ...
|
||||
@overload
|
||||
def translation(domain: str, localedir: Optional[str] = ..., languages: Optional[Iterable[str]] = ...,
|
||||
class_: Type[_T] = ..., fallback: Literal[False] = ..., codeset: Optional[str] = ...) -> _T: ...
|
||||
@overload
|
||||
def translation(domain: str, localedir: Optional[str] = ..., languages: Optional[Iterable[str]] = ...,
|
||||
class_: Type[_T] = ..., fallback: Literal[True] = ..., codeset: Optional[str] = ...) -> Any: ...
|
||||
|
||||
def install(domain: str, localedir: Optional[str] = ..., codeset: Optional[str] = ...,
|
||||
names: Optional[Container[str]] = ...) -> None: ...
|
||||
|
||||
def textdomain(domain: Optional[str] = ...) -> str: ...
|
||||
def bindtextdomain(domain: str, localedir: Optional[str] = ...) -> str: ...
|
||||
def bind_textdomain_codeset(domain: str, codeset: Optional[str] = ...) -> str: ...
|
||||
def dgettext(domain: str, message: str) -> str: ...
|
||||
def ldgettext(domain: str, message: str) -> str: ...
|
||||
def dngettext(domain: str, singular: str, plural: str, n: int) -> str: ...
|
||||
def ldngettext(domain: str, singular: str, plural: str, n: int) -> str: ...
|
||||
def gettext(message: str) -> str: ...
|
||||
def lgettext(message: str) -> str: ...
|
||||
def ngettext(singular: str, plural: str, n: int) -> str: ...
|
||||
def lngettext(singular: str, plural: str, n: int) -> str: ...
|
||||
def pgettext(context: str, message: str) -> str: ...
|
||||
def dpgettext(domain: str, context: str, message: str) -> str: ...
|
||||
def npgettext(context: str, msgid1: str, msgid2: str, n: int) -> str: ...
|
||||
def dnpgettext(domain: str, context: str, msgid1: str, msgid2: str, n: int) -> str: ...
|
||||
|
||||
Catalog = translation
|
||||
@@ -0,0 +1,16 @@
|
||||
from importlib.abc import Loader
|
||||
import types
|
||||
from typing import Any, Mapping, Optional, Sequence
|
||||
|
||||
def __import__(name: str, globals: Optional[Mapping[str, Any]] = ...,
|
||||
locals: Optional[Mapping[str, Any]] = ...,
|
||||
fromlist: Sequence[str] = ...,
|
||||
level: int = ...) -> types.ModuleType: ...
|
||||
|
||||
def import_module(name: str, package: Optional[str] = ...) -> types.ModuleType: ...
|
||||
|
||||
def find_loader(name: str, path: Optional[str] = ...) -> Optional[Loader]: ...
|
||||
|
||||
def invalidate_caches() -> None: ...
|
||||
|
||||
def reload(module: types.ModuleType) -> types.ModuleType: ...
|
||||
@@ -0,0 +1,92 @@
|
||||
from abc import ABCMeta, abstractmethod
|
||||
import os
|
||||
import sys
|
||||
import types
|
||||
from typing import Any, IO, Iterator, Mapping, Optional, Sequence, Tuple, Union
|
||||
|
||||
# Loader is exported from this module, but for circular import reasons
|
||||
# exists in its own stub file (with ModuleSpec and ModuleType).
|
||||
from _importlib_modulespec import Loader as Loader # Exported
|
||||
|
||||
from _importlib_modulespec import ModuleSpec
|
||||
|
||||
_Path = Union[bytes, str]
|
||||
|
||||
class Finder(metaclass=ABCMeta):
|
||||
...
|
||||
# Technically this class defines the following method, but its subclasses
|
||||
# in this module violate its signature. Since this class is deprecated, it's
|
||||
# easier to simply ignore that this method exists.
|
||||
# @abstractmethod
|
||||
# def find_module(self, fullname: str,
|
||||
# path: Optional[Sequence[_Path]] = ...) -> Optional[Loader]: ...
|
||||
|
||||
class ResourceLoader(Loader):
|
||||
@abstractmethod
|
||||
def get_data(self, path: _Path) -> bytes: ...
|
||||
|
||||
class InspectLoader(Loader):
|
||||
def is_package(self, fullname: str) -> bool: ...
|
||||
def get_code(self, fullname: str) -> Optional[types.CodeType]: ...
|
||||
def load_module(self, fullname: str) -> types.ModuleType: ...
|
||||
@abstractmethod
|
||||
def get_source(self, fullname: str) -> Optional[str]: ...
|
||||
def exec_module(self, module: types.ModuleType) -> None: ...
|
||||
@staticmethod
|
||||
def source_to_code(data: Union[bytes, str], path: str = ...) -> types.CodeType: ...
|
||||
|
||||
class ExecutionLoader(InspectLoader):
|
||||
@abstractmethod
|
||||
def get_filename(self, fullname: str) -> _Path: ...
|
||||
def get_code(self, fullname: str) -> Optional[types.CodeType]: ...
|
||||
|
||||
class SourceLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta):
|
||||
def path_mtime(self, path: _Path) -> float: ...
|
||||
def set_data(self, path: _Path, data: bytes) -> None: ...
|
||||
def get_source(self, fullname: str) -> Optional[str]: ...
|
||||
def path_stats(self, path: _Path) -> Mapping[str, Any]: ...
|
||||
|
||||
|
||||
class MetaPathFinder(Finder):
|
||||
def find_module(self, fullname: str,
|
||||
path: Optional[Sequence[_Path]]) -> Optional[Loader]:
|
||||
...
|
||||
def invalidate_caches(self) -> None: ...
|
||||
# Not defined on the actual class, but expected to exist.
|
||||
def find_spec(
|
||||
self, fullname: str, path: Optional[Sequence[_Path]],
|
||||
target: Optional[types.ModuleType] = ...
|
||||
) -> Optional[ModuleSpec]:
|
||||
...
|
||||
|
||||
class PathEntryFinder(Finder):
|
||||
def find_module(self, fullname: str) -> Optional[Loader]: ...
|
||||
def find_loader(
|
||||
self, fullname: str
|
||||
) -> Tuple[Optional[Loader], Sequence[_Path]]: ...
|
||||
def invalidate_caches(self) -> None: ...
|
||||
# Not defined on the actual class, but expected to exist.
|
||||
def find_spec(
|
||||
self, fullname: str,
|
||||
target: Optional[types.ModuleType] = ...
|
||||
) -> Optional[ModuleSpec]: ...
|
||||
|
||||
class FileLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta):
|
||||
name: str
|
||||
path: _Path
|
||||
def __init__(self, fullname: str, path: _Path) -> None: ...
|
||||
def get_data(self, path: _Path) -> bytes: ...
|
||||
def get_filename(self, fullname: str) -> _Path: ...
|
||||
|
||||
if sys.version_info >= (3, 7):
|
||||
_PathLike = Union[bytes, str, os.PathLike[Any]]
|
||||
|
||||
class ResourceReader(metaclass=ABCMeta):
|
||||
@abstractmethod
|
||||
def open_resource(self, resource: _PathLike) -> IO[bytes]: ...
|
||||
@abstractmethod
|
||||
def resource_path(self, resource: _PathLike) -> str: ...
|
||||
@abstractmethod
|
||||
def is_resource(self, name: str) -> bool: ...
|
||||
@abstractmethod
|
||||
def contents(self) -> Iterator[str]: ...
|
||||
@@ -0,0 +1,115 @@
|
||||
import importlib.abc
|
||||
import types
|
||||
from typing import Any, Callable, List, Optional, Sequence, Tuple
|
||||
|
||||
# ModuleSpec is exported from this module, but for circular import
|
||||
# reasons exists in its own stub file (with Loader and ModuleType).
|
||||
from _importlib_modulespec import ModuleSpec as ModuleSpec # Exported
|
||||
|
||||
class BuiltinImporter(importlib.abc.MetaPathFinder,
|
||||
importlib.abc.InspectLoader):
|
||||
# MetaPathFinder
|
||||
@classmethod
|
||||
def find_module(
|
||||
cls, fullname: str,
|
||||
path: Optional[Sequence[importlib.abc._Path]]
|
||||
) -> Optional[importlib.abc.Loader]:
|
||||
...
|
||||
@classmethod
|
||||
def find_spec(cls, fullname: str,
|
||||
path: Optional[Sequence[importlib.abc._Path]],
|
||||
target: Optional[types.ModuleType] = ...) -> Optional[ModuleSpec]:
|
||||
...
|
||||
# InspectLoader
|
||||
@classmethod
|
||||
def is_package(cls, fullname: str) -> bool: ...
|
||||
@classmethod
|
||||
def load_module(cls, fullname: str) -> types.ModuleType: ...
|
||||
@classmethod
|
||||
def get_code(cls, fullname: str) -> None: ...
|
||||
@classmethod
|
||||
def get_source(cls, fullname: str) -> None: ...
|
||||
# Loader
|
||||
@staticmethod
|
||||
def module_repr(module: types.ModuleType) -> str: ...
|
||||
@classmethod
|
||||
def create_module(cls, spec: ModuleSpec) -> Optional[types.ModuleType]: ...
|
||||
@classmethod
|
||||
def exec_module(cls, module: types.ModuleType) -> None: ...
|
||||
|
||||
class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
|
||||
# MetaPathFinder
|
||||
@classmethod
|
||||
def find_module(
|
||||
cls, fullname: str,
|
||||
path: Optional[Sequence[importlib.abc._Path]]
|
||||
) -> Optional[importlib.abc.Loader]:
|
||||
...
|
||||
@classmethod
|
||||
def find_spec(cls, fullname: str,
|
||||
path: Optional[Sequence[importlib.abc._Path]],
|
||||
target: Optional[types.ModuleType] = ...) -> Optional[ModuleSpec]:
|
||||
...
|
||||
# InspectLoader
|
||||
@classmethod
|
||||
def is_package(cls, fullname: str) -> bool: ...
|
||||
@classmethod
|
||||
def load_module(cls, fullname: str) -> types.ModuleType: ...
|
||||
@classmethod
|
||||
def get_code(cls, fullname: str) -> None: ...
|
||||
@classmethod
|
||||
def get_source(cls, fullname: str) -> None: ...
|
||||
# Loader
|
||||
@staticmethod
|
||||
def module_repr(module: types.ModuleType) -> str: ...
|
||||
@classmethod
|
||||
def create_module(cls, spec: ModuleSpec) -> Optional[types.ModuleType]:
|
||||
...
|
||||
@staticmethod
|
||||
def exec_module(module: types.ModuleType) -> None: ...
|
||||
|
||||
class WindowsRegistryFinder(importlib.abc.MetaPathFinder):
|
||||
@classmethod
|
||||
def find_module(
|
||||
cls, fullname: str,
|
||||
path: Optional[Sequence[importlib.abc._Path]]
|
||||
) -> Optional[importlib.abc.Loader]:
|
||||
...
|
||||
@classmethod
|
||||
def find_spec(cls, fullname: str,
|
||||
path: Optional[Sequence[importlib.abc._Path]],
|
||||
target: Optional[types.ModuleType] = ...) -> Optional[ModuleSpec]:
|
||||
...
|
||||
|
||||
class PathFinder(importlib.abc.MetaPathFinder): ...
|
||||
|
||||
SOURCE_SUFFIXES: List[str]
|
||||
DEBUG_BYTECODE_SUFFIXES: List[str]
|
||||
OPTIMIZED_BYTECODE_SUFFIXES: List[str]
|
||||
BYTECODE_SUFFIXES: List[str]
|
||||
EXTENSION_SUFFIXES: List[str]
|
||||
|
||||
def all_suffixes() -> List[str]: ...
|
||||
|
||||
class FileFinder(importlib.abc.PathEntryFinder):
|
||||
path: str
|
||||
def __init__(
|
||||
self, path: str,
|
||||
*loader_details: Tuple[importlib.abc.Loader, List[str]]
|
||||
) -> None: ...
|
||||
@classmethod
|
||||
def path_hook(
|
||||
cls, *loader_details: Tuple[importlib.abc.Loader, List[str]]
|
||||
) -> Callable[[str], importlib.abc.PathEntryFinder]: ...
|
||||
|
||||
class SourceFileLoader(importlib.abc.FileLoader,
|
||||
importlib.abc.SourceLoader):
|
||||
...
|
||||
|
||||
class SourcelessFileLoader(importlib.abc.FileLoader,
|
||||
importlib.abc.SourceLoader):
|
||||
...
|
||||
|
||||
class ExtensionFileLoader(importlib.abc.ExecutionLoader):
|
||||
def get_filename(self, fullname: str) -> importlib.abc._Path: ...
|
||||
def get_source(self, fullname: str) -> None: ...
|
||||
@@ -0,0 +1,87 @@
|
||||
import abc
|
||||
import os
|
||||
import pathlib
|
||||
import sys
|
||||
from email.message import Message
|
||||
from importlib.abc import MetaPathFinder
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, List, NamedTuple, Optional, Tuple, Union, overload
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
class PackageNotFoundError(ModuleNotFoundError): ...
|
||||
class EntryPointBase(NamedTuple):
|
||||
name: str
|
||||
value: str
|
||||
group: str
|
||||
class EntryPoint(EntryPointBase):
|
||||
def load(self) -> Any: ... # Callable[[], Any] or an importable module
|
||||
@property
|
||||
def extras(self) -> List[str]: ...
|
||||
class PackagePath(pathlib.PurePosixPath):
|
||||
def read_text(self, encoding: str = ...) -> str: ...
|
||||
def read_binary(self) -> bytes: ...
|
||||
def locate(self) -> os.PathLike[str]: ...
|
||||
# The following attributes are not defined on PackagePath, but are dynamically added by Distribution.files:
|
||||
hash: Optional[FileHash]
|
||||
size: Optional[int]
|
||||
dist: Distribution
|
||||
class FileHash:
|
||||
mode: str
|
||||
value: str
|
||||
def __init__(self, spec: str) -> None: ...
|
||||
class Distribution:
|
||||
@abc.abstractmethod
|
||||
def read_text(self, filename: str) -> Optional[str]: ...
|
||||
@abc.abstractmethod
|
||||
def locate_file(self, path: Union[os.PathLike[str], str]) -> os.PathLike[str]: ...
|
||||
@classmethod
|
||||
def from_name(cls, name: str) -> Distribution: ...
|
||||
@overload
|
||||
@classmethod
|
||||
def discover(cls, *, context: DistributionFinder.Context) -> Iterable[Distribution]: ...
|
||||
@overload
|
||||
@classmethod
|
||||
def discover(
|
||||
cls, *, context: None = ..., name: Optional[str] = ..., path: List[str] = ..., **kwargs: Any
|
||||
) -> Iterable[Distribution]: ...
|
||||
@staticmethod
|
||||
def at(path: Union[str, os.PathLike[str]]) -> PathDistribution: ...
|
||||
@property
|
||||
def metadata(self) -> Message: ...
|
||||
@property
|
||||
def version(self) -> str: ...
|
||||
@property
|
||||
def entry_points(self) -> List[EntryPoint]: ...
|
||||
@property
|
||||
def files(self) -> Optional[List[PackagePath]]: ...
|
||||
@property
|
||||
def requires(self) -> Optional[List[str]]: ...
|
||||
class DistributionFinder(MetaPathFinder):
|
||||
class Context:
|
||||
name: Optional[str]
|
||||
def __init__(self, *, name: Optional[str] = ..., path: List[str] = ..., **kwargs: Any) -> None: ...
|
||||
@property
|
||||
def path(self) -> List[str]: ...
|
||||
@property
|
||||
def pattern(self) -> str: ...
|
||||
@abc.abstractmethod
|
||||
def find_distributions(self, context: Context = ...) -> Iterable[Distribution]: ...
|
||||
class MetadataPathFinder(DistributionFinder):
|
||||
@classmethod
|
||||
def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
|
||||
class PathDistribution(Distribution):
|
||||
def __init__(self, path: Path) -> None: ...
|
||||
def read_text(self, filename: Union[str, os.PathLike[str]]) -> str: ...
|
||||
def locate_file(self, path: Union[str, os.PathLike[str]]) -> os.PathLike[str]: ...
|
||||
def distribution(distribution_name: str) -> Distribution: ...
|
||||
@overload
|
||||
def distributions(*, context: DistributionFinder.Context) -> Iterable[Distribution]: ...
|
||||
@overload
|
||||
def distributions(
|
||||
*, context: None = ..., name: Optional[str] = ..., path: List[str] = ..., **kwargs: Any
|
||||
) -> Iterable[Distribution]: ...
|
||||
def metadata(distribution_name: str) -> Message: ...
|
||||
def version(distribution_name: str) -> str: ...
|
||||
def entry_points() -> Dict[str, Tuple[EntryPoint, ...]]: ...
|
||||
def files(distribution_name: str) -> Optional[List[PackagePath]]: ...
|
||||
def requires(distribution_name: str) -> Optional[List[str]]: ...
|
||||
@@ -0,0 +1,25 @@
|
||||
import sys
|
||||
# This is a >=3.7 module, so we conditionally include its source.
|
||||
if sys.version_info >= (3, 7):
|
||||
import os
|
||||
|
||||
from pathlib import Path
|
||||
from types import ModuleType
|
||||
from typing import ContextManager, Iterator, Union, BinaryIO, TextIO
|
||||
|
||||
Package = Union[str, ModuleType]
|
||||
Resource = Union[str, os.PathLike]
|
||||
|
||||
def open_binary(package: Package, resource: Resource) -> BinaryIO: ...
|
||||
def open_text(package: Package,
|
||||
resource: Resource,
|
||||
encoding: str = ...,
|
||||
errors: str = ...) -> TextIO: ...
|
||||
def read_binary(package: Package, resource: Resource) -> bytes: ...
|
||||
def read_text(package: Package,
|
||||
resource: Resource,
|
||||
encoding: str = ...,
|
||||
errors: str = ...) -> str: ...
|
||||
def path(package: Package, resource: Resource) -> ContextManager[Path]: ...
|
||||
def is_resource(package: Package, name: str) -> bool: ...
|
||||
def contents(package: Package) -> Iterator[str]: ...
|
||||
@@ -0,0 +1,53 @@
|
||||
import importlib.abc
|
||||
import importlib.machinery
|
||||
import sys
|
||||
import types
|
||||
from typing import Any, Callable, List, Optional, Union
|
||||
|
||||
def module_for_loader(
|
||||
fxn: Callable[..., types.ModuleType]
|
||||
) -> Callable[..., types.ModuleType]: ...
|
||||
def set_loader(
|
||||
fxn: Callable[..., types.ModuleType]
|
||||
) -> Callable[..., types.ModuleType]: ...
|
||||
def set_package(
|
||||
fxn: Callable[..., types.ModuleType]
|
||||
) -> Callable[..., types.ModuleType]: ...
|
||||
|
||||
def resolve_name(name: str, package: str) -> str: ...
|
||||
|
||||
MAGIC_NUMBER: bytes
|
||||
|
||||
def cache_from_source(path: str, debug_override: Optional[bool] = ..., *,
|
||||
optimization: Optional[Any] = ...) -> str: ...
|
||||
def source_from_cache(path: str) -> str: ...
|
||||
def decode_source(source_bytes: bytes) -> str: ...
|
||||
def find_spec(
|
||||
name: str, package: Optional[str] = ...
|
||||
) -> Optional[importlib.machinery.ModuleSpec]: ...
|
||||
def spec_from_loader(
|
||||
name: str, loader: Optional[importlib.abc.Loader], *,
|
||||
origin: Optional[str] = ..., loader_state: Optional[Any] = ...,
|
||||
is_package: Optional[bool] = ...
|
||||
) -> importlib.machinery.ModuleSpec: ...
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
import os
|
||||
_Path = Union[str, bytes, os.PathLike]
|
||||
else:
|
||||
_Path = str
|
||||
|
||||
def spec_from_file_location(
|
||||
name: str, location: _Path, *,
|
||||
loader: Optional[importlib.abc.Loader] = ...,
|
||||
submodule_search_locations: Optional[List[str]] = ...
|
||||
) -> importlib.machinery.ModuleSpec: ...
|
||||
|
||||
def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ...
|
||||
|
||||
class LazyLoader(importlib.abc.Loader):
|
||||
def __init__(self, loader: importlib.abc.Loader) -> None: ...
|
||||
@classmethod
|
||||
def factory(cls, loader: importlib.abc.Loader) -> Callable[..., LazyLoader]: ...
|
||||
def create_module(self, spec: importlib.machinery.ModuleSpec) -> Optional[types.ModuleType]: ...
|
||||
def exec_module(self, module: types.ModuleType) -> None: ...
|
||||
@@ -0,0 +1,79 @@
|
||||
# Stubs for selector
|
||||
# See https://docs.python.org/3/library/selectors.html
|
||||
|
||||
from abc import ABCMeta, abstractmethod
|
||||
from typing import Any, List, Mapping, NamedTuple, Optional, Protocol, Tuple, Union
|
||||
from _types import FileDescriptor, FileDescriptorLike
|
||||
|
||||
_EventMask = int
|
||||
|
||||
EVENT_READ: _EventMask
|
||||
EVENT_WRITE: _EventMask
|
||||
|
||||
class SelectorKey(NamedTuple):
|
||||
fileobj: FileDescriptorLike
|
||||
fd: FileDescriptor
|
||||
events: _EventMask
|
||||
data: Any
|
||||
|
||||
class BaseSelector(metaclass=ABCMeta):
|
||||
@abstractmethod
|
||||
def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ...
|
||||
|
||||
@abstractmethod
|
||||
def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
|
||||
|
||||
def modify(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ...
|
||||
|
||||
@abstractmethod
|
||||
def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ...
|
||||
|
||||
def close(self) -> None: ...
|
||||
|
||||
def get_key(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
|
||||
|
||||
@abstractmethod
|
||||
def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
|
||||
|
||||
def __enter__(self) -> BaseSelector: ...
|
||||
|
||||
def __exit__(self, *args: Any) -> None: ...
|
||||
|
||||
class SelectSelector(BaseSelector):
|
||||
def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ...
|
||||
def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
|
||||
def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ...
|
||||
def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
|
||||
|
||||
class PollSelector(BaseSelector):
|
||||
def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ...
|
||||
def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
|
||||
def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ...
|
||||
def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
|
||||
|
||||
class EpollSelector(BaseSelector):
|
||||
def fileno(self) -> int: ...
|
||||
def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ...
|
||||
def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
|
||||
def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ...
|
||||
def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
|
||||
|
||||
class DevpollSelector(BaseSelector):
|
||||
def fileno(self) -> int: ...
|
||||
def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ...
|
||||
def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
|
||||
def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ...
|
||||
def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
|
||||
|
||||
class KqueueSelector(BaseSelector):
|
||||
def fileno(self) -> int: ...
|
||||
def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ...
|
||||
def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
|
||||
def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ...
|
||||
def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
|
||||
|
||||
class DefaultSelector(BaseSelector):
|
||||
def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ...
|
||||
def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
|
||||
def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ...
|
||||
def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
|
||||
@@ -0,0 +1,64 @@
|
||||
# Stubs for statistics
|
||||
|
||||
from decimal import Decimal
|
||||
from fractions import Fraction
|
||||
import sys
|
||||
from typing import Any, Iterable, List, Optional, SupportsFloat, Type, TypeVar, Union
|
||||
|
||||
_T = TypeVar("_T")
|
||||
# Most functions in this module accept homogeneous collections of one of these types
|
||||
_Number = TypeVar('_Number', float, Decimal, Fraction)
|
||||
|
||||
class StatisticsError(ValueError): ...
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
def fmean(data: Iterable[SupportsFloat]) -> float: ...
|
||||
def geometric_mean(data: Iterable[SupportsFloat]) -> float: ...
|
||||
def mean(data: Iterable[_Number]) -> _Number: ...
|
||||
if sys.version_info >= (3, 6):
|
||||
def harmonic_mean(data: Iterable[_Number]) -> _Number: ...
|
||||
def median(data: Iterable[_Number]) -> _Number: ...
|
||||
def median_low(data: Iterable[_Number]) -> _Number: ...
|
||||
def median_high(data: Iterable[_Number]) -> _Number: ...
|
||||
def median_grouped(data: Iterable[_Number], interval: _Number = ...) -> _Number: ...
|
||||
def mode(data: Iterable[_Number]) -> _Number: ...
|
||||
if sys.version_info >= (3, 8):
|
||||
def multimode(data: Iterable[_T]) -> List[_T]: ...
|
||||
def pstdev(data: Iterable[_Number], mu: Optional[_Number] = ...) -> _Number: ...
|
||||
def pvariance(data: Iterable[_Number], mu: Optional[_Number] = ...) -> _Number: ...
|
||||
if sys.version_info >= (3, 8):
|
||||
def quantiles(data: Iterable[_Number], *, n: int = ..., method: str = ...) -> List[_Number]: ...
|
||||
def stdev(data: Iterable[_Number], xbar: Optional[_Number] = ...) -> _Number: ...
|
||||
def variance(data: Iterable[_Number], xbar: Optional[_Number] = ...) -> _Number: ...
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
class NormalDist:
|
||||
def __init__(self, mu: float = ..., sigma: float = ...) -> None: ...
|
||||
@property
|
||||
def mean(self) -> float: ...
|
||||
@property
|
||||
def median(self) -> float: ...
|
||||
@property
|
||||
def mode(self) -> float: ...
|
||||
@property
|
||||
def stdev(self) -> float: ...
|
||||
@property
|
||||
def variance(self) -> float: ...
|
||||
@classmethod
|
||||
def from_samples(cls: Type[_T], data: Iterable[SupportsFloat]) -> _T: ...
|
||||
def samples(self, n: int, *, seed: Optional[Any] = ...) -> List[float]: ...
|
||||
def pdf(self, x: float) -> float: ...
|
||||
def cdf(self, x: float) -> float: ...
|
||||
def inv_cdf(self, p: float) -> float: ...
|
||||
def overlap(self, other: NormalDist) -> float: ...
|
||||
def quantiles(self, n: int = ...) -> List[float]: ...
|
||||
def __add__(self, x2: Union[float, NormalDist]) -> NormalDist: ...
|
||||
def __sub__(self, x2: Union[float, NormalDist]) -> NormalDist: ...
|
||||
def __mul__(self, x2: float) -> NormalDist: ...
|
||||
def __truediv__(self, x2: float) -> NormalDist: ...
|
||||
def __pos__(self) -> NormalDist: ...
|
||||
def __neg__(self) -> NormalDist: ...
|
||||
__radd__ = __add__
|
||||
def __rsub__(self, x2: Union[float, NormalDist]) -> NormalDist: ...
|
||||
__rmul__ = __mul__
|
||||
def __hash__(self) -> int: ...
|
||||
@@ -0,0 +1,113 @@
|
||||
from typing import Callable, List, Optional, Dict, Pattern
|
||||
|
||||
class TextWrapper:
|
||||
width: int = ...
|
||||
initial_indent: str = ...
|
||||
subsequent_indent: str = ...
|
||||
expand_tabs: bool = ...
|
||||
replace_whitespace: bool = ...
|
||||
fix_sentence_endings: bool = ...
|
||||
drop_whitespace: bool = ...
|
||||
break_long_words: bool = ...
|
||||
break_on_hyphens: bool = ...
|
||||
tabsize: int = ...
|
||||
max_lines: Optional[int] = ...
|
||||
placeholder: str = ...
|
||||
|
||||
# Attributes not present in documentation
|
||||
sentence_end_re: Pattern[str] = ...
|
||||
wordsep_re: Pattern[str] = ...
|
||||
wordsep_simple_re: Pattern[str] = ...
|
||||
whitespace_trans: str = ...
|
||||
unicode_whitespace_trans: Dict[int, int] = ...
|
||||
uspace: int = ...
|
||||
x: str = ... # leaked loop variable
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
width: int = ...,
|
||||
initial_indent: str = ...,
|
||||
subsequent_indent: str = ...,
|
||||
expand_tabs: bool = ...,
|
||||
replace_whitespace: bool = ...,
|
||||
fix_sentence_endings: bool = ...,
|
||||
break_long_words: bool = ...,
|
||||
drop_whitespace: bool = ...,
|
||||
break_on_hyphens: bool = ...,
|
||||
tabsize: int = ...,
|
||||
*,
|
||||
max_lines: Optional[int] = ...,
|
||||
placeholder: str = ...) -> None:
|
||||
...
|
||||
|
||||
# Private methods *are* part of the documented API for subclasses.
|
||||
def _munge_whitespace(self, text: str) -> str: ...
|
||||
def _split(self, text: str) -> List[str]: ...
|
||||
def _fix_sentence_endings(self, chunks: List[str]) -> None: ...
|
||||
def _handle_long_word(self, reversed_chunks: List[str], cur_line: List[str], cur_len: int, width: int) -> None: ...
|
||||
def _wrap_chunks(self, chunks: List[str]) -> List[str]: ...
|
||||
def _split_chunks(self, text: str) -> List[str]: ...
|
||||
|
||||
def wrap(self, text: str) -> List[str]: ...
|
||||
def fill(self, text: str) -> str: ...
|
||||
|
||||
|
||||
def wrap(
|
||||
text: str,
|
||||
width: int = ...,
|
||||
*,
|
||||
initial_indent: str = ...,
|
||||
subsequent_indent: str = ...,
|
||||
expand_tabs: bool = ...,
|
||||
tabsize: int = ...,
|
||||
replace_whitespace: bool = ...,
|
||||
fix_sentence_endings: bool = ...,
|
||||
break_long_words: bool = ...,
|
||||
break_on_hyphens: bool = ...,
|
||||
drop_whitespace: bool = ...,
|
||||
max_lines: int = ...,
|
||||
placeholder: str = ...
|
||||
) -> List[str]:
|
||||
...
|
||||
|
||||
def fill(
|
||||
text: str,
|
||||
width: int = ...,
|
||||
*,
|
||||
initial_indent: str = ...,
|
||||
subsequent_indent: str = ...,
|
||||
expand_tabs: bool = ...,
|
||||
tabsize: int = ...,
|
||||
replace_whitespace: bool = ...,
|
||||
fix_sentence_endings: bool = ...,
|
||||
break_long_words: bool = ...,
|
||||
break_on_hyphens: bool = ...,
|
||||
drop_whitespace: bool = ...,
|
||||
max_lines: int = ...,
|
||||
placeholder: str = ...
|
||||
) -> str:
|
||||
...
|
||||
|
||||
def shorten(
|
||||
text: str,
|
||||
width: int,
|
||||
*,
|
||||
initial_indent: str = ...,
|
||||
subsequent_indent: str = ...,
|
||||
expand_tabs: bool = ...,
|
||||
tabsize: int = ...,
|
||||
replace_whitespace: bool = ...,
|
||||
fix_sentence_endings: bool = ...,
|
||||
break_long_words: bool = ...,
|
||||
break_on_hyphens: bool = ...,
|
||||
drop_whitespace: bool = ...,
|
||||
# Omit `max_lines: int = None`, it is forced to 1 here.
|
||||
placeholder: str = ...
|
||||
) -> str:
|
||||
...
|
||||
|
||||
def dedent(text: str) -> str:
|
||||
...
|
||||
|
||||
def indent(text: str, prefix: str, predicate: Optional[Callable[[str], bool]] = ...) -> str:
|
||||
...
|
||||
@@ -0,0 +1,41 @@
|
||||
import sys
|
||||
|
||||
from typing import Optional, Sequence, Text, Union, AnyStr
|
||||
from types import SimpleNamespace
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
from builtins import _PathLike
|
||||
_Path = Union[str, bytes, _PathLike[str], _PathLike[bytes]]
|
||||
else:
|
||||
_Path = Union[str, bytes]
|
||||
|
||||
class EnvBuilder:
|
||||
system_site_packages: bool
|
||||
clear: bool
|
||||
symlinks: bool
|
||||
upgrade: bool
|
||||
with_pip: bool
|
||||
if sys.version_info >= (3, 6):
|
||||
prompt: Optional[str]
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
def __init__(self, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., upgrade: bool = ..., with_pip: bool = ..., prompt: Optional[str] = ...) -> None: ...
|
||||
else:
|
||||
def __init__(self, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., upgrade: bool = ..., with_pip: bool = ...) -> None: ...
|
||||
def create(self, env_dir: _Path) -> None: ...
|
||||
def clear_directory(self, path: _Path) -> None: ... # undocumented
|
||||
def ensure_directories(self, env_dir: _Path) -> SimpleNamespace: ...
|
||||
def create_configuration(self, context: SimpleNamespace) -> None: ...
|
||||
def symlink_or_copy(self, src: _Path, dst: _Path, relative_symlinks_ok: bool = ...) -> None: ... # undocumented
|
||||
def setup_python(self, context: SimpleNamespace) -> None: ...
|
||||
def _setup_pip(self, context: SimpleNamespace) -> None: ... # undocumented
|
||||
def setup_scripts(self, context: SimpleNamespace) -> None: ...
|
||||
def post_setup(self, context: SimpleNamespace) -> None: ...
|
||||
def replace_variables(self, text: str, context: SimpleNamespace) -> str: ... # undocumented
|
||||
def install_scripts(self, context: SimpleNamespace, path: str) -> None: ...
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
def create(env_dir: _Path, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., with_pip: bool = ..., prompt: Optional[str] = ...) -> None: ...
|
||||
else:
|
||||
def create(env_dir: _Path, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., with_pip: bool = ...) -> None: ...
|
||||
def main(args: Optional[Sequence[Text]] = ...) -> None: ...
|
||||
+143
@@ -0,0 +1,143 @@
|
||||
from typing import Any, Generator, IO, Optional, Sequence, Tuple, Type, TypeVar, Union, List
|
||||
from types import TracebackType
|
||||
import os
|
||||
import sys
|
||||
|
||||
_P = TypeVar('_P', bound=PurePath)
|
||||
|
||||
if sys.version_info >= (3, 6):
|
||||
_PurePathBase = os.PathLike[str]
|
||||
else:
|
||||
_PurePathBase = object
|
||||
|
||||
class PurePath(_PurePathBase):
|
||||
parts: Tuple[str, ...]
|
||||
drive: str
|
||||
root: str
|
||||
anchor: str
|
||||
name: str
|
||||
suffix: str
|
||||
suffixes: List[str]
|
||||
stem: str
|
||||
if sys.version_info < (3, 5):
|
||||
def __init__(self, *pathsegments: str) -> None: ...
|
||||
elif sys.version_info < (3, 6):
|
||||
def __new__(cls: Type[_P], *args: Union[str, PurePath]) -> _P: ...
|
||||
else:
|
||||
def __new__(cls: Type[_P], *args: Union[str, os.PathLike[str]]) -> _P: ...
|
||||
def __hash__(self) -> int: ...
|
||||
def __lt__(self, other: PurePath) -> bool: ...
|
||||
def __le__(self, other: PurePath) -> bool: ...
|
||||
def __gt__(self, other: PurePath) -> bool: ...
|
||||
def __ge__(self, other: PurePath) -> bool: ...
|
||||
if sys.version_info < (3, 6):
|
||||
def __truediv__(self: _P, key: Union[str, PurePath]) -> _P: ...
|
||||
def __rtruediv__(self: _P, key: Union[str, PurePath]) -> _P: ...
|
||||
else:
|
||||
def __truediv__(self: _P, key: Union[str, os.PathLike[str]]) -> _P: ...
|
||||
def __rtruediv__(self: _P, key: Union[str, os.PathLike[str]]) -> _P: ...
|
||||
if sys.version_info < (3,):
|
||||
def __div__(self: _P, key: Union[str, PurePath]) -> _P: ...
|
||||
def __bytes__(self) -> bytes: ...
|
||||
def as_posix(self) -> str: ...
|
||||
def as_uri(self) -> str: ...
|
||||
def is_absolute(self) -> bool: ...
|
||||
def is_reserved(self) -> bool: ...
|
||||
def match(self, path_pattern: str) -> bool: ...
|
||||
if sys.version_info < (3, 6):
|
||||
def relative_to(self: _P, *other: Union[str, PurePath]) -> _P: ...
|
||||
else:
|
||||
def relative_to(self: _P, *other: Union[str, os.PathLike[str]]) -> _P: ...
|
||||
def with_name(self: _P, name: str) -> _P: ...
|
||||
def with_suffix(self: _P, suffix: str) -> _P: ...
|
||||
if sys.version_info < (3, 6):
|
||||
def joinpath(self: _P, *other: Union[str, PurePath]) -> _P: ...
|
||||
else:
|
||||
def joinpath(self: _P, *other: Union[str, os.PathLike[str]]) -> _P: ...
|
||||
|
||||
@property
|
||||
def parents(self: _P) -> Sequence[_P]: ...
|
||||
@property
|
||||
def parent(self: _P) -> _P: ...
|
||||
|
||||
class PurePosixPath(PurePath): ...
|
||||
class PureWindowsPath(PurePath): ...
|
||||
|
||||
class Path(PurePath):
|
||||
def __enter__(self) -> Path: ...
|
||||
def __exit__(self, exc_type: Optional[Type[BaseException]],
|
||||
exc_value: Optional[BaseException],
|
||||
traceback: Optional[TracebackType]) -> Optional[bool]: ...
|
||||
@classmethod
|
||||
def cwd(cls: Type[_P]) -> _P: ...
|
||||
def stat(self) -> os.stat_result: ...
|
||||
def chmod(self, mode: int) -> None: ...
|
||||
def exists(self) -> bool: ...
|
||||
def glob(self, pattern: str) -> Generator[Path, None, None]: ...
|
||||
def group(self) -> str: ...
|
||||
def is_dir(self) -> bool: ...
|
||||
def is_file(self) -> bool: ...
|
||||
if sys.version_info >= (3, 7):
|
||||
def is_mount(self) -> bool: ...
|
||||
def is_symlink(self) -> bool: ...
|
||||
def is_socket(self) -> bool: ...
|
||||
def is_fifo(self) -> bool: ...
|
||||
def is_block_device(self) -> bool: ...
|
||||
def is_char_device(self) -> bool: ...
|
||||
def iterdir(self) -> Generator[Path, None, None]: ...
|
||||
def lchmod(self, mode: int) -> None: ...
|
||||
def lstat(self) -> os.stat_result: ...
|
||||
if sys.version_info < (3, 5):
|
||||
def mkdir(self, mode: int = ...,
|
||||
parents: bool = ...) -> None: ...
|
||||
else:
|
||||
def mkdir(self, mode: int = ..., parents: bool = ...,
|
||||
exist_ok: bool = ...) -> None: ...
|
||||
def open(self, mode: str = ..., buffering: int = ...,
|
||||
encoding: Optional[str] = ..., errors: Optional[str] = ...,
|
||||
newline: Optional[str] = ...) -> IO[Any]: ...
|
||||
def owner(self) -> str: ...
|
||||
if sys.version_info >= (3, 8):
|
||||
def rename(self: _P, target: Union[str, PurePath]) -> _P: ...
|
||||
else:
|
||||
def rename(self, target: Union[str, PurePath]) -> None: ...
|
||||
def replace(self, target: Union[str, PurePath]) -> None: ...
|
||||
if sys.version_info < (3, 6):
|
||||
def resolve(self: _P) -> _P: ...
|
||||
else:
|
||||
def resolve(self: _P, strict: bool = ...) -> _P: ...
|
||||
def rglob(self, pattern: str) -> Generator[Path, None, None]: ...
|
||||
def rmdir(self) -> None: ...
|
||||
def symlink_to(self, target: Union[str, Path],
|
||||
target_is_directory: bool = ...) -> None: ...
|
||||
def touch(self, mode: int = ..., exist_ok: bool = ...) -> None: ...
|
||||
if sys.version_info >= (3, 8):
|
||||
def unlink(self, missing_ok: bool = ...) -> None: ...
|
||||
else:
|
||||
def unlink(self) -> None: ...
|
||||
|
||||
if sys.version_info >= (3, 5):
|
||||
@classmethod
|
||||
def home(cls: Type[_P]) -> _P: ...
|
||||
if sys.version_info < (3, 6):
|
||||
def __new__(cls: Type[_P], *args: Union[str, PurePath],
|
||||
**kwargs: Any) -> _P: ...
|
||||
else:
|
||||
def __new__(cls: Type[_P], *args: Union[str, os.PathLike[str]],
|
||||
**kwargs: Any) -> _P: ...
|
||||
|
||||
def absolute(self: _P) -> _P: ...
|
||||
def expanduser(self: _P) -> _P: ...
|
||||
def read_bytes(self) -> bytes: ...
|
||||
def read_text(self, encoding: Optional[str] = ...,
|
||||
errors: Optional[str] = ...) -> str: ...
|
||||
def samefile(self, other_path: Union[str, bytes, int, Path]) -> bool: ...
|
||||
def write_bytes(self, data: bytes) -> int: ...
|
||||
def write_text(self, data: str, encoding: Optional[str] = ...,
|
||||
errors: Optional[str] = ...) -> int: ...
|
||||
if sys.version_info >= (3, 8):
|
||||
def link_to(self, target: Union[str, bytes, os.PathLike[str]]) -> None: ...
|
||||
|
||||
|
||||
class PosixPath(Path, PurePosixPath): ...
|
||||
class WindowsPath(Path, PureWindowsPath): ...
|
||||
@@ -32,6 +32,7 @@ val whiteList = sequenceOf(
|
||||
"_compression",
|
||||
"_csv",
|
||||
"_curses",
|
||||
"_dummy_threading",
|
||||
"_heapq",
|
||||
"_imp",
|
||||
"_importlib_modulespec",
|
||||
@@ -40,16 +41,21 @@ val whiteList = sequenceOf(
|
||||
"_operator",
|
||||
"_random",
|
||||
"_thread",
|
||||
"_types",
|
||||
"_warnings",
|
||||
"abc",
|
||||
"antigravity",
|
||||
"argparse",
|
||||
"array",
|
||||
"ast",
|
||||
"asyncio",
|
||||
"asyncore",
|
||||
"attr",
|
||||
"audioop",
|
||||
"bdb",
|
||||
"binascii",
|
||||
"builtins",
|
||||
"cgi",
|
||||
"cmath",
|
||||
"cmd",
|
||||
"codecs",
|
||||
@@ -65,32 +71,41 @@ val whiteList = sequenceOf(
|
||||
"ctypes",
|
||||
"curses",
|
||||
"datetime",
|
||||
//"datetimerange", leads to broken tests but could be enabled
|
||||
"dateutil",
|
||||
"dbm",
|
||||
"decimal",
|
||||
"difflib",
|
||||
"distutils",
|
||||
"doctest",
|
||||
"email",
|
||||
"exceptions",
|
||||
"faulthandler",
|
||||
"fcntl",
|
||||
"filecmp",
|
||||
//"formatter", leads to broken tests but could be enabled
|
||||
"functools",
|
||||
"gc",
|
||||
"genericpath",
|
||||
"gettext",
|
||||
"gflags",
|
||||
"hashlib",
|
||||
"heapq",
|
||||
"http",
|
||||
"imaplib",
|
||||
"imghdr",
|
||||
"importlib",
|
||||
"inspect",
|
||||
"io",
|
||||
"ipaddress",
|
||||
"itertools",
|
||||
"json",
|
||||
"locale",
|
||||
"logging",
|
||||
"macpath",
|
||||
"marshal",
|
||||
"math",
|
||||
"mimetypes",
|
||||
"mock",
|
||||
"modulefinder",
|
||||
"multiprocessing",
|
||||
@@ -102,7 +117,9 @@ val whiteList = sequenceOf(
|
||||
"orjson",
|
||||
"os",
|
||||
"os2emxpath",
|
||||
"parser",
|
||||
"pathlib",
|
||||
"pathlib2",
|
||||
"pdb",
|
||||
"pickle",
|
||||
//"platform", leads to broken tests but could be enabled
|
||||
@@ -110,12 +127,16 @@ val whiteList = sequenceOf(
|
||||
"posix",
|
||||
"posixpath",
|
||||
"pprint",
|
||||
"pstats",
|
||||
"py_compile",
|
||||
"pydoc",
|
||||
"pyexpat",
|
||||
"queue",
|
||||
"re",
|
||||
"requests",
|
||||
"resource",
|
||||
"select",
|
||||
"selectors",
|
||||
"shutil",
|
||||
"signal",
|
||||
"six",
|
||||
@@ -125,9 +146,16 @@ val whiteList = sequenceOf(
|
||||
"sre_constants",
|
||||
"sre_parse",
|
||||
"ssl",
|
||||
"statistics",
|
||||
//"string", leads to broken tests but could be enabled
|
||||
"struct",
|
||||
"subprocess",
|
||||
"sys",
|
||||
"tarfile",
|
||||
"tempfile",
|
||||
"termios",
|
||||
"textwrap",
|
||||
"this",
|
||||
"threading",
|
||||
"time",
|
||||
"token",
|
||||
@@ -140,10 +168,14 @@ val whiteList = sequenceOf(
|
||||
"urllib",
|
||||
"uu",
|
||||
"uuid",
|
||||
"venv",
|
||||
"warnings",
|
||||
"webbrowser",
|
||||
"werkzeug",
|
||||
"winsound",
|
||||
"xml",
|
||||
"zipapp",
|
||||
"zipfile",
|
||||
"zipimport",
|
||||
"zlib"
|
||||
).mapTo(hashSetOf()) { it.toLowerCase() }
|
||||
|
||||
Reference in New Issue
Block a user