id int64 0 458k | file_name stringlengths 4 119 | file_path stringlengths 14 227 | content stringlengths 24 9.96M | size int64 24 9.96M | language stringclasses 1 value | extension stringclasses 14 values | total_lines int64 1 219k | avg_line_length float64 2.52 4.63M | max_line_length int64 5 9.91M | alphanum_fraction float64 0 1 | repo_name stringlengths 7 101 | repo_stars int64 100 139k | repo_forks int64 0 26.4k | repo_open_issues int64 0 2.27k | repo_license stringclasses 12 values | repo_extraction_date stringclasses 433 values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
29,200 | util.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/wsgiref/util.pyi | import sys
from typing import IO, Any, Callable, Optional
from .types import WSGIEnvironment
class FileWrapper:
filelike: IO[bytes]
blksize: int
close: Callable[[], None] # only exists if filelike.close exists
def __init__(self, filelike: IO[bytes], blksize: int = ...) -> None: ...
def __getitem__(self, key: Any) -> bytes: ...
def __iter__(self) -> FileWrapper: ...
if sys.version_info < (3,):
def next(self) -> bytes: ...
else:
def __next__(self) -> bytes: ...
def guess_scheme(environ: WSGIEnvironment) -> str: ...
def application_uri(environ: WSGIEnvironment) -> str: ...
def request_uri(environ: WSGIEnvironment, include_query: bool = ...) -> str: ...
def shift_path_info(environ: WSGIEnvironment) -> Optional[str]: ...
def setup_testing_defaults(environ: WSGIEnvironment) -> None: ...
def is_hop_by_hop(header_name: str) -> bool: ...
| 893 | Python | .py | 20 | 41.1 | 80 | 0.652874 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,201 | headers.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/wsgiref/headers.pyi | import sys
from typing import List, Optional, Pattern, Tuple, overload
_HeaderList = List[Tuple[str, str]]
tspecials: Pattern[str] # undocumented
class Headers:
if sys.version_info < (3, 5):
def __init__(self, headers: _HeaderList) -> None: ...
else:
def __init__(self, headers: Optional[_HeaderList] = ...) -> None: ...
def __len__(self) -> int: ...
def __setitem__(self, name: str, val: str) -> None: ...
def __delitem__(self, name: str) -> None: ...
def __getitem__(self, name: str) -> Optional[str]: ...
if sys.version_info < (3,):
def has_key(self, name: str) -> bool: ...
def __contains__(self, name: str) -> bool: ...
def get_all(self, name: str) -> List[str]: ...
@overload
def get(self, name: str, default: str) -> str: ...
@overload
def get(self, name: str, default: Optional[str] = ...) -> Optional[str]: ...
def keys(self) -> List[str]: ...
def values(self) -> List[str]: ...
def items(self) -> _HeaderList: ...
if sys.version_info >= (3,):
def __bytes__(self) -> bytes: ...
def setdefault(self, name: str, value: str) -> str: ...
def add_header(self, _name: str, _value: Optional[str], **_params: Optional[str]) -> None: ...
| 1,250 | Python | .py | 28 | 39.678571 | 98 | 0.570139 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,202 | simple_server.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/wsgiref/simple_server.pyi | import sys
from typing import List, Optional, Type, TypeVar, overload
from .handlers import SimpleHandler
from .types import ErrorStream, StartResponse, WSGIApplication, WSGIEnvironment
if sys.version_info < (3,):
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
else:
from http.server import BaseHTTPRequestHandler, HTTPServer
server_version: str # undocumented
sys_version: str # undocumented
software_version: str # undocumented
class ServerHandler(SimpleHandler): # undocumented
server_software: str
def close(self) -> None: ...
class WSGIServer(HTTPServer):
application: Optional[WSGIApplication]
base_environ: WSGIEnvironment # only available after call to setup_environ()
def setup_environ(self) -> None: ...
def get_app(self) -> Optional[WSGIApplication]: ...
def set_app(self, application: Optional[WSGIApplication]) -> None: ...
class WSGIRequestHandler(BaseHTTPRequestHandler):
server_version: str
def get_environ(self) -> WSGIEnvironment: ...
def get_stderr(self) -> ErrorStream: ...
def handle(self) -> None: ...
def demo_app(environ: WSGIEnvironment, start_response: StartResponse) -> List[bytes]: ...
_S = TypeVar("_S", bound=WSGIServer)
@overload
def make_server(host: str, port: int, app: WSGIApplication, *, handler_class: Type[WSGIRequestHandler] = ...) -> WSGIServer: ...
@overload
def make_server(
host: str, port: int, app: WSGIApplication, server_class: Type[_S], handler_class: Type[WSGIRequestHandler] = ...
) -> _S: ...
| 1,528 | Python | .py | 33 | 43.363636 | 128 | 0.742434 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,203 | validate.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/wsgiref/validate.pyi | import sys
from _typeshed.wsgi import ErrorStream, InputStream, WSGIApplication
from typing import Any, Callable, Iterable, Iterator, NoReturn, Optional
class WSGIWarning(Warning): ...
def validator(application: WSGIApplication) -> WSGIApplication: ...
class InputWrapper:
input: InputStream
def __init__(self, wsgi_input: InputStream) -> None: ...
if sys.version_info < (3,):
def read(self, size: int = ...) -> bytes: ...
def readline(self) -> bytes: ...
else:
def read(self, size: int) -> bytes: ...
def readline(self, size: int = ...) -> bytes: ...
def readlines(self, hint: int = ...) -> bytes: ...
def __iter__(self) -> Iterable[bytes]: ...
def close(self) -> NoReturn: ...
class ErrorWrapper:
errors: ErrorStream
def __init__(self, wsgi_errors: ErrorStream) -> None: ...
def write(self, s: str) -> None: ...
def flush(self) -> None: ...
def writelines(self, seq: Iterable[str]) -> None: ...
def close(self) -> NoReturn: ...
class WriteWrapper:
writer: Callable[[bytes], Any]
def __init__(self, wsgi_writer: Callable[[bytes], Any]) -> None: ...
def __call__(self, s: bytes) -> None: ...
class PartialIteratorWrapper:
iterator: Iterator[bytes]
def __init__(self, wsgi_iterator: Iterator[bytes]) -> None: ...
def __iter__(self) -> IteratorWrapper: ...
class IteratorWrapper:
original_iterator: Iterator[bytes]
iterator: Iterator[bytes]
closed: bool
check_start_response: Optional[bool]
def __init__(self, wsgi_iterator: Iterator[bytes], check_start_response: Optional[bool]) -> None: ...
def __iter__(self) -> IteratorWrapper: ...
if sys.version_info < (3,):
def next(self) -> bytes: ...
else:
def __next__(self) -> bytes: ...
def close(self) -> None: ...
def __del__(self) -> None: ...
| 1,861 | Python | .py | 45 | 36.555556 | 105 | 0.620232 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,204 | handlers.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/wsgiref/handlers.pyi | import sys
from abc import abstractmethod
from types import TracebackType
from typing import IO, Callable, Dict, List, MutableMapping, Optional, Text, Tuple, Type
from .headers import Headers
from .types import ErrorStream, InputStream, StartResponse, WSGIApplication, WSGIEnvironment
from .util import FileWrapper
_exc_info = Tuple[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]]
def format_date_time(timestamp: Optional[float]) -> str: ... # undocumented
if sys.version_info >= (3, 2):
def read_environ() -> Dict[str, str]: ...
class BaseHandler:
wsgi_version: Tuple[int, int] # undocumented
wsgi_multithread: bool
wsgi_multiprocess: bool
wsgi_run_once: bool
origin_server: bool
http_version: str
server_software: Optional[str]
os_environ: MutableMapping[str, str]
wsgi_file_wrapper: Optional[Type[FileWrapper]]
headers_class: Type[Headers] # undocumented
traceback_limit: Optional[int]
error_status: str
error_headers: List[Tuple[Text, Text]]
error_body: bytes
def run(self, application: WSGIApplication) -> None: ...
def setup_environ(self) -> None: ...
def finish_response(self) -> None: ...
def get_scheme(self) -> str: ...
def set_content_length(self) -> None: ...
def cleanup_headers(self) -> None: ...
def start_response(
self, status: Text, headers: List[Tuple[Text, Text]], exc_info: Optional[_exc_info] = ...
) -> Callable[[bytes], None]: ...
def send_preamble(self) -> None: ...
def write(self, data: bytes) -> None: ...
def sendfile(self) -> bool: ...
def finish_content(self) -> None: ...
def close(self) -> None: ...
def send_headers(self) -> None: ...
def result_is_file(self) -> bool: ...
def client_is_modern(self) -> bool: ...
def log_exception(self, exc_info: _exc_info) -> None: ...
def handle_error(self) -> None: ...
def error_output(self, environ: WSGIEnvironment, start_response: StartResponse) -> List[bytes]: ...
@abstractmethod
def _write(self, data: bytes) -> None: ...
@abstractmethod
def _flush(self) -> None: ...
@abstractmethod
def get_stdin(self) -> InputStream: ...
@abstractmethod
def get_stderr(self) -> ErrorStream: ...
@abstractmethod
def add_cgi_vars(self) -> None: ...
class SimpleHandler(BaseHandler):
stdin: InputStream
stdout: IO[bytes]
stderr: ErrorStream
base_env: MutableMapping[str, str]
def __init__(
self,
stdin: InputStream,
stdout: IO[bytes],
stderr: ErrorStream,
environ: MutableMapping[str, str],
multithread: bool = ...,
multiprocess: bool = ...,
) -> None: ...
def get_stdin(self) -> InputStream: ...
def get_stderr(self) -> ErrorStream: ...
def add_cgi_vars(self) -> None: ...
def _write(self, data: bytes) -> None: ...
def _flush(self) -> None: ...
class BaseCGIHandler(SimpleHandler): ...
class CGIHandler(BaseCGIHandler):
def __init__(self) -> None: ...
class IISCGIHandler(BaseCGIHandler):
def __init__(self) -> None: ...
| 3,125 | Python | .py | 80 | 34.25 | 103 | 0.655343 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,205 | util.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/ctypes/util.pyi | import sys
from typing import Optional
def find_library(name: str) -> Optional[str]: ...
if sys.platform == "win32":
def find_msvcrt() -> Optional[str]: ...
| 163 | Python | .py | 5 | 30.4 | 49 | 0.685897 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,206 | wintypes.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/ctypes/wintypes.pyi | from ctypes import (
Array,
Structure,
_SimpleCData,
c_byte,
c_char,
c_char_p,
c_double,
c_float,
c_int,
c_long,
c_longlong,
c_short,
c_uint,
c_ulong,
c_ulonglong,
c_ushort,
c_void_p,
c_wchar,
c_wchar_p,
pointer,
)
BYTE = c_byte
WORD = c_ushort
DWORD = c_ulong
CHAR = c_char
WCHAR = c_wchar
UINT = c_uint
INT = c_int
DOUBLE = c_double
FLOAT = c_float
BOOLEAN = BYTE
BOOL = c_long
class VARIANT_BOOL(_SimpleCData[bool]): ...
ULONG = c_ulong
LONG = c_long
USHORT = c_ushort
SHORT = c_short
LARGE_INTEGER = c_longlong
_LARGE_INTEGER = c_longlong
ULARGE_INTEGER = c_ulonglong
_ULARGE_INTEGER = c_ulonglong
OLESTR = c_wchar_p
LPOLESTR = c_wchar_p
LPCOLESTR = c_wchar_p
LPWSTR = c_wchar_p
LPCWSTR = c_wchar_p
LPSTR = c_char_p
LPCSTR = c_char_p
LPVOID = c_void_p
LPCVOID = c_void_p
# These two types are pointer-sized unsigned and signed ints, respectively.
# At runtime, they are either c_[u]long or c_[u]longlong, depending on the host's pointer size
# (they are not really separate classes).
class WPARAM(_SimpleCData[int]): ...
class LPARAM(_SimpleCData[int]): ...
ATOM = WORD
LANGID = WORD
COLORREF = DWORD
LGRPID = DWORD
LCTYPE = DWORD
LCID = DWORD
HANDLE = c_void_p
HACCEL = HANDLE
HBITMAP = HANDLE
HBRUSH = HANDLE
HCOLORSPACE = HANDLE
HDC = HANDLE
HDESK = HANDLE
HDWP = HANDLE
HENHMETAFILE = HANDLE
HFONT = HANDLE
HGDIOBJ = HANDLE
HGLOBAL = HANDLE
HHOOK = HANDLE
HICON = HANDLE
HINSTANCE = HANDLE
HKEY = HANDLE
HKL = HANDLE
HLOCAL = HANDLE
HMENU = HANDLE
HMETAFILE = HANDLE
HMODULE = HANDLE
HMONITOR = HANDLE
HPALETTE = HANDLE
HPEN = HANDLE
HRGN = HANDLE
HRSRC = HANDLE
HSTR = HANDLE
HTASK = HANDLE
HWINSTA = HANDLE
HWND = HANDLE
SC_HANDLE = HANDLE
SERVICE_STATUS_HANDLE = HANDLE
class RECT(Structure):
left: LONG
top: LONG
right: LONG
bottom: LONG
RECTL = RECT
_RECTL = RECT
tagRECT = RECT
class _SMALL_RECT(Structure):
Left: SHORT
Top: SHORT
Right: SHORT
Bottom: SHORT
SMALL_RECT = _SMALL_RECT
class _COORD(Structure):
X: SHORT
Y: SHORT
class POINT(Structure):
x: LONG
y: LONG
POINTL = POINT
_POINTL = POINT
tagPOINT = POINT
class SIZE(Structure):
cx: LONG
cy: LONG
SIZEL = SIZE
tagSIZE = SIZE
def RGB(red: int, green: int, blue: int) -> int: ...
class FILETIME(Structure):
dwLowDateTime: DWORD
dwHighDateTime: DWORD
_FILETIME = FILETIME
class MSG(Structure):
hWnd: HWND
message: UINT
wParam: WPARAM
lParam: LPARAM
time: DWORD
pt: POINT
tagMSG = MSG
MAX_PATH: int
class WIN32_FIND_DATAA(Structure):
dwFileAttributes: DWORD
ftCreationTime: FILETIME
ftLastAccessTime: FILETIME
ftLastWriteTime: FILETIME
nFileSizeHigh: DWORD
nFileSizeLow: DWORD
dwReserved0: DWORD
dwReserved1: DWORD
cFileName: Array[CHAR]
cAlternateFileName: Array[CHAR]
class WIN32_FIND_DATAW(Structure):
dwFileAttributes: DWORD
ftCreationTime: FILETIME
ftLastAccessTime: FILETIME
ftLastWriteTime: FILETIME
nFileSizeHigh: DWORD
nFileSizeLow: DWORD
dwReserved0: DWORD
dwReserved1: DWORD
cFileName: Array[WCHAR]
cAlternateFileName: Array[WCHAR]
# These pointer type definitions use pointer[...] instead of POINTER(...), to allow them
# to be used in type annotations.
PBOOL = pointer[BOOL]
LPBOOL = pointer[BOOL]
PBOOLEAN = pointer[BOOLEAN]
PBYTE = pointer[BYTE]
LPBYTE = pointer[BYTE]
PCHAR = pointer[CHAR]
LPCOLORREF = pointer[COLORREF]
PDWORD = pointer[DWORD]
LPDWORD = pointer[DWORD]
PFILETIME = pointer[FILETIME]
LPFILETIME = pointer[FILETIME]
PFLOAT = pointer[FLOAT]
PHANDLE = pointer[HANDLE]
LPHANDLE = pointer[HANDLE]
PHKEY = pointer[HKEY]
LPHKL = pointer[HKL]
PINT = pointer[INT]
LPINT = pointer[INT]
PLARGE_INTEGER = pointer[LARGE_INTEGER]
PLCID = pointer[LCID]
PLONG = pointer[LONG]
LPLONG = pointer[LONG]
PMSG = pointer[MSG]
LPMSG = pointer[MSG]
PPOINT = pointer[POINT]
LPPOINT = pointer[POINT]
PPOINTL = pointer[POINTL]
PRECT = pointer[RECT]
LPRECT = pointer[RECT]
PRECTL = pointer[RECTL]
LPRECTL = pointer[RECTL]
LPSC_HANDLE = pointer[SC_HANDLE]
PSHORT = pointer[SHORT]
PSIZE = pointer[SIZE]
LPSIZE = pointer[SIZE]
PSIZEL = pointer[SIZEL]
LPSIZEL = pointer[SIZEL]
PSMALL_RECT = pointer[SMALL_RECT]
PUINT = pointer[UINT]
LPUINT = pointer[UINT]
PULARGE_INTEGER = pointer[ULARGE_INTEGER]
PULONG = pointer[ULONG]
PUSHORT = pointer[USHORT]
PWCHAR = pointer[WCHAR]
PWIN32_FIND_DATAA = pointer[WIN32_FIND_DATAA]
LPWIN32_FIND_DATAA = pointer[WIN32_FIND_DATAA]
PWIN32_FIND_DATAW = pointer[WIN32_FIND_DATAW]
LPWIN32_FIND_DATAW = pointer[WIN32_FIND_DATAW]
PWORD = pointer[WORD]
LPWORD = pointer[WORD]
| 4,642 | Python | .py | 210 | 19.809524 | 94 | 0.744782 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,207 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/ctypes/__init__.pyi | import sys
from array import array
from typing import (
Any,
Callable,
ClassVar,
Generic,
Iterable,
Iterator,
List,
Mapping,
Optional,
Sequence,
Text,
Tuple,
Type,
TypeVar,
Union as _UnionT,
overload,
)
if sys.version_info >= (3, 9):
from types import GenericAlias
_T = TypeVar("_T")
_DLLT = TypeVar("_DLLT", bound=CDLL)
_CT = TypeVar("_CT", bound=_CData)
RTLD_GLOBAL: int = ...
RTLD_LOCAL: int = ...
DEFAULT_MODE: int = ...
class CDLL(object):
_func_flags_: ClassVar[int] = ...
_func_restype_: ClassVar[_CData] = ...
_name: str = ...
_handle: int = ...
_FuncPtr: Type[_FuncPointer] = ...
def __init__(
self,
name: Optional[str],
mode: int = ...,
handle: Optional[int] = ...,
use_errno: bool = ...,
use_last_error: bool = ...,
winmode: Optional[int] = ...,
) -> None: ...
def __getattr__(self, name: str) -> _NamedFuncPointer: ...
def __getitem__(self, name: str) -> _NamedFuncPointer: ...
if sys.platform == "win32":
class OleDLL(CDLL): ...
class WinDLL(CDLL): ...
class PyDLL(CDLL): ...
class LibraryLoader(Generic[_DLLT]):
def __init__(self, dlltype: Type[_DLLT]) -> None: ...
def __getattr__(self, name: str) -> _DLLT: ...
def __getitem__(self, name: str) -> _DLLT: ...
def LoadLibrary(self, name: str) -> _DLLT: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
cdll: LibraryLoader[CDLL] = ...
if sys.platform == "win32":
windll: LibraryLoader[WinDLL] = ...
oledll: LibraryLoader[OleDLL] = ...
pydll: LibraryLoader[PyDLL] = ...
pythonapi: PyDLL = ...
# Anything that implements the read-write buffer interface.
# The buffer interface is defined purely on the C level, so we cannot define a normal Protocol
# for it. Instead we have to list the most common stdlib buffer classes in a Union.
_WritableBuffer = _UnionT[bytearray, memoryview, array, _CData]
# Same as _WritableBuffer, but also includes read-only buffer types (like bytes).
_ReadOnlyBuffer = _UnionT[_WritableBuffer, bytes]
class _CDataMeta(type):
# By default mypy complains about the following two methods, because strictly speaking cls
# might not be a Type[_CT]. However this can never actually happen, because the only class that
# uses _CDataMeta as its metaclass is _CData. So it's safe to ignore the errors here.
def __mul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ... # type: ignore
def __rmul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ... # type: ignore
class _CData(metaclass=_CDataMeta):
_b_base: int = ...
_b_needsfree_: bool = ...
_objects: Optional[Mapping[Any, int]] = ...
@classmethod
def from_buffer(cls: Type[_CT], source: _WritableBuffer, offset: int = ...) -> _CT: ...
@classmethod
def from_buffer_copy(cls: Type[_CT], source: _ReadOnlyBuffer, offset: int = ...) -> _CT: ...
@classmethod
def from_address(cls: Type[_CT], address: int) -> _CT: ...
@classmethod
def from_param(cls: Type[_CT], obj: Any) -> _UnionT[_CT, _CArgObject]: ...
@classmethod
def in_dll(cls: Type[_CT], library: CDLL, name: str) -> _CT: ...
class _CanCastTo(_CData): ...
class _PointerLike(_CanCastTo): ...
_ECT = Callable[[Optional[Type[_CData]], _FuncPointer, Tuple[_CData, ...]], _CData]
_PF = _UnionT[Tuple[int], Tuple[int, str], Tuple[int, str, Any]]
class _FuncPointer(_PointerLike, _CData):
restype: _UnionT[Type[_CData], Callable[[int], None], None] = ...
argtypes: Sequence[Type[_CData]] = ...
errcheck: _ECT = ...
@overload
def __init__(self, address: int) -> None: ...
@overload
def __init__(self, callable: Callable[..., Any]) -> None: ...
@overload
def __init__(self, func_spec: Tuple[_UnionT[str, int], CDLL], paramflags: Tuple[_PF, ...] = ...) -> None: ...
@overload
def __init__(self, vtlb_index: int, name: str, paramflags: Tuple[_PF, ...] = ..., iid: pointer[c_int] = ...) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
class _NamedFuncPointer(_FuncPointer):
__name__: str
class ArgumentError(Exception): ...
def CFUNCTYPE(
restype: Optional[Type[_CData]], *argtypes: Type[_CData], use_errno: bool = ..., use_last_error: bool = ...
) -> Type[_FuncPointer]: ...
if sys.platform == "win32":
def WINFUNCTYPE(
restype: Optional[Type[_CData]], *argtypes: Type[_CData], use_errno: bool = ..., use_last_error: bool = ...
) -> Type[_FuncPointer]: ...
def PYFUNCTYPE(restype: Optional[Type[_CData]], *argtypes: Type[_CData]) -> Type[_FuncPointer]: ...
class _CArgObject: ...
# Any type that can be implicitly converted to c_void_p when passed as a C function argument.
# (bytes is not included here, see below.)
_CVoidPLike = _UnionT[_PointerLike, Array[Any], _CArgObject, int]
# Same as above, but including types known to be read-only (i. e. bytes).
# This distinction is not strictly necessary (ctypes doesn't differentiate between const
# and non-const pointers), but it catches errors like memmove(b'foo', buf, 4)
# when memmove(buf, b'foo', 4) was intended.
_CVoidConstPLike = _UnionT[_CVoidPLike, bytes]
def addressof(obj: _CData) -> int: ...
def alignment(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
def byref(obj: _CData, offset: int = ...) -> _CArgObject: ...
_CastT = TypeVar("_CastT", bound=_CanCastTo)
def cast(obj: _UnionT[_CData, _CArgObject, int], type: Type[_CastT]) -> _CastT: ...
def create_string_buffer(init: _UnionT[int, bytes], size: Optional[int] = ...) -> Array[c_char]: ...
c_buffer = create_string_buffer
def create_unicode_buffer(init: _UnionT[int, Text], size: Optional[int] = ...) -> Array[c_wchar]: ...
if sys.platform == "win32":
def DllCanUnloadNow() -> int: ...
def DllGetClassObject(rclsid: Any, riid: Any, ppv: Any) -> int: ... # TODO not documented
def FormatError(code: int) -> str: ...
def GetLastError() -> int: ...
def get_errno() -> int: ...
if sys.platform == "win32":
def get_last_error() -> int: ...
def memmove(dst: _CVoidPLike, src: _CVoidConstPLike, count: int) -> None: ...
def memset(dst: _CVoidPLike, c: int, count: int) -> None: ...
def POINTER(type: Type[_CT]) -> Type[pointer[_CT]]: ...
# The real ctypes.pointer is a function, not a class. The stub version of pointer behaves like
# ctypes._Pointer in that it is the base class for all pointer types. Unlike the real _Pointer,
# it can be instantiated directly (to mimic the behavior of the real pointer function).
class pointer(Generic[_CT], _PointerLike, _CData):
_type_: ClassVar[Type[_CT]] = ...
contents: _CT = ...
def __init__(self, arg: _CT = ...) -> None: ...
@overload
def __getitem__(self, i: int) -> _CT: ...
@overload
def __getitem__(self, s: slice) -> List[_CT]: ...
@overload
def __setitem__(self, i: int, o: _CT) -> None: ...
@overload
def __setitem__(self, s: slice, o: Iterable[_CT]) -> None: ...
def resize(obj: _CData, size: int) -> None: ...
if sys.version_info < (3,):
def set_conversion_mode(encoding: str, errors: str) -> Tuple[str, str]: ...
def set_errno(value: int) -> int: ...
if sys.platform == "win32":
def set_last_error(value: int) -> int: ...
def sizeof(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
def string_at(address: _CVoidConstPLike, size: int = ...) -> bytes: ...
if sys.platform == "win32":
def WinError(code: Optional[int] = ..., descr: Optional[str] = ...) -> OSError: ...
def wstring_at(address: _CVoidConstPLike, size: int = ...) -> str: ...
class _SimpleCData(Generic[_T], _CData):
value: _T = ...
def __init__(self, value: _T = ...) -> None: ...
class c_byte(_SimpleCData[int]): ...
class c_char(_SimpleCData[bytes]):
def __init__(self, value: _UnionT[int, bytes] = ...) -> None: ...
class c_char_p(_PointerLike, _SimpleCData[Optional[bytes]]):
def __init__(self, value: Optional[_UnionT[int, bytes]] = ...) -> None: ...
class c_double(_SimpleCData[float]): ...
class c_longdouble(_SimpleCData[float]): ...
class c_float(_SimpleCData[float]): ...
class c_int(_SimpleCData[int]): ...
class c_int8(_SimpleCData[int]): ...
class c_int16(_SimpleCData[int]): ...
class c_int32(_SimpleCData[int]): ...
class c_int64(_SimpleCData[int]): ...
class c_long(_SimpleCData[int]): ...
class c_longlong(_SimpleCData[int]): ...
class c_short(_SimpleCData[int]): ...
class c_size_t(_SimpleCData[int]): ...
class c_ssize_t(_SimpleCData[int]): ...
class c_ubyte(_SimpleCData[int]): ...
class c_uint(_SimpleCData[int]): ...
class c_uint8(_SimpleCData[int]): ...
class c_uint16(_SimpleCData[int]): ...
class c_uint32(_SimpleCData[int]): ...
class c_uint64(_SimpleCData[int]): ...
class c_ulong(_SimpleCData[int]): ...
class c_ulonglong(_SimpleCData[int]): ...
class c_ushort(_SimpleCData[int]): ...
class c_void_p(_PointerLike, _SimpleCData[Optional[int]]): ...
class c_wchar(_SimpleCData[Text]): ...
class c_wchar_p(_PointerLike, _SimpleCData[Optional[Text]]):
def __init__(self, value: Optional[_UnionT[int, Text]] = ...) -> None: ...
class c_bool(_SimpleCData[bool]):
def __init__(self, value: bool = ...) -> None: ...
if sys.platform == "win32":
class HRESULT(_SimpleCData[int]): ... # TODO undocumented
class py_object(_CanCastTo, _SimpleCData[_T]): ...
class _CField:
offset: int = ...
size: int = ...
class _StructUnionMeta(_CDataMeta):
_fields_: Sequence[_UnionT[Tuple[str, Type[_CData]], Tuple[str, Type[_CData], int]]] = ...
_pack_: int = ...
_anonymous_: Sequence[str] = ...
def __getattr__(self, name: str) -> _CField: ...
class _StructUnionBase(_CData, metaclass=_StructUnionMeta):
def __init__(self, *args: Any, **kw: Any) -> None: ...
def __getattr__(self, name: str) -> Any: ...
def __setattr__(self, name: str, value: Any) -> None: ...
class Union(_StructUnionBase): ...
class Structure(_StructUnionBase): ...
class BigEndianStructure(Structure): ...
class LittleEndianStructure(Structure): ...
class Array(Generic[_CT], _CData):
_length_: ClassVar[int] = ...
_type_: ClassVar[Type[_CT]] = ...
raw: bytes = ... # Note: only available if _CT == c_char
value: Any = ... # Note: bytes if _CT == c_char, Text if _CT == c_wchar, unavailable otherwise
# TODO These methods cannot be annotated correctly at the moment.
# All of these "Any"s stand for the array's element type, but it's not possible to use _CT
# here, because of a special feature of ctypes.
# By default, when accessing an element of an Array[_CT], the returned object has type _CT.
# However, when _CT is a "simple type" like c_int, ctypes automatically "unboxes" the object
# and converts it to the corresponding Python primitive. For example, when accessing an element
# of an Array[c_int], a Python int object is returned, not a c_int.
# This behavior does *not* apply to subclasses of "simple types".
# If MyInt is a subclass of c_int, then accessing an element of an Array[MyInt] returns
# a MyInt, not an int.
# This special behavior is not easy to model in a stub, so for now all places where
# the array element type would belong are annotated with Any instead.
def __init__(self, *args: Any) -> None: ...
@overload
def __getitem__(self, i: int) -> Any: ...
@overload
def __getitem__(self, s: slice) -> List[Any]: ...
@overload
def __setitem__(self, i: int, o: Any) -> None: ...
@overload
def __setitem__(self, s: slice, o: Iterable[Any]) -> None: ...
def __iter__(self) -> Iterator[Any]: ...
# Can't inherit from Sized because the metaclass conflict between
# Sized and _CData prevents using _CDataMeta.
def __len__(self) -> int: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
| 11,893 | Python | .py | 257 | 42.677043 | 125 | 0.634841 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,208 | domreg.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/dom/domreg.pyi | from _typeshed.xml import DOMImplementation
from typing import Any, Callable, Dict, Iterable, Optional, Tuple, Union
well_known_implementations: Dict[str, str]
registered: Dict[str, Callable[[], DOMImplementation]]
def registerDOMImplementation(name: str, factory: Callable[[], DOMImplementation]) -> None: ...
def getDOMImplementation(
name: Optional[str] = ..., features: Union[str, Iterable[Tuple[str, Optional[str]]]] = ...
) -> DOMImplementation: ...
| 462 | Python | .py | 8 | 56 | 95 | 0.752212 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,209 | expatbuilder.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/dom/expatbuilder.pyi | from typing import Any
def __getattr__(name: str) -> Any: ... # incomplete
| 77 | Python | .py | 2 | 37 | 52 | 0.662162 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,210 | pulldom.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/dom/pulldom.pyi | from typing import Any
def __getattr__(name: str) -> Any: ... # incomplete
| 77 | Python | .py | 2 | 37 | 52 | 0.662162 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,211 | NodeFilter.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/dom/NodeFilter.pyi | class NodeFilter:
FILTER_ACCEPT: int
FILTER_REJECT: int
FILTER_SKIP: int
SHOW_ALL: int
SHOW_ELEMENT: int
SHOW_ATTRIBUTE: int
SHOW_TEXT: int
SHOW_CDATA_SECTION: int
SHOW_ENTITY_REFERENCE: int
SHOW_ENTITY: int
SHOW_PROCESSING_INSTRUCTION: int
SHOW_COMMENT: int
SHOW_DOCUMENT: int
SHOW_DOCUMENT_TYPE: int
SHOW_DOCUMENT_FRAGMENT: int
SHOW_NOTATION: int
def acceptNode(self, node) -> int: ...
| 457 | Python | .py | 18 | 20.555556 | 42 | 0.687215 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,212 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/dom/__init__.pyi | from typing import Any
from .domreg import getDOMImplementation as getDOMImplementation, registerDOMImplementation as registerDOMImplementation
class Node:
ELEMENT_NODE: int
ATTRIBUTE_NODE: int
TEXT_NODE: int
CDATA_SECTION_NODE: int
ENTITY_REFERENCE_NODE: int
ENTITY_NODE: int
PROCESSING_INSTRUCTION_NODE: int
COMMENT_NODE: int
DOCUMENT_NODE: int
DOCUMENT_TYPE_NODE: int
DOCUMENT_FRAGMENT_NODE: int
NOTATION_NODE: int
# ExceptionCode
INDEX_SIZE_ERR: int
DOMSTRING_SIZE_ERR: int
HIERARCHY_REQUEST_ERR: int
WRONG_DOCUMENT_ERR: int
INVALID_CHARACTER_ERR: int
NO_DATA_ALLOWED_ERR: int
NO_MODIFICATION_ALLOWED_ERR: int
NOT_FOUND_ERR: int
NOT_SUPPORTED_ERR: int
INUSE_ATTRIBUTE_ERR: int
INVALID_STATE_ERR: int
SYNTAX_ERR: int
INVALID_MODIFICATION_ERR: int
NAMESPACE_ERR: int
INVALID_ACCESS_ERR: int
VALIDATION_ERR: int
class DOMException(Exception):
code: int
def __init__(self, *args: Any, **kw: Any) -> None: ...
def _get_code(self) -> int: ...
class IndexSizeErr(DOMException): ...
class DomstringSizeErr(DOMException): ...
class HierarchyRequestErr(DOMException): ...
class WrongDocumentErr(DOMException): ...
class NoDataAllowedErr(DOMException): ...
class NoModificationAllowedErr(DOMException): ...
class NotFoundErr(DOMException): ...
class NotSupportedErr(DOMException): ...
class InuseAttributeErr(DOMException): ...
class InvalidStateErr(DOMException): ...
class SyntaxErr(DOMException): ...
class InvalidModificationErr(DOMException): ...
class NamespaceErr(DOMException): ...
class InvalidAccessErr(DOMException): ...
class ValidationErr(DOMException): ...
class UserDataHandler:
NODE_CLONED: int
NODE_IMPORTED: int
NODE_DELETED: int
NODE_RENAMED: int
XML_NAMESPACE: str
XMLNS_NAMESPACE: str
XHTML_NAMESPACE: str
EMPTY_NAMESPACE: None
EMPTY_PREFIX: None
| 1,844 | Python | .py | 61 | 27.868852 | 120 | 0.778716 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,213 | minicompat.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/dom/minicompat.pyi | from typing import Any
def __getattr__(name: str) -> Any: ... # incomplete
| 77 | Python | .py | 2 | 37 | 52 | 0.662162 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,214 | xmlbuilder.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/dom/xmlbuilder.pyi | from typing import Any
def __getattr__(name: str) -> Any: ... # incomplete
| 77 | Python | .py | 2 | 37 | 52 | 0.662162 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,215 | minidom.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/dom/minidom.pyi | from typing import Any, Optional
from xml.sax.xmlreader import XMLReader
def parse(file: str, parser: Optional[XMLReader] = ..., bufsize: Optional[int] = ...): ...
def parseString(string: str, parser: Optional[XMLReader] = ...): ...
def __getattr__(name: str) -> Any: ... # incomplete
| 287 | Python | .py | 5 | 56.2 | 90 | 0.686833 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,216 | xmlreader.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/sax/xmlreader.pyi | from typing import Mapping, Optional, Tuple
class XMLReader:
def __init__(self) -> None: ...
def parse(self, source): ...
def getContentHandler(self): ...
def setContentHandler(self, handler): ...
def getDTDHandler(self): ...
def setDTDHandler(self, handler): ...
def getEntityResolver(self): ...
def setEntityResolver(self, resolver): ...
def getErrorHandler(self): ...
def setErrorHandler(self, handler): ...
def setLocale(self, locale): ...
def getFeature(self, name): ...
def setFeature(self, name, state): ...
def getProperty(self, name): ...
def setProperty(self, name, value): ...
class IncrementalParser(XMLReader):
def __init__(self, bufsize: int = ...) -> None: ...
def parse(self, source): ...
def feed(self, data): ...
def prepareParser(self, source): ...
def close(self): ...
def reset(self): ...
class Locator:
def getColumnNumber(self): ...
def getLineNumber(self): ...
def getPublicId(self): ...
def getSystemId(self): ...
class InputSource:
def __init__(self, system_id: Optional[str] = ...) -> None: ...
def setPublicId(self, public_id): ...
def getPublicId(self): ...
def setSystemId(self, system_id): ...
def getSystemId(self): ...
def setEncoding(self, encoding): ...
def getEncoding(self): ...
def setByteStream(self, bytefile): ...
def getByteStream(self): ...
def setCharacterStream(self, charfile): ...
def getCharacterStream(self): ...
class AttributesImpl:
def __init__(self, attrs: Mapping[str, str]) -> None: ...
def getLength(self): ...
def getType(self, name): ...
def getValue(self, name): ...
def getValueByQName(self, name): ...
def getNameByQName(self, name): ...
def getQNameByName(self, name): ...
def getNames(self): ...
def getQNames(self): ...
def __len__(self): ...
def __getitem__(self, name): ...
def keys(self): ...
def has_key(self, name): ...
def __contains__(self, name): ...
def get(self, name, alternative=...): ...
def copy(self): ...
def items(self): ...
def values(self): ...
class AttributesNSImpl(AttributesImpl):
def __init__(self, attrs: Mapping[Tuple[str, str], str], qnames: Mapping[Tuple[str, str], str]) -> None: ...
def getValueByQName(self, name): ...
def getNameByQName(self, name): ...
def getQNameByName(self, name): ...
def getQNames(self): ...
def copy(self): ...
| 2,477 | Python | .py | 67 | 32.298507 | 112 | 0.616057 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,217 | handler.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/sax/handler.pyi | from typing import Any
version: Any
class ErrorHandler:
def error(self, exception): ...
def fatalError(self, exception): ...
def warning(self, exception): ...
class ContentHandler:
def __init__(self) -> None: ...
def setDocumentLocator(self, locator): ...
def startDocument(self): ...
def endDocument(self): ...
def startPrefixMapping(self, prefix, uri): ...
def endPrefixMapping(self, prefix): ...
def startElement(self, name, attrs): ...
def endElement(self, name): ...
def startElementNS(self, name, qname, attrs): ...
def endElementNS(self, name, qname): ...
def characters(self, content): ...
def ignorableWhitespace(self, whitespace): ...
def processingInstruction(self, target, data): ...
def skippedEntity(self, name): ...
class DTDHandler:
def notationDecl(self, name, publicId, systemId): ...
def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
class EntityResolver:
def resolveEntity(self, publicId, systemId): ...
feature_namespaces: Any
feature_namespace_prefixes: Any
feature_string_interning: Any
feature_validation: Any
feature_external_ges: Any
feature_external_pes: Any
all_features: Any
property_lexical_handler: Any
property_declaration_handler: Any
property_dom_node: Any
property_xml_string: Any
property_encoding: Any
property_interning_dict: Any
all_properties: Any
| 1,391 | Python | .py | 40 | 31.625 | 70 | 0.724907 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,218 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/sax/__init__.pyi | import sys
from typing import IO, Any, Iterable, List, NoReturn, Optional, Text, Union
from xml.sax.handler import ContentHandler, ErrorHandler
from xml.sax.xmlreader import Locator, XMLReader
class SAXException(Exception):
def __init__(self, msg: str, exception: Optional[Exception] = ...) -> None: ...
def getMessage(self) -> str: ...
def getException(self) -> Exception: ...
def __getitem__(self, ix: Any) -> NoReturn: ...
class SAXParseException(SAXException):
def __init__(self, msg: str, exception: Exception, locator: Locator) -> None: ...
def getColumnNumber(self) -> int: ...
def getLineNumber(self) -> int: ...
def getPublicId(self): ...
def getSystemId(self): ...
class SAXNotRecognizedException(SAXException): ...
class SAXNotSupportedException(SAXException): ...
class SAXReaderNotAvailable(SAXNotSupportedException): ...
default_parser_list: List[str]
if sys.version_info >= (3, 8):
def make_parser(parser_list: Iterable[str] = ...) -> XMLReader: ...
else:
def make_parser(parser_list: List[str] = ...) -> XMLReader: ...
def parse(source: Union[str, IO[str], IO[bytes]], handler: ContentHandler, errorHandler: ErrorHandler = ...) -> None: ...
def parseString(string: Union[bytes, Text], handler: ContentHandler, errorHandler: Optional[ErrorHandler] = ...) -> None: ...
def _create_parser(parser_name: str) -> XMLReader: ...
| 1,389 | Python | .py | 26 | 50.461538 | 125 | 0.699115 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,219 | saxutils.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/sax/saxutils.pyi | import sys
from _typeshed import SupportsWrite
from codecs import StreamReaderWriter, StreamWriter
from io import RawIOBase, TextIOBase
from typing import Mapping, Optional, Text, Union
from xml.sax import handler, xmlreader
def escape(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ...
def unescape(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ...
def quoteattr(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ...
class XMLGenerator(handler.ContentHandler):
if sys.version_info >= (3, 0):
def __init__(
self,
out: Optional[Union[TextIOBase, RawIOBase, StreamWriter, StreamReaderWriter, SupportsWrite[str]]] = ...,
encoding: str = ...,
short_empty_elements: bool = ...,
) -> None: ...
else:
def __init__(
self,
out: Optional[Union[TextIOBase, RawIOBase, StreamWriter, StreamReaderWriter, SupportsWrite[str]]] = ...,
encoding: Text = ...,
) -> None: ...
def startDocument(self): ...
def endDocument(self): ...
def startPrefixMapping(self, prefix, uri): ...
def endPrefixMapping(self, prefix): ...
def startElement(self, name, attrs): ...
def endElement(self, name): ...
def startElementNS(self, name, qname, attrs): ...
def endElementNS(self, name, qname): ...
def characters(self, content): ...
def ignorableWhitespace(self, content): ...
def processingInstruction(self, target, data): ...
class XMLFilterBase(xmlreader.XMLReader):
def __init__(self, parent: Optional[xmlreader.XMLReader] = ...) -> None: ...
def error(self, exception): ...
def fatalError(self, exception): ...
def warning(self, exception): ...
def setDocumentLocator(self, locator): ...
def startDocument(self): ...
def endDocument(self): ...
def startPrefixMapping(self, prefix, uri): ...
def endPrefixMapping(self, prefix): ...
def startElement(self, name, attrs): ...
def endElement(self, name): ...
def startElementNS(self, name, qname, attrs): ...
def endElementNS(self, name, qname): ...
def characters(self, content): ...
def ignorableWhitespace(self, chars): ...
def processingInstruction(self, target, data): ...
def skippedEntity(self, name): ...
def notationDecl(self, name, publicId, systemId): ...
def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
def resolveEntity(self, publicId, systemId): ...
def parse(self, source): ...
def setLocale(self, locale): ...
def getFeature(self, name): ...
def setFeature(self, name, state): ...
def getProperty(self, name): ...
def setProperty(self, name, value): ...
def getParent(self): ...
def setParent(self, parent): ...
def prepare_input_source(source, base=...): ...
| 2,825 | Python | .py | 64 | 38.703125 | 116 | 0.644178 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,220 | ElementInclude.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/etree/ElementInclude.pyi | import sys
from typing import Callable, Optional, Union
from xml.etree.ElementTree import Element
XINCLUDE: str
XINCLUDE_INCLUDE: str
XINCLUDE_FALLBACK: str
class FatalIncludeError(SyntaxError): ...
def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str] = ...) -> Union[str, Element]: ...
# TODO: loader is of type default_loader ie it takes a callable that has the
# same signature as default_loader. But default_loader has a keyword argument
# Which can't be represented using Callable...
if sys.version_info >= (3, 9):
def include(
elem: Element,
loader: Optional[Callable[..., Union[str, Element]]] = ...,
base_url: Optional[str] = ...,
max_depth: Optional[int] = ...,
) -> None: ...
else:
def include(elem: Element, loader: Optional[Callable[..., Union[str, Element]]] = ...) -> None: ...
| 873 | Python | .py | 20 | 40.2 | 119 | 0.685142 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,221 | ElementPath.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/etree/ElementPath.pyi | from typing import Callable, Dict, Generator, List, Optional, Pattern, Tuple, TypeVar, Union
from xml.etree.ElementTree import Element
xpath_tokenizer_re: Pattern[str]
_token = Tuple[str, str]
_next = Callable[[], _token]
_callback = Callable[[_SelectorContext, List[Element]], Generator[Element, None, None]]
def xpath_tokenizer(pattern: str, namespaces: Optional[Dict[str, str]] = ...) -> Generator[_token, None, None]: ...
def get_parent_map(context: _SelectorContext) -> Dict[Element, Element]: ...
def prepare_child(next: _next, token: _token) -> _callback: ...
def prepare_star(next: _next, token: _token) -> _callback: ...
def prepare_self(next: _next, token: _token) -> _callback: ...
def prepare_descendant(next: _next, token: _token) -> _callback: ...
def prepare_parent(next: _next, token: _token) -> _callback: ...
def prepare_predicate(next: _next, token: _token) -> _callback: ...
ops: Dict[str, Callable[[_next, _token], _callback]]
class _SelectorContext:
parent_map: Dict[Element, Element]
root: Element
def __init__(self, root: Element) -> None: ...
_T = TypeVar("_T")
def iterfind(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> List[Element]: ...
def find(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> Optional[Element]: ...
def findall(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> List[Element]: ...
def findtext(
elem: Element, path: str, default: Optional[_T] = ..., namespaces: Optional[Dict[str, str]] = ...
) -> Union[_T, str]: ...
| 1,561 | Python | .py | 26 | 58.153846 | 115 | 0.676047 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,222 | ElementTree.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/xml/etree/ElementTree.pyi | import sys
from _typeshed import AnyPath, FileDescriptor, SupportsWrite
from typing import (
IO,
Any,
Callable,
Dict,
Generator,
ItemsView,
Iterable,
Iterator,
KeysView,
List,
MutableSequence,
Optional,
Sequence,
Text,
Tuple,
TypeVar,
Union,
overload,
)
from typing_extensions import Literal
VERSION: str
class ParseError(SyntaxError):
code: int
position: Tuple[int, int]
def iselement(element: object) -> bool: ...
_T = TypeVar("_T")
# Type for parser inputs. Parser will accept any unicode/str/bytes and coerce,
# and this is true in py2 and py3 (even fromstringlist() in python3 can be
# called with a heterogeneous list)
_parser_input_type = Union[bytes, Text]
# Type for individual tag/attr/ns/text values in args to most functions.
# In py2, the library accepts str or unicode everywhere and coerces
# aggressively.
# In py3, bytes is not coerced to str and so use of bytes is probably an error,
# so we exclude it. (why? the parser never produces bytes when it parses XML,
# so e.g., element.get(b'name') will always return None for parsed XML, even if
# there is a 'name' attribute.)
_str_argument_type = Union[str, Text]
# Type for return values from individual tag/attr/text values
if sys.version_info >= (3,):
# note: in python3, everything comes out as str, yay:
_str_result_type = str
else:
# in python2, if the tag/attribute/text wasn't decode-able as ascii, it
# comes out as a unicode string; otherwise it comes out as str. (see
# _fixtext function in the source). Client code knows best:
_str_result_type = Any
_file_or_filename = Union[AnyPath, FileDescriptor, IO[Any]]
if sys.version_info >= (3, 8):
@overload
def canonicalize(
xml_data: Optional[_parser_input_type] = ...,
*,
out: None = ...,
from_file: Optional[_file_or_filename] = ...,
with_comments: bool = ...,
strip_text: bool = ...,
rewrite_prefixes: bool = ...,
qname_aware_tags: Optional[Iterable[str]] = ...,
qname_aware_attrs: Optional[Iterable[str]] = ...,
exclude_attrs: Optional[Iterable[str]] = ...,
exclude_tags: Optional[Iterable[str]] = ...,
) -> str: ...
@overload
def canonicalize(
xml_data: Optional[_parser_input_type] = ...,
*,
out: SupportsWrite[str],
from_file: Optional[_file_or_filename] = ...,
with_comments: bool = ...,
strip_text: bool = ...,
rewrite_prefixes: bool = ...,
qname_aware_tags: Optional[Iterable[str]] = ...,
qname_aware_attrs: Optional[Iterable[str]] = ...,
exclude_attrs: Optional[Iterable[str]] = ...,
exclude_tags: Optional[Iterable[str]] = ...,
) -> None: ...
class Element(MutableSequence[Element]):
tag: _str_result_type
attrib: Dict[_str_result_type, _str_result_type]
text: Optional[_str_result_type]
tail: Optional[_str_result_type]
def __init__(
self,
tag: Union[_str_argument_type, Callable[..., Element]],
attrib: Dict[_str_argument_type, _str_argument_type] = ...,
**extra: _str_argument_type,
) -> None: ...
def append(self, __subelement: Element) -> None: ...
def clear(self) -> None: ...
def extend(self, __elements: Iterable[Element]) -> None: ...
def find(
self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...
) -> Optional[Element]: ...
def findall(
self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...
) -> List[Element]: ...
@overload
def findtext(
self,
path: _str_argument_type,
default: None = ...,
namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...,
) -> Optional[_str_result_type]: ...
@overload
def findtext(
self, path: _str_argument_type, default: _T, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...
) -> Union[_T, _str_result_type]: ...
@overload
def get(self, key: _str_argument_type, default: None = ...) -> Optional[_str_result_type]: ...
@overload
def get(self, key: _str_argument_type, default: _T) -> Union[_str_result_type, _T]: ...
if sys.version_info >= (3, 2):
def insert(self, __index: int, __subelement: Element) -> None: ...
else:
def insert(self, __index: int, __element: Element) -> None: ...
def items(self) -> ItemsView[_str_result_type, _str_result_type]: ...
def iter(self, tag: Optional[_str_argument_type] = ...) -> Generator[Element, None, None]: ...
def iterfind(
self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...
) -> List[Element]: ...
def itertext(self) -> Generator[_str_result_type, None, None]: ...
def keys(self) -> KeysView[_str_result_type]: ...
def makeelement(self, __tag: _str_argument_type, __attrib: Dict[_str_argument_type, _str_argument_type]) -> Element: ...
def remove(self, __subelement: Element) -> None: ...
def set(self, __key: _str_argument_type, __value: _str_argument_type) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
@overload
def __getitem__(self, i: int) -> Element: ...
@overload
def __getitem__(self, s: slice) -> MutableSequence[Element]: ...
def __len__(self) -> int: ...
@overload
def __setitem__(self, i: int, o: Element) -> None: ...
@overload
def __setitem__(self, s: slice, o: Iterable[Element]) -> None: ...
if sys.version_info < (3, 9):
def getchildren(self) -> List[Element]: ...
def getiterator(self, tag: Optional[_str_argument_type] = ...) -> List[Element]: ...
def SubElement(
parent: Element,
tag: _str_argument_type,
attrib: Dict[_str_argument_type, _str_argument_type] = ...,
**extra: _str_argument_type,
) -> Element: ...
def Comment(text: Optional[_str_argument_type] = ...) -> Element: ...
def ProcessingInstruction(target: _str_argument_type, text: Optional[_str_argument_type] = ...) -> Element: ...
PI: Callable[..., Element]
class QName:
text: str
def __init__(self, text_or_uri: _str_argument_type, tag: Optional[_str_argument_type] = ...) -> None: ...
class ElementTree:
def __init__(self, element: Optional[Element] = ..., file: Optional[_file_or_filename] = ...) -> None: ...
def getroot(self) -> Element: ...
def parse(self, source: _file_or_filename, parser: Optional[XMLParser] = ...) -> Element: ...
def iter(self, tag: Optional[_str_argument_type] = ...) -> Generator[Element, None, None]: ...
if sys.version_info < (3, 9):
def getiterator(self, tag: Optional[_str_argument_type] = ...) -> List[Element]: ...
def find(
self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...
) -> Optional[Element]: ...
@overload
def findtext(
self,
path: _str_argument_type,
default: None = ...,
namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...,
) -> Optional[_str_result_type]: ...
@overload
def findtext(
self, path: _str_argument_type, default: _T, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...
) -> Union[_T, _str_result_type]: ...
def findall(
self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...
) -> List[Element]: ...
def iterfind(
self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ...
) -> List[Element]: ...
if sys.version_info >= (3, 4):
def write(
self,
file_or_filename: _file_or_filename,
encoding: Optional[str] = ...,
xml_declaration: Optional[bool] = ...,
default_namespace: Optional[_str_argument_type] = ...,
method: Optional[str] = ...,
*,
short_empty_elements: bool = ...,
) -> None: ...
else:
def write(
self,
file_or_filename: _file_or_filename,
encoding: Optional[str] = ...,
xml_declaration: Optional[bool] = ...,
default_namespace: Optional[_str_argument_type] = ...,
method: Optional[str] = ...,
) -> None: ...
def write_c14n(self, file: _file_or_filename) -> None: ...
def register_namespace(prefix: _str_argument_type, uri: _str_argument_type) -> None: ...
if sys.version_info >= (3, 8):
@overload
def tostring(
element: Element,
encoding: None = ...,
method: Optional[str] = ...,
*,
xml_declaration: Optional[bool] = ...,
default_namespace: Optional[_str_argument_type] = ...,
short_empty_elements: bool = ...,
) -> bytes: ...
@overload
def tostring(
element: Element,
encoding: Literal["unicode"],
method: Optional[str] = ...,
*,
xml_declaration: Optional[bool] = ...,
default_namespace: Optional[_str_argument_type] = ...,
short_empty_elements: bool = ...,
) -> str: ...
@overload
def tostring(
element: Element,
encoding: str,
method: Optional[str] = ...,
*,
xml_declaration: Optional[bool] = ...,
default_namespace: Optional[_str_argument_type] = ...,
short_empty_elements: bool = ...,
) -> Any: ...
@overload
def tostringlist(
element: Element,
encoding: None = ...,
method: Optional[str] = ...,
*,
xml_declaration: Optional[bool] = ...,
default_namespace: Optional[_str_argument_type] = ...,
short_empty_elements: bool = ...,
) -> List[bytes]: ...
@overload
def tostringlist(
element: Element,
encoding: Literal["unicode"],
method: Optional[str] = ...,
*,
xml_declaration: Optional[bool] = ...,
default_namespace: Optional[_str_argument_type] = ...,
short_empty_elements: bool = ...,
) -> List[str]: ...
@overload
def tostringlist(
element: Element,
encoding: str,
method: Optional[str] = ...,
*,
xml_declaration: Optional[bool] = ...,
default_namespace: Optional[_str_argument_type] = ...,
short_empty_elements: bool = ...,
) -> List[Any]: ...
elif sys.version_info >= (3,):
@overload
def tostring(
element: Element, encoding: None = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ...
) -> bytes: ...
@overload
def tostring(
element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, short_empty_elements: bool = ...
) -> str: ...
@overload
def tostring(element: Element, encoding: str, method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> Any: ...
@overload
def tostringlist(
element: Element, encoding: None = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ...
) -> List[bytes]: ...
@overload
def tostringlist(
element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, short_empty_elements: bool = ...
) -> List[str]: ...
@overload
def tostringlist(
element: Element, encoding: str, method: Optional[str] = ..., *, short_empty_elements: bool = ...
) -> List[Any]: ...
else:
def tostring(element: Element, encoding: Optional[str] = ..., method: Optional[str] = ...) -> bytes: ...
def tostringlist(element: Element, encoding: Optional[str] = ..., method: Optional[str] = ...) -> List[bytes]: ...
def dump(elem: Element) -> None: ...
def parse(source: _file_or_filename, parser: Optional[XMLParser] = ...) -> ElementTree: ...
def iterparse(
source: _file_or_filename, events: Optional[Sequence[str]] = ..., parser: Optional[XMLParser] = ...
) -> Iterator[Tuple[str, Any]]: ...
if sys.version_info >= (3, 4):
class XMLPullParser:
def __init__(self, events: Optional[Sequence[str]] = ..., *, _parser: Optional[XMLParser] = ...) -> None: ...
def feed(self, data: bytes) -> None: ...
def close(self) -> None: ...
def read_events(self) -> Iterator[Tuple[str, Element]]: ...
def XML(text: _parser_input_type, parser: Optional[XMLParser] = ...) -> Element: ...
def XMLID(text: _parser_input_type, parser: Optional[XMLParser] = ...) -> Tuple[Element, Dict[_str_result_type, Element]]: ...
# This is aliased to XML in the source.
fromstring = XML
def fromstringlist(sequence: Sequence[_parser_input_type], parser: Optional[XMLParser] = ...) -> Element: ...
# This type is both not precise enough and too precise. The TreeBuilder
# requires the elementfactory to accept tag and attrs in its args and produce
# some kind of object that has .text and .tail properties.
# I've chosen to constrain the ElementFactory to always produce an Element
# because that is how almost everyone will use it.
# Unfortunately, the type of the factory arguments is dependent on how
# TreeBuilder is called by client code (they could pass strs, bytes or whatever);
# but we don't want to use a too-broad type, or it would be too hard to write
# elementfactories.
_ElementFactory = Callable[[Any, Dict[Any, Any]], Element]
class TreeBuilder:
def __init__(self, element_factory: Optional[_ElementFactory] = ...) -> None: ...
def close(self) -> Element: ...
def data(self, __data: _parser_input_type) -> None: ...
def start(self, __tag: _parser_input_type, __attrs: Dict[_parser_input_type, _parser_input_type]) -> Element: ...
def end(self, __tag: _parser_input_type) -> Element: ...
if sys.version_info >= (3, 8):
class C14NWriterTarget:
def __init__(
self,
write: Callable[[str], Any],
*,
with_comments: bool = ...,
strip_text: bool = ...,
rewrite_prefixes: bool = ...,
qname_aware_tags: Optional[Iterable[str]] = ...,
qname_aware_attrs: Optional[Iterable[str]] = ...,
exclude_attrs: Optional[Iterable[str]] = ...,
exclude_tags: Optional[Iterable[str]] = ...,
) -> None: ...
class XMLParser:
parser: Any
target: Any
# TODO-what is entity used for???
entity: Any
version: str
if sys.version_info >= (3, 8):
def __init__(self, *, target: Any = ..., encoding: Optional[str] = ...) -> None: ...
else:
def __init__(self, html: int = ..., target: Any = ..., encoding: Optional[str] = ...) -> None: ...
def doctype(self, __name: str, __pubid: str, __system: str) -> None: ...
def close(self) -> Any: ...
def feed(self, __data: _parser_input_type) -> None: ...
| 14,905 | Python | .py | 349 | 36.553009 | 127 | 0.60073 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,223 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/ensurepip/__init__.pyi | import sys
from typing import Optional
def version() -> str: ...
if sys.version_info >= (3, 0):
def bootstrap(
*,
root: Optional[str] = ...,
upgrade: bool = ...,
user: bool = ...,
altinstall: bool = ...,
default_pip: bool = ...,
verbosity: int = ...,
) -> None: ...
else:
def bootstrap(
root: Optional[str] = ...,
upgrade: bool = ...,
user: bool = ...,
altinstall: bool = ...,
default_pip: bool = ...,
verbosity: int = ...,
) -> None: ...
| 562 | Python | .py | 22 | 18.954545 | 34 | 0.461825 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,224 | schema.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/msilib/schema.pyi | import sys
from typing import List, Optional, Tuple
if sys.platform == "win32":
from . import Table
_Validation: Table
ActionText: Table
AdminExecuteSequence: Table
Condition: Table
AdminUISequence: Table
AdvtExecuteSequence: Table
AdvtUISequence: Table
AppId: Table
AppSearch: Table
Property: Table
BBControl: Table
Billboard: Table
Feature: Table
Binary: Table
BindImage: Table
File: Table
CCPSearch: Table
CheckBox: Table
Class: Table
Component: Table
Icon: Table
ProgId: Table
ComboBox: Table
CompLocator: Table
Complus: Table
Directory: Table
Control: Table
Dialog: Table
ControlCondition: Table
ControlEvent: Table
CreateFolder: Table
CustomAction: Table
DrLocator: Table
DuplicateFile: Table
Environment: Table
Error: Table
EventMapping: Table
Extension: Table
MIME: Table
FeatureComponents: Table
FileSFPCatalog: Table
SFPCatalog: Table
Font: Table
IniFile: Table
IniLocator: Table
InstallExecuteSequence: Table
InstallUISequence: Table
IsolatedComponent: Table
LaunchCondition: Table
ListBox: Table
ListView: Table
LockPermissions: Table
Media: Table
MoveFile: Table
MsiAssembly: Table
MsiAssemblyName: Table
MsiDigitalCertificate: Table
MsiDigitalSignature: Table
MsiFileHash: Table
MsiPatchHeaders: Table
ODBCAttribute: Table
ODBCDriver: Table
ODBCDataSource: Table
ODBCSourceAttribute: Table
ODBCTranslator: Table
Patch: Table
PatchPackage: Table
PublishComponent: Table
RadioButton: Table
Registry: Table
RegLocator: Table
RemoveFile: Table
RemoveIniFile: Table
RemoveRegistry: Table
ReserveCost: Table
SelfReg: Table
ServiceControl: Table
ServiceInstall: Table
Shortcut: Table
Signature: Table
TextStyle: Table
TypeLib: Table
UIText: Table
Upgrade: Table
Verb: Table
tables: List[Table]
_Validation_records: List[
Tuple[str, str, str, Optional[int], Optional[int], Optional[str], Optional[int], Optional[str], Optional[str], str]
]
| 2,214 | Python | .py | 93 | 18.849462 | 123 | 0.717525 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,225 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/msilib/__init__.pyi | import sys
from types import ModuleType
from typing import Any, Container, Dict, Iterable, List, Optional, Sequence, Set, Tuple, Type, Union
from typing_extensions import Literal
if sys.platform == "win32":
from _msi import _Database
AMD64: bool
if sys.version_info < (3, 7):
Itanium: bool
Win64: bool
datasizemask: Literal[0x00FF]
type_valid: Literal[0x0100]
type_localizable: Literal[0x0200]
typemask: Literal[0x0C00]
type_long: Literal[0x0000]
type_short: Literal[0x0400]
type_string: Literal[0x0C00]
type_binary: Literal[0x0800]
type_nullable: Literal[0x1000]
type_key: Literal[0x2000]
knownbits: Literal[0x3FFF]
class Table:
name: str
fields: List[Tuple[int, str, int]]
def __init__(self, name: str) -> None: ...
def add_field(self, index: int, name: str, type: int) -> None: ...
def sql(self) -> str: ...
def create(self, db: _Database) -> None: ...
class _Unspecified: ...
def change_sequence(
seq: Sequence[Tuple[str, Optional[str], int]],
action: str,
seqno: Union[int, Type[_Unspecified]] = ...,
cond: Union[str, Type[_Unspecified]] = ...,
) -> None: ...
def add_data(db: _Database, table: str, values: Iterable[Tuple[Any, ...]]) -> None: ...
def add_stream(db: _Database, name: str, path: str) -> None: ...
def init_database(
name: str, schema: ModuleType, ProductName: str, ProductCode: str, ProductVersion: str, Manufacturer: str
) -> _Database: ...
def add_tables(db: _Database, module: ModuleType) -> None: ...
def make_id(str: str) -> str: ...
def gen_uuid() -> str: ...
class CAB:
name: str
files: List[Tuple[str, str]]
filenames: Set[str]
index: int
def __init__(self, name: str) -> None: ...
def gen_id(self, file: str) -> str: ...
def append(self, full: str, file: str, logical: str) -> Tuple[int, str]: ...
def commit(self, db: _Database) -> None: ...
_directories: Set[str]
class Directory:
db: _Database
cab: CAB
basedir: str
physical: str
logical: str
component: Optional[str]
short_names: Set[str]
ids: Set[str]
keyfiles: Dict[str, str]
componentflags: Optional[int]
absolute: str
def __init__(
self,
db: _Database,
cab: CAB,
basedir: str,
physical: str,
_logical: str,
default: str,
componentflags: Optional[int] = ...,
) -> None: ...
def start_component(
self,
component: Optional[str] = ...,
feature: Optional[Feature] = ...,
flags: Optional[int] = ...,
keyfile: Optional[str] = ...,
uuid: Optional[str] = ...,
) -> None: ...
def make_short(self, file: str) -> str: ...
def add_file(
self, file: str, src: Optional[str] = ..., version: Optional[str] = ..., language: Optional[str] = ...
) -> str: ...
def glob(self, pattern: str, exclude: Optional[Container[str]] = ...) -> List[str]: ...
def remove_pyc(self) -> None: ...
class Binary:
name: str
def __init__(self, fname: str) -> None: ...
def __repr__(self) -> str: ...
class Feature:
id: str
def __init__(
self,
db: _Database,
id: str,
title: str,
desc: str,
display: int,
level: int = ...,
parent: Optional[Feature] = ...,
directory: Optional[str] = ...,
attributes: int = ...,
) -> None: ...
def set_current(self) -> None: ...
class Control:
dlg: Dialog
name: str
def __init__(self, dlg: Dialog, name: str) -> None: ...
def event(self, event: str, argument: str, condition: str = ..., ordering: Optional[int] = ...) -> None: ...
def mapping(self, event: str, attribute: str) -> None: ...
def condition(self, action: str, condition: str) -> None: ...
class RadioButtonGroup(Control):
property: str
index: int
def __init__(self, dlg: Dialog, name: str, property: str) -> None: ...
def add(self, name: str, x: int, y: int, w: int, h: int, text: str, value: Optional[str] = ...) -> None: ...
class Dialog:
db: _Database
name: str
x: int
y: int
w: int
h: int
def __init__(
self,
db: _Database,
name: str,
x: int,
y: int,
w: int,
h: int,
attr: int,
title: str,
first: str,
default: str,
cancel: str,
) -> None: ...
def control(
self,
name: str,
type: str,
x: int,
y: int,
w: int,
h: int,
attr: int,
prop: Optional[str],
text: Optional[str],
next: Optional[str],
help: Optional[str],
) -> Control: ...
def text(self, name: str, x: int, y: int, w: int, h: int, attr: int, text: Optional[str]) -> Control: ...
def bitmap(self, name: str, x: int, y: int, w: int, h: int, text: Optional[str]) -> Control: ...
def line(self, name: str, x: int, y: int, w: int, h: int) -> Control: ...
def pushbutton(
self, name: str, x: int, y: int, w: int, h: int, attr: int, text: Optional[str], next: Optional[str]
) -> Control: ...
def radiogroup(
self,
name: str,
x: int,
y: int,
w: int,
h: int,
attr: int,
prop: Optional[str],
text: Optional[str],
next: Optional[str],
) -> RadioButtonGroup: ...
def checkbox(
self,
name: str,
x: int,
y: int,
w: int,
h: int,
attr: int,
prop: Optional[str],
text: Optional[str],
next: Optional[str],
) -> Control: ...
| 6,306 | Python | .py | 185 | 24.464865 | 116 | 0.497872 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,226 | sequence.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/msilib/sequence.pyi | import sys
from typing import List, Optional, Tuple
if sys.platform == "win32":
_SequenceType = List[Tuple[str, Optional[str], int]]
AdminExecuteSequence: _SequenceType
AdminUISequence: _SequenceType
AdvtExecuteSequence: _SequenceType
InstallExecuteSequence: _SequenceType
InstallUISequence: _SequenceType
tables: List[str]
| 356 | Python | .py | 10 | 31.4 | 56 | 0.77193 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,227 | text.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/msilib/text.pyi | import sys
from typing import List, Optional, Tuple
if sys.platform == "win32":
ActionText: List[Tuple[str, str, Optional[str]]]
UIText: List[Tuple[str, Optional[str]]]
tables: List[str]
| 202 | Python | .py | 6 | 30.166667 | 52 | 0.715026 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,228 | dbapi2.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/sqlite3/dbapi2.pyi | import os
import sys
from datetime import date, datetime, time
from typing import Any, Callable, Generator, Iterable, Iterator, List, Optional, Text, Tuple, Type, TypeVar, Union
_T = TypeVar("_T")
paramstyle: str
threadsafety: int
apilevel: str
Date = date
Time = time
Timestamp = datetime
def DateFromTicks(ticks: float) -> Date: ...
def TimeFromTicks(ticks: float) -> Time: ...
def TimestampFromTicks(ticks: float) -> Timestamp: ...
version_info: str
sqlite_version_info: Tuple[int, int, int]
if sys.version_info >= (3,):
Binary = memoryview
else:
Binary = buffer
# The remaining definitions are imported from _sqlite3.
PARSE_COLNAMES: int
PARSE_DECLTYPES: int
SQLITE_ALTER_TABLE: int
SQLITE_ANALYZE: int
SQLITE_ATTACH: int
SQLITE_CREATE_INDEX: int
SQLITE_CREATE_TABLE: int
SQLITE_CREATE_TEMP_INDEX: int
SQLITE_CREATE_TEMP_TABLE: int
SQLITE_CREATE_TEMP_TRIGGER: int
SQLITE_CREATE_TEMP_VIEW: int
SQLITE_CREATE_TRIGGER: int
SQLITE_CREATE_VIEW: int
SQLITE_DELETE: int
SQLITE_DENY: int
SQLITE_DETACH: int
SQLITE_DROP_INDEX: int
SQLITE_DROP_TABLE: int
SQLITE_DROP_TEMP_INDEX: int
SQLITE_DROP_TEMP_TABLE: int
SQLITE_DROP_TEMP_TRIGGER: int
SQLITE_DROP_TEMP_VIEW: int
SQLITE_DROP_TRIGGER: int
SQLITE_DROP_VIEW: int
SQLITE_IGNORE: int
SQLITE_INSERT: int
SQLITE_OK: int
SQLITE_PRAGMA: int
SQLITE_READ: int
SQLITE_REINDEX: int
SQLITE_SELECT: int
SQLITE_TRANSACTION: int
SQLITE_UPDATE: int
adapters: Any
converters: Any
sqlite_version: str
version: str
# TODO: adapt needs to get probed
def adapt(obj, protocol, alternate): ...
def complete_statement(sql: str) -> bool: ...
if sys.version_info >= (3, 7):
def connect(
database: Union[bytes, Text, os.PathLike[Text]],
timeout: float = ...,
detect_types: int = ...,
isolation_level: Optional[str] = ...,
check_same_thread: bool = ...,
factory: Optional[Type[Connection]] = ...,
cached_statements: int = ...,
uri: bool = ...,
) -> Connection: ...
elif sys.version_info >= (3, 4):
def connect(
database: Union[bytes, Text],
timeout: float = ...,
detect_types: int = ...,
isolation_level: Optional[str] = ...,
check_same_thread: bool = ...,
factory: Optional[Type[Connection]] = ...,
cached_statements: int = ...,
uri: bool = ...,
) -> Connection: ...
else:
def connect(
database: Union[bytes, Text],
timeout: float = ...,
detect_types: int = ...,
isolation_level: Optional[str] = ...,
check_same_thread: bool = ...,
factory: Optional[Type[Connection]] = ...,
cached_statements: int = ...,
) -> Connection: ...
def enable_callback_tracebacks(flag: bool) -> None: ...
def enable_shared_cache(do_enable: int) -> None: ...
def register_adapter(type: Type[_T], callable: Callable[[_T], Union[int, float, str, bytes]]) -> None: ...
def register_converter(typename: str, callable: Callable[[bytes], Any]) -> None: ...
if sys.version_info < (3, 8):
class Cache(object):
def __init__(self, *args, **kwargs) -> None: ...
def display(self, *args, **kwargs) -> None: ...
def get(self, *args, **kwargs) -> None: ...
class Connection(object):
DataError: Any
DatabaseError: Any
Error: Any
IntegrityError: Any
InterfaceError: Any
InternalError: Any
NotSupportedError: Any
OperationalError: Any
ProgrammingError: Any
Warning: Any
in_transaction: Any
isolation_level: Any
row_factory: Any
text_factory: Any
total_changes: Any
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
def close(self) -> None: ...
def commit(self) -> None: ...
def create_aggregate(self, name: str, num_params: int, aggregate_class: type) -> None: ...
def create_collation(self, name: str, callable: Any) -> None: ...
if sys.version_info >= (3, 8):
def create_function(self, name: str, num_params: int, func: Any, *, deterministic: bool = ...) -> None: ...
else:
def create_function(self, name: str, num_params: int, func: Any) -> None: ...
def cursor(self, cursorClass: Optional[type] = ...) -> Cursor: ...
def execute(self, sql: str, parameters: Iterable[Any] = ...) -> Cursor: ...
# TODO: please check in executemany() if seq_of_parameters type is possible like this
def executemany(self, sql: str, seq_of_parameters: Iterable[Iterable[Any]]) -> Cursor: ...
def executescript(self, sql_script: Union[bytes, Text]) -> Cursor: ...
def interrupt(self, *args: Any, **kwargs: Any) -> None: ...
def iterdump(self, *args: Any, **kwargs: Any) -> Generator[str, None, None]: ...
def rollback(self, *args: Any, **kwargs: Any) -> None: ...
# TODO: set_authorizer(authorzer_callback)
# see https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.set_authorizer
# returns [SQLITE_OK, SQLITE_DENY, SQLITE_IGNORE] so perhaps int
def set_authorizer(self, *args: Any, **kwargs: Any) -> None: ...
# set_progress_handler(handler, n) -> see https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.set_progress_handler
def set_progress_handler(self, *args: Any, **kwargs: Any) -> None: ...
def set_trace_callback(self, *args: Any, **kwargs: Any) -> None: ...
# enable_load_extension and load_extension is not available on python distributions compiled
# without sqlite3 loadable extension support. see footnotes https://docs.python.org/3/library/sqlite3.html#f1
def enable_load_extension(self, enabled: bool) -> None: ...
def load_extension(self, path: str) -> None: ...
if sys.version_info >= (3, 7):
def backup(
self,
target: Connection,
*,
pages: int = ...,
progress: Optional[Callable[[int, int, int], object]] = ...,
name: str = ...,
sleep: float = ...,
) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
def __enter__(self) -> Connection: ...
def __exit__(self, t: Optional[type] = ..., exc: Optional[BaseException] = ..., tb: Optional[Any] = ...) -> None: ...
class Cursor(Iterator[Any]):
arraysize: Any
connection: Any
description: Any
lastrowid: Any
row_factory: Any
rowcount: Any
# TODO: Cursor class accepts exactly 1 argument
# required type is sqlite3.Connection (which is imported as _Connection)
# however, the name of the __init__ variable is unknown
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
def close(self, *args: Any, **kwargs: Any) -> None: ...
def execute(self, sql: str, parameters: Iterable[Any] = ...) -> Cursor: ...
def executemany(self, sql: str, seq_of_parameters: Iterable[Iterable[Any]]) -> Cursor: ...
def executescript(self, sql_script: Union[bytes, Text]) -> Cursor: ...
def fetchall(self) -> List[Any]: ...
def fetchmany(self, size: Optional[int] = ...) -> List[Any]: ...
def fetchone(self) -> Any: ...
def setinputsizes(self, *args: Any, **kwargs: Any) -> None: ...
def setoutputsize(self, *args: Any, **kwargs: Any) -> None: ...
def __iter__(self) -> Cursor: ...
if sys.version_info >= (3, 0):
def __next__(self) -> Any: ...
else:
def next(self) -> Any: ...
class DataError(DatabaseError): ...
class DatabaseError(Error): ...
class Error(Exception): ...
class IntegrityError(DatabaseError): ...
class InterfaceError(Error): ...
class InternalError(DatabaseError): ...
class NotSupportedError(DatabaseError): ...
class OperationalError(DatabaseError): ...
if sys.version_info >= (3,):
OptimizedUnicode = str
else:
class OptimizedUnicode(object):
maketrans: Any
def __init__(self, *args, **kwargs): ...
def capitalize(self, *args, **kwargs): ...
def casefold(self, *args, **kwargs): ...
def center(self, *args, **kwargs): ...
def count(self, *args, **kwargs): ...
def encode(self, *args, **kwargs): ...
def endswith(self, *args, **kwargs): ...
def expandtabs(self, *args, **kwargs): ...
def find(self, *args, **kwargs): ...
def format(self, *args, **kwargs): ...
def format_map(self, *args, **kwargs): ...
def index(self, *args, **kwargs): ...
def isalnum(self, *args, **kwargs): ...
def isalpha(self, *args, **kwargs): ...
def isdecimal(self, *args, **kwargs): ...
def isdigit(self, *args, **kwargs): ...
def isidentifier(self, *args, **kwargs): ...
def islower(self, *args, **kwargs): ...
def isnumeric(self, *args, **kwargs): ...
def isprintable(self, *args, **kwargs): ...
def isspace(self, *args, **kwargs): ...
def istitle(self, *args, **kwargs): ...
def isupper(self, *args, **kwargs): ...
def join(self, *args, **kwargs): ...
def ljust(self, *args, **kwargs): ...
def lower(self, *args, **kwargs): ...
def lstrip(self, *args, **kwargs): ...
def partition(self, *args, **kwargs): ...
def replace(self, *args, **kwargs): ...
def rfind(self, *args, **kwargs): ...
def rindex(self, *args, **kwargs): ...
def rjust(self, *args, **kwargs): ...
def rpartition(self, *args, **kwargs): ...
def rsplit(self, *args, **kwargs): ...
def rstrip(self, *args, **kwargs): ...
def split(self, *args, **kwargs): ...
def splitlines(self, *args, **kwargs): ...
def startswith(self, *args, **kwargs): ...
def strip(self, *args, **kwargs): ...
def swapcase(self, *args, **kwargs): ...
def title(self, *args, **kwargs): ...
def translate(self, *args, **kwargs): ...
def upper(self, *args, **kwargs): ...
def zfill(self, *args, **kwargs): ...
def __add__(self, other): ...
def __contains__(self, *args, **kwargs): ...
def __eq__(self, other): ...
def __format__(self, *args, **kwargs): ...
def __ge__(self, other): ...
def __getitem__(self, index): ...
def __getnewargs__(self, *args, **kwargs): ...
def __gt__(self, other): ...
def __hash__(self): ...
def __iter__(self): ...
def __le__(self, other): ...
def __len__(self, *args, **kwargs): ...
def __lt__(self, other): ...
def __mod__(self, other): ...
def __mul__(self, other): ...
def __ne__(self, other): ...
def __rmod__(self, other): ...
def __rmul__(self, other): ...
class PrepareProtocol(object):
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
class ProgrammingError(DatabaseError): ...
class Row(object):
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
def keys(self, *args: Any, **kwargs: Any): ...
def __eq__(self, other): ...
def __ge__(self, other): ...
def __getitem__(self, index): ...
def __gt__(self, other): ...
def __hash__(self): ...
def __iter__(self): ...
def __le__(self, other): ...
def __len__(self, *args: Any, **kwargs: Any): ...
def __lt__(self, other): ...
def __ne__(self, other): ...
if sys.version_info < (3, 8):
class Statement(object):
def __init__(self, *args, **kwargs): ...
class Warning(Exception): ...
| 11,315 | Python | .py | 279 | 35.107527 | 132 | 0.598638 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,229 | textpad.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/curses/textpad.pyi | from _curses import _CursesWindow
from typing import Callable, Optional, Union
def rectangle(win: _CursesWindow, uly: int, ulx: int, lry: int, lrx: int) -> None: ...
class Textbox:
stripspaces: bool
def __init__(self, win: _CursesWindow, insert_mode: bool = ...) -> None: ...
def edit(self, validate: Optional[Callable[[int], int]] = ...) -> str: ...
def do_command(self, ch: Union[str, int]) -> None: ...
def gather(self) -> str: ...
| 457 | Python | .py | 9 | 47.333333 | 86 | 0.636771 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,230 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/curses/__init__.pyi | from _curses import * # noqa: F403
from _curses import _CursesWindow as _CursesWindow
from typing import Any, Callable, TypeVar
_T = TypeVar("_T")
# available after calling `curses.initscr()`
LINES: int
COLS: int
# available after calling `curses.start_color()`
COLORS: int
COLOR_PAIRS: int
def wrapper(__func: Callable[..., _T], *arg: Any, **kwds: Any) -> _T: ...
| 370 | Python | .py | 11 | 32.272727 | 73 | 0.715493 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,231 | ascii.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/curses/ascii.pyi | from typing import List, TypeVar, Union
_Ch = TypeVar("_Ch", str, int)
NUL: int
SOH: int
STX: int
ETX: int
EOT: int
ENQ: int
ACK: int
BEL: int
BS: int
TAB: int
HT: int
LF: int
NL: int
VT: int
FF: int
CR: int
SO: int
SI: int
DLE: int
DC1: int
DC2: int
DC3: int
DC4: int
NAK: int
SYN: int
ETB: int
CAN: int
EM: int
SUB: int
ESC: int
FS: int
GS: int
RS: int
US: int
SP: int
DEL: int
controlnames: List[int]
def isalnum(c: Union[str, int]) -> bool: ...
def isalpha(c: Union[str, int]) -> bool: ...
def isascii(c: Union[str, int]) -> bool: ...
def isblank(c: Union[str, int]) -> bool: ...
def iscntrl(c: Union[str, int]) -> bool: ...
def isdigit(c: Union[str, int]) -> bool: ...
def isgraph(c: Union[str, int]) -> bool: ...
def islower(c: Union[str, int]) -> bool: ...
def isprint(c: Union[str, int]) -> bool: ...
def ispunct(c: Union[str, int]) -> bool: ...
def isspace(c: Union[str, int]) -> bool: ...
def isupper(c: Union[str, int]) -> bool: ...
def isxdigit(c: Union[str, int]) -> bool: ...
def isctrl(c: Union[str, int]) -> bool: ...
def ismeta(c: Union[str, int]) -> bool: ...
def ascii(c: _Ch) -> _Ch: ...
def ctrl(c: _Ch) -> _Ch: ...
def alt(c: _Ch) -> _Ch: ...
def unctrl(c: Union[str, int]) -> str: ...
| 1,212 | Python | .py | 58 | 19.827586 | 45 | 0.624348 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,232 | panel.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/curses/panel.pyi | from _curses import _CursesWindow
class _Curses_Panel: # type is <class '_curses_panel.curses panel'> (note the space in the class name)
def above(self) -> _Curses_Panel: ...
def below(self) -> _Curses_Panel: ...
def bottom(self) -> None: ...
def hidden(self) -> bool: ...
def hide(self) -> None: ...
def move(self, y: int, x: int) -> None: ...
def replace(self, win: _CursesWindow) -> None: ...
def set_userptr(self, obj: object) -> None: ...
def show(self) -> None: ...
def top(self) -> None: ...
def userptr(self) -> object: ...
def window(self) -> _CursesWindow: ...
def bottom_panel() -> _Curses_Panel: ...
def new_panel(__win: _CursesWindow) -> _Curses_Panel: ...
def top_panel() -> _Curses_Panel: ...
def update_panels() -> _Curses_Panel: ...
| 801 | Python | .py | 18 | 40.722222 | 103 | 0.599232 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,233 | dataclasses.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3.7/dataclasses.pyi | import sys
from typing import Any, Callable, Dict, Generic, Iterable, List, Mapping, Optional, Tuple, Type, TypeVar, Union, overload
if sys.version_info >= (3, 9):
from types import GenericAlias
_T = TypeVar("_T")
class _MISSING_TYPE: ...
MISSING: _MISSING_TYPE
@overload
def asdict(obj: Any) -> Dict[str, Any]: ...
@overload
def asdict(obj: Any, *, dict_factory: Callable[[List[Tuple[str, Any]]], _T]) -> _T: ...
@overload
def astuple(obj: Any) -> Tuple[Any, ...]: ...
@overload
def astuple(obj: Any, *, tuple_factory: Callable[[List[Any]], _T]) -> _T: ...
@overload
def dataclass(_cls: Type[_T]) -> Type[_T]: ...
@overload
def dataclass(_cls: None) -> Callable[[Type[_T]], Type[_T]]: ...
@overload
def dataclass(
*, init: bool = ..., repr: bool = ..., eq: bool = ..., order: bool = ..., unsafe_hash: bool = ..., frozen: bool = ...
) -> Callable[[Type[_T]], Type[_T]]: ...
class Field(Generic[_T]):
name: str
type: Type[_T]
default: _T
default_factory: Callable[[], _T]
repr: bool
hash: Optional[bool]
init: bool
compare: bool
metadata: Mapping[str, Any]
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
# NOTE: Actual return type is 'Field[_T]', but we want to help type checkers
# to understand the magic that happens at runtime.
@overload # `default` and `default_factory` are optional and mutually exclusive.
def field(
*,
default: _T,
init: bool = ...,
repr: bool = ...,
hash: Optional[bool] = ...,
compare: bool = ...,
metadata: Optional[Mapping[str, Any]] = ...,
) -> _T: ...
@overload
def field(
*,
default_factory: Callable[[], _T],
init: bool = ...,
repr: bool = ...,
hash: Optional[bool] = ...,
compare: bool = ...,
metadata: Optional[Mapping[str, Any]] = ...,
) -> _T: ...
@overload
def field(
*,
init: bool = ...,
repr: bool = ...,
hash: Optional[bool] = ...,
compare: bool = ...,
metadata: Optional[Mapping[str, Any]] = ...,
) -> Any: ...
def fields(class_or_instance: Any) -> Tuple[Field[Any], ...]: ...
def is_dataclass(obj: Any) -> bool: ...
class FrozenInstanceError(AttributeError): ...
class InitVar(Generic[_T]):
if sys.version_info >= (3, 9):
def __class_getitem__(cls, type: Any) -> GenericAlias: ...
def make_dataclass(
cls_name: str,
fields: Iterable[Union[str, Tuple[str, type], Tuple[str, type, Field[Any]]]],
*,
bases: Tuple[type, ...] = ...,
namespace: Optional[Dict[str, Any]] = ...,
init: bool = ...,
repr: bool = ...,
eq: bool = ...,
order: bool = ...,
unsafe_hash: bool = ...,
frozen: bool = ...,
) -> type: ...
def replace(obj: _T, **changes: Any) -> _T: ...
| 2,737 | Python | .py | 86 | 28.488372 | 121 | 0.588569 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,234 | _py_abc.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3.7/_py_abc.pyi | from typing import Any, Dict, Tuple, Type, TypeVar
_T = TypeVar("_T")
# TODO: Change the return into a NewType bound to int after pytype/#597
def get_cache_token() -> object: ...
class ABCMeta(type):
def __new__(__mcls, __name: str, __bases: Tuple[Type[Any], ...], __namespace: Dict[str, Any]) -> ABCMeta: ...
def register(cls, subclass: Type[_T]) -> Type[_T]: ...
| 376 | Python | .py | 7 | 51.142857 | 113 | 0.636612 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,235 | contextvars.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3.7/contextvars.pyi | import sys
from typing import Any, Callable, ClassVar, Generic, Iterator, Mapping, TypeVar, Union, overload
if sys.version_info >= (3, 9):
from types import GenericAlias
_T = TypeVar("_T")
_D = TypeVar("_D")
class ContextVar(Generic[_T]):
def __init__(self, name: str, *, default: _T = ...) -> None: ...
@property
def name(self) -> str: ...
@overload
def get(self) -> _T: ...
@overload
def get(self, default: Union[_D, _T]) -> Union[_D, _T]: ...
def set(self, value: _T) -> Token[_T]: ...
def reset(self, token: Token[_T]) -> None: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class Token(Generic[_T]):
@property
def var(self) -> ContextVar[_T]: ...
@property
def old_value(self) -> Any: ... # returns either _T or MISSING, but that's hard to express
MISSING: ClassVar[object]
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
def copy_context() -> Context: ...
# It doesn't make sense to make this generic, because for most Contexts each ContextVar will have
# a different value.
class Context(Mapping[ContextVar[Any], Any]):
def __init__(self) -> None: ...
def run(self, callable: Callable[..., _T], *args: Any, **kwargs: Any) -> _T: ...
def copy(self) -> Context: ...
def __getitem__(self, key: ContextVar[Any]) -> Any: ...
def __iter__(self) -> Iterator[ContextVar[Any]]: ...
def __len__(self) -> int: ...
| 1,514 | Python | .py | 36 | 37.888889 | 97 | 0.599864 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,236 | _pydecimal.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_pydecimal.pyi | # This is a slight lie, the implementations aren't exactly identical
# However, in all likelihood, the differences are inconsequential
from decimal import *
| 157 | Python | .py | 3 | 51.333333 | 68 | 0.818182 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,237 | types.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/types.pyi | import sys
from typing import (
Any,
Awaitable,
Callable,
Dict,
Generic,
Iterable,
Iterator,
Mapping,
Optional,
Tuple,
Type,
TypeVar,
Union,
overload,
)
from typing_extensions import Literal, final
# ModuleType is exported from this module, but for circular import
# reasons exists in its own stub file (with ModuleSpec and Loader).
from _importlib_modulespec import ModuleType as ModuleType # Exported
# Note, all classes "defined" here require special handling.
_T = TypeVar("_T")
_T_co = TypeVar("_T_co", covariant=True)
_T_contra = TypeVar("_T_contra", contravariant=True)
_KT = TypeVar("_KT")
_VT = TypeVar("_VT")
class _Cell:
cell_contents: Any
class FunctionType:
__closure__: Optional[Tuple[_Cell, ...]]
__code__: CodeType
__defaults__: Optional[Tuple[Any, ...]]
__dict__: Dict[str, Any]
__globals__: Dict[str, Any]
__name__: str
__qualname__: str
__annotations__: Dict[str, Any]
__kwdefaults__: Dict[str, Any]
def __init__(
self,
code: CodeType,
globals: Dict[str, Any],
name: Optional[str] = ...,
argdefs: Optional[Tuple[object, ...]] = ...,
closure: Optional[Tuple[_Cell, ...]] = ...,
) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
def __get__(self, obj: Optional[object], type: Optional[type]) -> MethodType: ...
LambdaType = FunctionType
class CodeType:
"""Create a code object. Not for the faint of heart."""
co_argcount: int
if sys.version_info >= (3, 8):
co_posonlyargcount: int
co_kwonlyargcount: int
co_nlocals: int
co_stacksize: int
co_flags: int
co_code: bytes
co_consts: Tuple[Any, ...]
co_names: Tuple[str, ...]
co_varnames: Tuple[str, ...]
co_filename: str
co_name: str
co_firstlineno: int
co_lnotab: bytes
co_freevars: Tuple[str, ...]
co_cellvars: Tuple[str, ...]
if sys.version_info >= (3, 8):
def __init__(
self,
argcount: int,
posonlyargcount: int,
kwonlyargcount: int,
nlocals: int,
stacksize: int,
flags: int,
codestring: bytes,
constants: Tuple[Any, ...],
names: Tuple[str, ...],
varnames: Tuple[str, ...],
filename: str,
name: str,
firstlineno: int,
lnotab: bytes,
freevars: Tuple[str, ...] = ...,
cellvars: Tuple[str, ...] = ...,
) -> None: ...
else:
def __init__(
self,
argcount: int,
kwonlyargcount: int,
nlocals: int,
stacksize: int,
flags: int,
codestring: bytes,
constants: Tuple[Any, ...],
names: Tuple[str, ...],
varnames: Tuple[str, ...],
filename: str,
name: str,
firstlineno: int,
lnotab: bytes,
freevars: Tuple[str, ...] = ...,
cellvars: Tuple[str, ...] = ...,
) -> None: ...
if sys.version_info >= (3, 8):
def replace(
self,
*,
co_argcount: int = ...,
co_posonlyargcount: int = ...,
co_kwonlyargcount: int = ...,
co_nlocals: int = ...,
co_stacksize: int = ...,
co_flags: int = ...,
co_firstlineno: int = ...,
co_code: bytes = ...,
co_consts: Tuple[Any, ...] = ...,
co_names: Tuple[str, ...] = ...,
co_varnames: Tuple[str, ...] = ...,
co_freevars: Tuple[str, ...] = ...,
co_cellvars: Tuple[str, ...] = ...,
co_filename: str = ...,
co_name: str = ...,
co_lnotab: bytes = ...,
) -> CodeType: ...
class MappingProxyType(Mapping[_KT, _VT], Generic[_KT, _VT]):
def __init__(self, mapping: Mapping[_KT, _VT]) -> None: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __iter__(self) -> Iterator[_KT]: ...
def __len__(self) -> int: ...
def copy(self) -> Dict[_KT, _VT]: ...
class SimpleNamespace:
def __init__(self, **kwargs: Any) -> None: ...
def __getattribute__(self, name: str) -> Any: ...
def __setattr__(self, name: str, value: Any) -> None: ...
def __delattr__(self, name: str) -> None: ...
class GeneratorType:
gi_code: CodeType
gi_frame: FrameType
gi_running: bool
gi_yieldfrom: Optional[GeneratorType]
def __iter__(self) -> GeneratorType: ...
def __next__(self) -> Any: ...
def close(self) -> None: ...
def send(self, __arg: Any) -> Any: ...
@overload
def throw(
self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ...
) -> Any: ...
@overload
def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> Any: ...
class AsyncGeneratorType(Generic[_T_co, _T_contra]):
ag_await: Optional[Awaitable[Any]]
ag_frame: FrameType
ag_running: bool
ag_code: CodeType
def __aiter__(self) -> Awaitable[AsyncGeneratorType[_T_co, _T_contra]]: ...
def __anext__(self) -> Awaitable[_T_co]: ...
def asend(self, __val: _T_contra) -> Awaitable[_T_co]: ...
@overload
def athrow(
self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ...
) -> Awaitable[_T_co]: ...
@overload
def athrow(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> Awaitable[_T_co]: ...
def aclose(self) -> Awaitable[None]: ...
class CoroutineType:
cr_await: Optional[Any]
cr_code: CodeType
cr_frame: FrameType
cr_running: bool
def close(self) -> None: ...
def send(self, __arg: Any) -> Any: ...
@overload
def throw(
self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ...
) -> Any: ...
@overload
def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> Any: ...
class _StaticFunctionType:
"""Fictional type to correct the type of MethodType.__func__.
FunctionType is a descriptor, so mypy follows the descriptor protocol and
converts MethodType.__func__ back to MethodType (the return type of
FunctionType.__get__). But this is actually a special case; MethodType is
implemented in C and its attribute access doesn't go through
__getattribute__.
By wrapping FunctionType in _StaticFunctionType, we get the right result;
similar to wrapping a function in staticmethod() at runtime to prevent it
being bound as a method.
"""
def __get__(self, obj: Optional[object], type: Optional[type]) -> FunctionType: ...
class MethodType:
__func__: _StaticFunctionType
__self__: object
__name__: str
__qualname__: str
def __init__(self, func: Callable[..., Any], obj: object) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
class BuiltinFunctionType:
__self__: Union[object, ModuleType]
__name__: str
__qualname__: str
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
BuiltinMethodType = BuiltinFunctionType
if sys.version_info >= (3, 7):
class WrapperDescriptorType:
__name__: str
__qualname__: str
__objclass__: type
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
def __get__(self, obj: Any, type: type = ...) -> Any: ...
class MethodWrapperType:
__self__: object
__name__: str
__qualname__: str
__objclass__: type
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
def __eq__(self, other: Any) -> bool: ...
def __ne__(self, other: Any) -> bool: ...
class MethodDescriptorType:
__name__: str
__qualname__: str
__objclass__: type
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
def __get__(self, obj: Any, type: type = ...) -> Any: ...
class ClassMethodDescriptorType:
__name__: str
__qualname__: str
__objclass__: type
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
def __get__(self, obj: Any, type: type = ...) -> Any: ...
class TracebackType:
if sys.version_info >= (3, 7):
def __init__(self, tb_next: Optional[TracebackType], tb_frame: FrameType, tb_lasti: int, tb_lineno: int) -> None: ...
tb_next: Optional[TracebackType]
else:
@property
def tb_next(self) -> Optional[TracebackType]: ...
# the rest are read-only even in 3.7
@property
def tb_frame(self) -> FrameType: ...
@property
def tb_lasti(self) -> int: ...
@property
def tb_lineno(self) -> int: ...
class FrameType:
f_back: Optional[FrameType]
f_builtins: Dict[str, Any]
f_code: CodeType
f_globals: Dict[str, Any]
f_lasti: int
f_lineno: int
f_locals: Dict[str, Any]
f_trace: Optional[Callable[[FrameType, str, Any], Any]]
if sys.version_info >= (3, 7):
f_trace_lines: bool
f_trace_opcodes: bool
def clear(self) -> None: ...
class GetSetDescriptorType:
__name__: str
__objclass__: type
def __get__(self, obj: Any, type: type = ...) -> Any: ...
def __set__(self, obj: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
class MemberDescriptorType:
__name__: str
__objclass__: type
def __get__(self, obj: Any, type: type = ...) -> Any: ...
def __set__(self, obj: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
if sys.version_info >= (3, 7):
def new_class(
name: str, bases: Iterable[object] = ..., kwds: Dict[str, Any] = ..., exec_body: Callable[[Dict[str, Any]], None] = ...
) -> type: ...
def resolve_bases(bases: Iterable[object]) -> Tuple[Any, ...]: ...
else:
def new_class(
name: str, bases: Tuple[type, ...] = ..., kwds: Dict[str, Any] = ..., exec_body: Callable[[Dict[str, Any]], None] = ...
) -> type: ...
def prepare_class(
name: str, bases: Tuple[type, ...] = ..., kwds: Dict[str, Any] = ...
) -> Tuple[type, Dict[str, Any], Dict[str, Any]]: ...
# Actually a different type, but `property` is special and we want that too.
DynamicClassAttribute = property
def coroutine(f: Callable[..., Any]) -> CoroutineType: ...
if sys.version_info >= (3, 9):
class GenericAlias:
__origin__: type
__args__: Tuple[Any, ...]
__parameters__: Tuple[Any, ...]
def __init__(self, origin: type, args: Any) -> None: ...
def __getattr__(self, name: str) -> Any: ... # incomplete
if sys.version_info >= (3, 10):
@final
class NoneType:
def __bool__(self) -> Literal[False]: ...
EllipsisType = ellipsis # noqa F811 from builtins
NotImplementedType = _NotImplementedType # noqa F811 from builtins
| 11,027 | Python | .py | 302 | 29.897351 | 127 | 0.556532 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,238 | pathlib.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/pathlib.pyi | import os
import sys
from _typeshed import OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, OpenBinaryModeWriting, OpenTextMode
from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
from types import TracebackType
from typing import IO, Any, BinaryIO, Generator, List, Optional, Sequence, Tuple, Type, TypeVar, Union, overload
from typing_extensions import Literal
if sys.version_info >= (3, 9):
from types import GenericAlias
_P = TypeVar("_P", bound=PurePath)
if sys.version_info >= (3, 6):
_PurePathBase = os.PathLike[str]
_PathLike = os.PathLike[str]
else:
_PurePathBase = object
_PathLike = PurePath
class PurePath(_PurePathBase):
parts: Tuple[str, ...]
drive: str
root: str
anchor: str
name: str
suffix: str
suffixes: List[str]
stem: str
def __new__(cls: Type[_P], *args: Union[str, _PathLike]) -> _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: ...
def __truediv__(self: _P, key: Union[str, _PathLike]) -> _P: ...
def __rtruediv__(self: _P, key: Union[str, _PathLike]) -> _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: ...
if sys.version_info >= (3, 9):
def is_relative_to(self, *other: Union[str, os.PathLike[str]]) -> bool: ...
def match(self, path_pattern: str) -> bool: ...
def relative_to(self: _P, *other: Union[str, _PathLike]) -> _P: ...
def with_name(self: _P, name: str) -> _P: ...
if sys.version_info >= (3, 9):
def with_stem(self: _P, stem: str) -> _P: ...
def with_suffix(self: _P, suffix: str) -> _P: ...
def joinpath(self: _P, *other: Union[str, _PathLike]) -> _P: ...
@property
def parents(self: _P) -> Sequence[_P]: ...
@property
def parent(self: _P) -> _P: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, type: Any) -> GenericAlias: ...
class PurePosixPath(PurePath): ...
class PureWindowsPath(PurePath): ...
class Path(PurePath):
def __new__(cls: Type[_P], *args: Union[str, _PathLike], **kwargs: Any) -> _P: ...
def __enter__(self: _P) -> _P: ...
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: _P, pattern: str) -> Generator[_P, 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: _P) -> Generator[_P, None, None]: ...
def lchmod(self, mode: int) -> None: ...
def lstat(self) -> os.stat_result: ...
def mkdir(self, mode: int = ..., parents: bool = ..., exist_ok: bool = ...) -> None: ...
# Adapted from builtins.open
# Text mode: always returns a TextIOWrapper
@overload
def open(
self,
mode: OpenTextMode = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
newline: Optional[str] = ...,
) -> TextIOWrapper: ...
# Unbuffered binary mode: returns a FileIO
@overload
def open(
self, mode: OpenBinaryMode, buffering: Literal[0], encoding: None = ..., errors: None = ..., newline: None = ...
) -> FileIO: ...
# Buffering is on: return BufferedRandom, BufferedReader, or BufferedWriter
@overload
def open(
self,
mode: OpenBinaryModeUpdating,
buffering: Literal[-1, 1] = ...,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
) -> BufferedRandom: ...
@overload
def open(
self,
mode: OpenBinaryModeWriting,
buffering: Literal[-1, 1] = ...,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
) -> BufferedWriter: ...
@overload
def open(
self,
mode: OpenBinaryModeReading,
buffering: Literal[-1, 1] = ...,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
) -> BufferedReader: ...
# Buffering cannot be determined: fall back to BinaryIO
@overload
def open(
self, mode: OpenBinaryMode, buffering: int, encoding: None = ..., errors: None = ..., newline: None = ...
) -> BinaryIO: ...
# Fallback if mode is not specified
@overload
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, 9):
def readlink(self: _P) -> _P: ...
if sys.version_info >= (3, 8):
def rename(self: _P, target: Union[str, PurePath]) -> _P: ...
def replace(self: _P, target: Union[str, PurePath]) -> _P: ...
else:
def rename(self, target: Union[str, PurePath]) -> None: ...
def replace(self, target: Union[str, PurePath]) -> None: ...
def resolve(self: _P, strict: bool = ...) -> _P: ...
def rglob(self: _P, pattern: str) -> Generator[_P, 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: ...
@classmethod
def home(cls: Type[_P]) -> _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): ...
| 6,899 | Python | .py | 171 | 34.649123 | 125 | 0.569112 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,239 | ipaddress.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/ipaddress.pyi | import sys
from typing import Any, Container, Generic, Iterable, Iterator, Optional, SupportsInt, Tuple, TypeVar, overload
# Undocumented length constants
IPV4LENGTH: int
IPV6LENGTH: int
_A = TypeVar("_A", IPv4Address, IPv6Address)
_N = TypeVar("_N", IPv4Network, IPv6Network)
_T = TypeVar("_T")
def ip_address(address: object) -> Any: ... # morally Union[IPv4Address, IPv6Address]
def ip_network(address: object, strict: bool = ...) -> Any: ... # morally Union[IPv4Network, IPv6Network]
def ip_interface(address: object) -> Any: ... # morally Union[IPv4Interface, IPv6Interface]
class _IPAddressBase:
def __eq__(self, other: Any) -> bool: ...
def __ge__(self: _T, other: _T) -> bool: ...
def __gt__(self: _T, other: _T) -> bool: ...
def __le__(self: _T, other: _T) -> bool: ...
def __lt__(self: _T, other: _T) -> bool: ...
def __ne__(self, other: Any) -> bool: ...
@property
def compressed(self) -> str: ...
@property
def exploded(self) -> str: ...
@property
def reverse_pointer(self) -> str: ...
@property
def version(self) -> int: ...
class _BaseAddress(_IPAddressBase, SupportsInt):
def __init__(self, address: object) -> None: ...
def __add__(self: _T, other: int) -> _T: ...
def __hash__(self) -> int: ...
def __int__(self) -> int: ...
def __sub__(self: _T, other: int) -> _T: ...
@property
def is_global(self) -> bool: ...
@property
def is_link_local(self) -> bool: ...
@property
def is_loopback(self) -> bool: ...
@property
def is_multicast(self) -> bool: ...
@property
def is_private(self) -> bool: ...
@property
def is_reserved(self) -> bool: ...
@property
def is_unspecified(self) -> bool: ...
@property
def max_prefixlen(self) -> int: ...
@property
def packed(self) -> bytes: ...
class _BaseNetwork(_IPAddressBase, Container[_A], Iterable[_A], Generic[_A]):
network_address: _A
netmask: _A
def __init__(self, address: object, strict: bool = ...) -> None: ...
def __contains__(self, other: Any) -> bool: ...
def __getitem__(self, n: int) -> _A: ...
def __iter__(self) -> Iterator[_A]: ...
def address_exclude(self: _T, other: _T) -> Iterator[_T]: ...
@property
def broadcast_address(self) -> _A: ...
def compare_networks(self: _T, other: _T) -> int: ...
def hosts(self) -> Iterator[_A]: ...
@property
def is_global(self) -> bool: ...
@property
def is_link_local(self) -> bool: ...
@property
def is_loopback(self) -> bool: ...
@property
def is_multicast(self) -> bool: ...
@property
def is_private(self) -> bool: ...
@property
def is_reserved(self) -> bool: ...
@property
def is_unspecified(self) -> bool: ...
@property
def max_prefixlen(self) -> int: ...
@property
def num_addresses(self) -> int: ...
def overlaps(self, other: _BaseNetwork[_A]) -> bool: ...
@property
def prefixlen(self) -> int: ...
if sys.version_info >= (3, 7):
def subnet_of(self: _T, other: _T) -> bool: ...
def supernet_of(self: _T, other: _T) -> bool: ...
def subnets(self: _T, prefixlen_diff: int = ..., new_prefix: Optional[int] = ...) -> Iterator[_T]: ...
def supernet(self: _T, prefixlen_diff: int = ..., new_prefix: Optional[int] = ...) -> _T: ...
@property
def with_hostmask(self) -> str: ...
@property
def with_netmask(self) -> str: ...
@property
def with_prefixlen(self) -> str: ...
@property
def hostmask(self) -> _A: ...
class _BaseInterface(_BaseAddress, Generic[_A, _N]):
hostmask: _A
netmask: _A
network: _N
@property
def ip(self) -> _A: ...
@property
def with_hostmask(self) -> str: ...
@property
def with_netmask(self) -> str: ...
@property
def with_prefixlen(self) -> str: ...
class IPv4Address(_BaseAddress): ...
class IPv4Network(_BaseNetwork[IPv4Address]): ...
class IPv4Interface(IPv4Address, _BaseInterface[IPv4Address, IPv4Network]): ...
class IPv6Address(_BaseAddress):
@property
def ipv4_mapped(self) -> Optional[IPv4Address]: ...
@property
def is_site_local(self) -> bool: ...
@property
def sixtofour(self) -> Optional[IPv4Address]: ...
@property
def teredo(self) -> Optional[Tuple[IPv4Address, IPv4Address]]: ...
class IPv6Network(_BaseNetwork[IPv6Address]):
@property
def is_site_local(self) -> bool: ...
class IPv6Interface(IPv6Address, _BaseInterface[IPv6Address, IPv6Network]): ...
def v4_int_to_packed(address: int) -> bytes: ...
def v6_int_to_packed(address: int) -> bytes: ...
@overload
def summarize_address_range(first: IPv4Address, last: IPv4Address) -> Iterator[IPv4Network]: ...
@overload
def summarize_address_range(first: IPv6Address, last: IPv6Address) -> Iterator[IPv6Network]: ...
def collapse_addresses(addresses: Iterable[_N]) -> Iterator[_N]: ...
@overload
def get_mixed_type_key(obj: _A) -> Tuple[int, _A]: ...
@overload
def get_mixed_type_key(obj: IPv4Network) -> Tuple[int, IPv4Address, IPv4Address]: ...
@overload
def get_mixed_type_key(obj: IPv6Network) -> Tuple[int, IPv6Address, IPv6Address]: ...
class AddressValueError(ValueError): ...
class NetmaskValueError(ValueError): ...
| 5,252 | Python | .py | 139 | 33.669065 | 111 | 0.618039 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,240 | fcntl.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/fcntl.pyi | import sys
from _typeshed import FileDescriptorLike
from array import array
from typing import Any, Union, overload
from typing_extensions import Literal
FASYNC: int
FD_CLOEXEC: int
DN_ACCESS: int
DN_ATTRIB: int
DN_CREATE: int
DN_DELETE: int
DN_MODIFY: int
DN_MULTISHOT: int
DN_RENAME: int
F_DUPFD: int
F_DUPFD_CLOEXEC: int
F_FULLFSYNC: int
F_EXLCK: int
F_GETFD: int
F_GETFL: int
F_GETLEASE: int
F_GETLK: int
F_GETLK64: int
F_GETOWN: int
F_NOCACHE: int
F_GETSIG: int
F_NOTIFY: int
F_RDLCK: int
F_SETFD: int
F_SETFL: int
F_SETLEASE: int
F_SETLK: int
F_SETLK64: int
F_SETLKW: int
F_SETLKW64: int
if sys.version_info >= (3, 9) and sys.platform == "linux":
F_OFD_GETLK: int
F_OFD_SETLK: int
F_OFD_SETLKW: int
F_SETOWN: int
F_SETSIG: int
F_SHLCK: int
F_UNLCK: int
F_WRLCK: int
I_ATMARK: int
I_CANPUT: int
I_CKBAND: int
I_FDINSERT: int
I_FIND: int
I_FLUSH: int
I_FLUSHBAND: int
I_GETBAND: int
I_GETCLTIME: int
I_GETSIG: int
I_GRDOPT: int
I_GWROPT: int
I_LINK: int
I_LIST: int
I_LOOK: int
I_NREAD: int
I_PEEK: int
I_PLINK: int
I_POP: int
I_PUNLINK: int
I_PUSH: int
I_RECVFD: int
I_SENDFD: int
I_SETCLTIME: int
I_SETSIG: int
I_SRDOPT: int
I_STR: int
I_SWROPT: int
I_UNLINK: int
LOCK_EX: int
LOCK_MAND: int
LOCK_NB: int
LOCK_READ: int
LOCK_RW: int
LOCK_SH: int
LOCK_UN: int
LOCK_WRITE: int
@overload
def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: int = ...) -> int: ...
@overload
def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: bytes) -> bytes: ...
_ReadOnlyBuffer = bytes
_WritableBuffer = Union[bytearray, memoryview, array]
@overload
def ioctl(__fd: FileDescriptorLike, __request: int, __arg: int = ..., __mutate_flag: bool = ...) -> int: ...
@overload
def ioctl(__fd: FileDescriptorLike, __request: int, __arg: _WritableBuffer, __mutate_flag: Literal[True] = ...) -> int: ...
@overload
def ioctl(__fd: FileDescriptorLike, __request: int, __arg: _WritableBuffer, __mutate_flag: Literal[False]) -> bytes: ...
@overload
def ioctl(__fd: FileDescriptorLike, __request: int, __arg: _ReadOnlyBuffer, __mutate_flag: bool = ...) -> bytes: ...
def flock(__fd: FileDescriptorLike, __operation: int) -> None: ...
def lockf(__fd: FileDescriptorLike, __cmd: int, __len: int = ..., __start: int = ..., __whence: int = ...) -> Any: ...
| 2,244 | Python | .py | 97 | 21.989691 | 123 | 0.714219 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,241 | posixpath.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/posixpath.pyi | import os
import sys
from _typeshed import AnyPath, BytesPath, StrPath
from genericpath import exists as exists
from typing import Any, AnyStr, Optional, Sequence, Tuple, TypeVar, overload
_T = TypeVar("_T")
if sys.version_info >= (3, 6):
from builtins import _PathLike
# ----- os.path variables -----
supports_unicode_filenames: bool
# aliases (also in os)
curdir: str
pardir: str
sep: str
if sys.platform == "win32":
altsep: str
else:
altsep: Optional[str]
extsep: str
pathsep: str
defpath: str
devnull: str
# ----- os.path function stubs -----
if sys.version_info >= (3, 6):
# Overloads are necessary to work around python/mypy#3644.
@overload
def abspath(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def abspath(path: AnyStr) -> AnyStr: ...
@overload
def basename(p: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def basename(p: AnyStr) -> AnyStr: ...
@overload
def dirname(p: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def dirname(p: AnyStr) -> AnyStr: ...
@overload
def expanduser(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def expanduser(path: AnyStr) -> AnyStr: ...
@overload
def expandvars(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def expandvars(path: AnyStr) -> AnyStr: ...
@overload
def normcase(s: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def normcase(s: AnyStr) -> AnyStr: ...
@overload
def normpath(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def normpath(path: AnyStr) -> AnyStr: ...
if sys.platform == "win32":
@overload
def realpath(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def realpath(path: AnyStr) -> AnyStr: ...
else:
@overload
def realpath(filename: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def realpath(filename: AnyStr) -> AnyStr: ...
else:
def abspath(path: AnyStr) -> AnyStr: ...
def basename(p: AnyStr) -> AnyStr: ...
def dirname(p: AnyStr) -> AnyStr: ...
def expanduser(path: AnyStr) -> AnyStr: ...
def expandvars(path: AnyStr) -> AnyStr: ...
def normcase(s: AnyStr) -> AnyStr: ...
def normpath(path: AnyStr) -> AnyStr: ...
if sys.platform == "win32":
def realpath(path: AnyStr) -> AnyStr: ...
else:
def realpath(filename: AnyStr) -> AnyStr: ...
if sys.version_info >= (3, 6):
# In reality it returns str for sequences of StrPath and bytes for sequences
# of BytesPath, but mypy does not accept such a signature.
def commonpath(paths: Sequence[AnyPath]) -> Any: ...
elif sys.version_info >= (3, 5):
def commonpath(paths: Sequence[AnyStr]) -> AnyStr: ...
# NOTE: Empty lists results in '' (str) regardless of contained type.
# So, fall back to Any
def commonprefix(m: Sequence[AnyPath]) -> Any: ...
def lexists(path: AnyPath) -> bool: ...
# These return float if os.stat_float_times() == True,
# but int is a subclass of float.
def getatime(filename: AnyPath) -> float: ...
def getmtime(filename: AnyPath) -> float: ...
def getctime(filename: AnyPath) -> float: ...
def getsize(filename: AnyPath) -> int: ...
def isabs(s: AnyPath) -> bool: ...
def isfile(path: AnyPath) -> bool: ...
def isdir(s: AnyPath) -> bool: ...
def islink(path: AnyPath) -> bool: ...
def ismount(path: AnyPath) -> bool: ...
if sys.version_info >= (3, 6):
@overload
def join(a: StrPath, *paths: StrPath) -> str: ...
@overload
def join(a: BytesPath, *paths: BytesPath) -> bytes: ...
else:
def join(a: AnyStr, *paths: AnyStr) -> AnyStr: ...
@overload
def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ...
@overload
def relpath(path: StrPath, start: Optional[StrPath] = ...) -> str: ...
def samefile(f1: AnyPath, f2: AnyPath) -> bool: ...
def sameopenfile(fp1: int, fp2: int) -> bool: ...
def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ...
if sys.version_info >= (3, 6):
@overload
def split(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ...
@overload
def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
@overload
def splitdrive(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ...
@overload
def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
@overload
def splitext(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ...
@overload
def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
else:
def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
if sys.version_info < (3, 7) and sys.platform == "win32":
def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated
| 4,721 | Python | .py | 129 | 32.751938 | 80 | 0.638846 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,242 | _operator.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_operator.pyi | # In reality the import is the other way around, but this way we can keep the operator stub in 2and3
from operator import (
abs as abs,
add as add,
and_ as and_,
attrgetter as attrgetter,
concat as concat,
contains as contains,
countOf as countOf,
delitem as delitem,
eq as eq,
floordiv as floordiv,
ge as ge,
getitem as getitem,
gt as gt,
iadd as iadd,
iand as iand,
iconcat as iconcat,
ifloordiv as ifloordiv,
ilshift as ilshift,
imatmul as imatmul,
imod as imod,
imul as imul,
index as index,
indexOf as indexOf,
inv as inv,
invert as invert,
ior as ior,
ipow as ipow,
irshift as irshift,
is_ as is_,
is_not as is_not,
isub as isub,
itemgetter as itemgetter,
itruediv as itruediv,
ixor as ixor,
le as le,
length_hint as length_hint,
lshift as lshift,
lt as lt,
matmul as matmul,
methodcaller as methodcaller,
mod as mod,
mul as mul,
ne as ne,
neg as neg,
not_ as not_,
or_ as or_,
pos as pos,
pow as pow,
rshift as rshift,
setitem as setitem,
sub as sub,
truediv as truediv,
truth as truth,
xor as xor,
)
from typing import AnyStr
def _compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ...
| 1,310 | Python | .py | 59 | 17.525424 | 100 | 0.6448 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,243 | tracemalloc.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tracemalloc.pyi | import sys
from typing import List, Optional, Sequence, Tuple, Union, overload
from _tracemalloc import *
def get_object_traceback(obj: object) -> Optional[Traceback]: ...
def take_snapshot() -> Snapshot: ...
class DomainFilter:
inclusive: bool
domain: int
def __init__(self, inclusive: bool, domain: int) -> None: ...
class Filter:
domain: Optional[int]
inclusive: bool
lineno: Optional[int]
filename_pattern: str
all_frames: bool
def __init__(
self,
inclusive: bool,
filename_pattern: str,
lineno: Optional[int] = ...,
all_frames: bool = ...,
domain: Optional[int] = ...,
) -> None: ...
class Statistic:
count: int
size: int
traceback: Traceback
def __init__(self, traceback: Traceback, size: int, count: int) -> None: ...
class StatisticDiff:
count: int
count_diff: int
size: int
size_diff: int
traceback: Traceback
def __init__(self, traceback: Traceback, size: int, size_diff: int, count: int, count_diff: int) -> None: ...
_FrameTupleT = Tuple[str, int]
class Frame:
filename: str
lineno: int
def __init__(self, frame: _FrameTupleT) -> None: ...
if sys.version_info >= (3, 9):
_TraceTupleT = Union[Tuple[int, int, Sequence[_FrameTupleT], Optional[int]], Tuple[int, int, Sequence[_FrameTupleT]]]
else:
_TraceTupleT = Tuple[int, int, Sequence[_FrameTupleT]]
class Trace:
domain: int
size: int
traceback: Traceback
def __init__(self, trace: _TraceTupleT) -> None: ...
class Traceback(Sequence[Frame]):
if sys.version_info >= (3, 9):
total_nframe: Optional[int]
def __init__(self, frames: Sequence[_FrameTupleT], total_nframe: Optional[int] = ...) -> None: ...
else:
def __init__(self, frames: Sequence[_FrameTupleT]) -> None: ...
if sys.version_info >= (3, 7):
def format(self, limit: Optional[int] = ..., most_recent_first: bool = ...) -> List[str]: ...
else:
def format(self, limit: Optional[int] = ...) -> List[str]: ...
@overload
def __getitem__(self, i: int) -> Frame: ...
@overload
def __getitem__(self, s: slice) -> Sequence[Frame]: ...
def __len__(self) -> int: ...
class Snapshot:
def __init__(self, traces: Sequence[_TraceTupleT], traceback_limit: int) -> None: ...
def compare_to(self, old_snapshot: Snapshot, key_type: str, cumulative: bool = ...) -> List[StatisticDiff]: ...
def dump(self, filename: str) -> None: ...
def filter_traces(self, filters: Sequence[Union[DomainFilter, Filter]]) -> Snapshot: ...
@staticmethod
def load(filename: str) -> Snapshot: ...
def statistics(self, key_type: str, cumulative: bool = ...) -> List[Statistic]: ...
traceback_limit: int
traces: Sequence[Trace]
| 2,795 | Python | .py | 74 | 32.878378 | 121 | 0.626061 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,244 | getpass.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/getpass.pyi | from typing import Optional, TextIO
def getpass(prompt: str = ..., stream: Optional[TextIO] = ...) -> str: ...
def getuser() -> str: ...
class GetPassWarning(UserWarning): ...
| 178 | Python | .py | 4 | 43 | 74 | 0.668605 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,245 | _stat.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_stat.pyi | SF_APPEND: int
SF_ARCHIVED: int
SF_IMMUTABLE: int
SF_NOUNLINK: int
SF_SNAPSHOT: int
ST_ATIME: int
ST_CTIME: int
ST_DEV: int
ST_GID: int
ST_INO: int
ST_MODE: int
ST_MTIME: int
ST_NLINK: int
ST_SIZE: int
ST_UID: int
S_ENFMT: int
S_IEXEC: int
S_IFBLK: int
S_IFCHR: int
S_IFDIR: int
S_IFDOOR: int
S_IFIFO: int
S_IFLNK: int
S_IFPORT: int
S_IFREG: int
S_IFSOCK: int
S_IFWHT: int
S_IREAD: int
S_IRGRP: int
S_IROTH: int
S_IRUSR: int
S_IRWXG: int
S_IRWXO: int
S_IRWXU: int
S_ISGID: int
S_ISUID: int
S_ISVTX: int
S_IWGRP: int
S_IWOTH: int
S_IWRITE: int
S_IWUSR: int
S_IXGRP: int
S_IXOTH: int
S_IXUSR: int
UF_APPEND: int
UF_COMPRESSED: int
UF_HIDDEN: int
UF_IMMUTABLE: int
UF_NODUMP: int
UF_NOUNLINK: int
UF_OPAQUE: int
def S_IMODE(mode: int) -> int: ...
def S_IFMT(mode: int) -> int: ...
def S_ISBLK(mode: int) -> bool: ...
def S_ISCHR(mode: int) -> bool: ...
def S_ISDIR(mode: int) -> bool: ...
def S_ISDOOR(mode: int) -> bool: ...
def S_ISFIFO(mode: int) -> bool: ...
def S_ISLNK(mode: int) -> bool: ...
def S_ISPORT(mode: int) -> bool: ...
def S_ISREG(mode: int) -> bool: ...
def S_ISSOCK(mode: int) -> bool: ...
def S_ISWHT(mode: int) -> bool: ...
def filemode(mode: int) -> str: ...
| 1,179 | Python | .py | 64 | 17.40625 | 36 | 0.68851 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,246 | posix.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/posix.pyi | import sys
from builtins import _PathLike # See comment in builtins
from os import stat_result as stat_result
from typing import Dict, List, NamedTuple, Optional, overload
class uname_result(NamedTuple):
sysname: str
nodename: str
release: str
version: str
machine: str
class times_result(NamedTuple):
user: float
system: float
children_user: float
children_system: float
elapsed: float
class waitid_result(NamedTuple):
si_pid: int
si_uid: int
si_signo: int
si_status: int
si_code: int
class sched_param(NamedTuple):
sched_priority: int
CLD_CONTINUED: int
CLD_DUMPED: int
CLD_EXITED: int
CLD_TRAPPED: int
EX_CANTCREAT: int
EX_CONFIG: int
EX_DATAERR: int
EX_IOERR: int
EX_NOHOST: int
EX_NOINPUT: int
EX_NOPERM: int
EX_NOTFOUND: int
EX_NOUSER: int
EX_OK: int
EX_OSERR: int
EX_OSFILE: int
EX_PROTOCOL: int
EX_SOFTWARE: int
EX_TEMPFAIL: int
EX_UNAVAILABLE: int
EX_USAGE: int
F_OK: int
R_OK: int
W_OK: int
X_OK: int
F_LOCK: int
F_TEST: int
F_TLOCK: int
F_ULOCK: int
GRND_NONBLOCK: int
GRND_RANDOM: int
NGROUPS_MAX: int
O_APPEND: int
O_ACCMODE: int
O_ASYNC: int
O_CREAT: int
O_DIRECT: int
O_DIRECTORY: int
O_DSYNC: int
O_EXCL: int
O_LARGEFILE: int
O_NDELAY: int
O_NOATIME: int
O_NOCTTY: int
O_NOFOLLOW: int
O_NONBLOCK: int
O_RDONLY: int
O_RDWR: int
O_RSYNC: int
O_SYNC: int
O_TRUNC: int
O_WRONLY: int
POSIX_FADV_DONTNEED: int
POSIX_FADV_NOREUSE: int
POSIX_FADV_NORMAL: int
POSIX_FADV_RANDOM: int
POSIX_FADV_SEQUENTIAL: int
POSIX_FADV_WILLNEED: int
PRIO_PGRP: int
PRIO_PROCESS: int
PRIO_USER: int
P_ALL: int
P_PGID: int
P_PID: int
RTLD_DEEPBIND: int
RTLD_GLOBAL: int
RTLD_LAZY: int
RTLD_LOCAL: int
RTLD_NODELETE: int
RTLD_NOLOAD: int
RTLD_NOW: int
SCHED_BATCH: int
SCHED_FIFO: int
SCHED_IDLE: int
SCHED_OTHER: int
SCHED_RESET_ON_FORK: int
SCHED_RR: int
SEEK_DATA: int
SEEK_HOLE: int
ST_APPEND: int
ST_MANDLOCK: int
ST_NOATIME: int
ST_NODEV: int
ST_NODIRATIME: int
ST_NOEXEC: int
ST_NOSUID: int
ST_RDONLY: int
ST_RELATIME: int
ST_SYNCHRONOUS: int
ST_WRITE: int
TMP_MAX: int
WCONTINUED: int
def WCOREDUMP(__status: int) -> bool: ...
def WEXITSTATUS(status: int) -> int: ...
def WIFCONTINUED(status: int) -> bool: ...
def WIFEXITED(status: int) -> bool: ...
def WIFSIGNALED(status: int) -> bool: ...
def WIFSTOPPED(status: int) -> bool: ...
WNOHANG: int
def WSTOPSIG(status: int) -> int: ...
def WTERMSIG(status: int) -> int: ...
WUNTRACED: int
XATTR_CREATE: int
XATTR_REPLACE: int
XATTR_SIZE_MAX: int
@overload
def listdir(path: Optional[str] = ...) -> List[str]: ...
@overload
def listdir(path: bytes) -> List[bytes]: ...
@overload
def listdir(path: int) -> List[str]: ...
@overload
def listdir(path: _PathLike[str]) -> List[str]: ...
if sys.platform == "win32":
environ: Dict[str, str]
else:
environ: Dict[bytes, bytes]
| 2,810 | Python | .py | 141 | 18.248227 | 61 | 0.74518 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,247 | gzip.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/gzip.pyi | import _compression
import sys
import zlib
from _typeshed import AnyPath, ReadableBuffer
from typing import IO, Optional, TextIO, Union, overload
from typing_extensions import Literal
_OpenBinaryMode = Literal["r", "rb", "a", "ab", "w", "wb", "x", "xb"]
_OpenTextMode = Literal["rt", "at", "wt", "xt"]
@overload
def open(
filename: Union[AnyPath, IO[bytes]],
mode: _OpenBinaryMode = ...,
compresslevel: int = ...,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
) -> GzipFile: ...
@overload
def open(
filename: AnyPath,
mode: _OpenTextMode,
compresslevel: int = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
newline: Optional[str] = ...,
) -> TextIO: ...
@overload
def open(
filename: Union[AnyPath, IO[bytes]],
mode: str,
compresslevel: int = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
newline: Optional[str] = ...,
) -> Union[GzipFile, TextIO]: ...
class _PaddedFile:
file: IO[bytes]
def __init__(self, f: IO[bytes], prepend: bytes = ...) -> None: ...
def read(self, size: int) -> bytes: ...
def prepend(self, prepend: bytes = ...) -> None: ...
def seek(self, off: int) -> int: ...
def seekable(self) -> bool: ...
if sys.version_info >= (3, 8):
class BadGzipFile(OSError): ...
class GzipFile(_compression.BaseStream):
myfileobj: Optional[IO[bytes]]
mode: str
name: str
compress: zlib._Compress
fileobj: IO[bytes]
def __init__(
self,
filename: Optional[AnyPath] = ...,
mode: Optional[str] = ...,
compresslevel: int = ...,
fileobj: Optional[IO[bytes]] = ...,
mtime: Optional[float] = ...,
) -> None: ...
@property
def filename(self) -> str: ...
@property
def mtime(self) -> Optional[int]: ...
crc: int
def write(self, data: ReadableBuffer) -> int: ...
def read(self, size: Optional[int] = ...) -> bytes: ...
def read1(self, size: int = ...) -> bytes: ...
def peek(self, n: int) -> bytes: ...
@property
def closed(self) -> bool: ...
def close(self) -> None: ...
def flush(self, zlib_mode: int = ...) -> None: ...
def fileno(self) -> int: ...
def rewind(self) -> None: ...
def readable(self) -> bool: ...
def writable(self) -> bool: ...
def seekable(self) -> bool: ...
def seek(self, offset: int, whence: int = ...) -> int: ...
def readline(self, size: Optional[int] = ...) -> bytes: ...
class _GzipReader(_compression.DecompressReader):
def __init__(self, fp: IO[bytes]) -> None: ...
def read(self, size: int = ...) -> bytes: ...
if sys.version_info >= (3, 8):
def compress(data: bytes, compresslevel: int = ..., *, mtime: Optional[float] = ...) -> bytes: ...
else:
def compress(data: bytes, compresslevel: int = ...) -> bytes: ...
def decompress(data: bytes) -> bytes: ...
| 2,909 | Python | .py | 86 | 29.569767 | 102 | 0.580107 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,248 | socketserver.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/socketserver.pyi | import sys
import types
from socket import SocketType
from typing import Any, BinaryIO, Callable, ClassVar, List, Optional, Tuple, Type, Union
class BaseServer:
address_family: int
RequestHandlerClass: Callable[..., BaseRequestHandler]
server_address: Tuple[str, int]
socket: SocketType
allow_reuse_address: bool
request_queue_size: int
socket_type: int
timeout: Optional[float]
def __init__(self, server_address: Any, RequestHandlerClass: Callable[..., BaseRequestHandler]) -> None: ...
def fileno(self) -> int: ...
def handle_request(self) -> None: ...
def serve_forever(self, poll_interval: float = ...) -> None: ...
def shutdown(self) -> None: ...
def server_close(self) -> None: ...
def finish_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ...
def get_request(self) -> Tuple[SocketType, Tuple[str, int]]: ...
def handle_error(self, request: bytes, client_address: Tuple[str, int]) -> None: ...
def handle_timeout(self) -> None: ...
def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ...
def server_activate(self) -> None: ...
def server_bind(self) -> None: ...
def verify_request(self, request: bytes, client_address: Tuple[str, int]) -> bool: ...
if sys.version_info >= (3, 6):
def __enter__(self) -> BaseServer: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[types.TracebackType]
) -> None: ...
def service_actions(self) -> None: ...
class TCPServer(BaseServer):
def __init__(
self,
server_address: Tuple[str, int],
RequestHandlerClass: Callable[..., BaseRequestHandler],
bind_and_activate: bool = ...,
) -> None: ...
class UDPServer(BaseServer):
def __init__(
self,
server_address: Tuple[str, int],
RequestHandlerClass: Callable[..., BaseRequestHandler],
bind_and_activate: bool = ...,
) -> None: ...
if sys.platform != "win32":
class UnixStreamServer(BaseServer):
def __init__(
self,
server_address: Union[str, bytes],
RequestHandlerClass: Callable[..., BaseRequestHandler],
bind_and_activate: bool = ...,
) -> None: ...
class UnixDatagramServer(BaseServer):
def __init__(
self,
server_address: Union[str, bytes],
RequestHandlerClass: Callable[..., BaseRequestHandler],
bind_and_activate: bool = ...,
) -> None: ...
if sys.platform != "win32":
class ForkingMixIn:
timeout: Optional[float] # undocumented
active_children: Optional[List[int]] # undocumented
max_children: int # undocumented
if sys.version_info >= (3, 7):
block_on_close: bool
if sys.version_info >= (3, 6):
def collect_children(self, *, blocking: bool = ...) -> None: ... # undocumented
else:
def collect_children(self) -> None: ... # undocumented
def handle_timeout(self) -> None: ... # undocumented
def service_actions(self) -> None: ... # undocumented
def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ...
if sys.version_info >= (3, 6):
def server_close(self) -> None: ...
class ThreadingMixIn:
daemon_threads: bool
if sys.version_info >= (3, 7):
block_on_close: bool
def process_request_thread(self, request: bytes, client_address: Tuple[str, int]) -> None: ... # undocumented
def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ...
if sys.version_info >= (3, 6):
def server_close(self) -> None: ...
if sys.platform != "win32":
class ForkingTCPServer(ForkingMixIn, TCPServer): ...
class ForkingUDPServer(ForkingMixIn, UDPServer): ...
class ThreadingTCPServer(ThreadingMixIn, TCPServer): ...
class ThreadingUDPServer(ThreadingMixIn, UDPServer): ...
if sys.platform != "win32":
class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): ...
class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): ...
class BaseRequestHandler:
# Those are technically of types, respectively:
# * Union[SocketType, Tuple[bytes, SocketType]]
# * Union[Tuple[str, int], str]
# But there are some concerns that having unions here would cause
# too much inconvenience to people using it (see
# https://github.com/python/typeshed/pull/384#issuecomment-234649696)
request: Any
client_address: Any
server: BaseServer
def __init__(self, request: Any, client_address: Any, server: BaseServer) -> None: ...
def setup(self) -> None: ...
def handle(self) -> None: ...
def finish(self) -> None: ...
class StreamRequestHandler(BaseRequestHandler):
rbufsize: ClassVar[int] # Undocumented
wbufsize: ClassVar[int] # Undocumented
timeout: ClassVar[Optional[float]] # Undocumented
disable_nagle_algorithm: ClassVar[bool] # Undocumented
connection: SocketType # Undocumented
rfile: BinaryIO
wfile: BinaryIO
class DatagramRequestHandler(BaseRequestHandler):
packet: SocketType # Undocumented
socket: SocketType # Undocumented
rfile: BinaryIO
wfile: BinaryIO
| 5,367 | Python | .py | 121 | 38.066116 | 130 | 0.648261 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,249 | nturl2path.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/nturl2path.pyi | def url2pathname(url: str) -> str: ...
def pathname2url(p: str) -> str: ...
| 76 | Python | .py | 2 | 37 | 38 | 0.621622 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,250 | statistics.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/statistics.pyi | import sys
from _typeshed import SupportsLessThanT
from decimal import Decimal
from fractions import Fraction
from typing import Any, Hashable, 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)
# Used in mode, multimode
_HashableT = TypeVar("_HashableT", bound=Hashable)
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: ...
def harmonic_mean(data: Iterable[_Number]) -> _Number: ...
def median(data: Iterable[_Number]) -> _Number: ...
def median_low(data: Iterable[SupportsLessThanT]) -> SupportsLessThanT: ...
def median_high(data: Iterable[SupportsLessThanT]) -> SupportsLessThanT: ...
def median_grouped(data: Iterable[_Number], interval: _Number = ...) -> _Number: ...
def mode(data: Iterable[_HashableT]) -> _HashableT: ...
if sys.version_info >= (3, 8):
def multimode(data: Iterable[_HashableT]) -> List[_HashableT]: ...
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]: ...
if sys.version_info >= (3, 9):
def zscore(self, x: float) -> 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: ...
| 3,149 | Python | .py | 62 | 45.241935 | 100 | 0.59961 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,251 | fnmatch.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/fnmatch.pyi | from typing import AnyStr, Iterable, List
def fnmatch(name: AnyStr, pat: AnyStr) -> bool: ...
def fnmatchcase(name: AnyStr, pat: AnyStr) -> bool: ...
def filter(names: Iterable[AnyStr], pat: AnyStr) -> List[AnyStr]: ...
def translate(pat: str) -> str: ...
| 257 | Python | .py | 5 | 50.2 | 69 | 0.685259 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,252 | symbol.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/symbol.pyi | from typing import Dict
single_input: int
file_input: int
eval_input: int
decorator: int
decorators: int
decorated: int
async_funcdef: int
funcdef: int
parameters: int
typedargslist: int
tfpdef: int
varargslist: int
vfpdef: int
stmt: int
simple_stmt: int
small_stmt: int
expr_stmt: int
annassign: int
testlist_star_expr: int
augassign: int
del_stmt: int
pass_stmt: int
flow_stmt: int
break_stmt: int
continue_stmt: int
return_stmt: int
yield_stmt: int
raise_stmt: int
import_stmt: int
import_name: int
import_from: int
import_as_name: int
dotted_as_name: int
import_as_names: int
dotted_as_names: int
dotted_name: int
global_stmt: int
nonlocal_stmt: int
assert_stmt: int
compound_stmt: int
async_stmt: int
if_stmt: int
while_stmt: int
for_stmt: int
try_stmt: int
with_stmt: int
with_item: int
except_clause: int
suite: int
test: int
test_nocond: int
lambdef: int
lambdef_nocond: int
or_test: int
and_test: int
not_test: int
comparison: int
comp_op: int
star_expr: int
expr: int
xor_expr: int
and_expr: int
shift_expr: int
arith_expr: int
term: int
factor: int
power: int
atom_expr: int
atom: int
testlist_comp: int
trailer: int
subscriptlist: int
subscript: int
sliceop: int
exprlist: int
testlist: int
dictorsetmaker: int
classdef: int
arglist: int
argument: int
comp_iter: int
comp_for: int
comp_if: int
encoding_decl: int
yield_expr: int
yield_arg: int
sym_name: Dict[int, str]
| 1,383 | Python | .py | 88 | 14.693182 | 24 | 0.812838 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,253 | _compression.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_compression.pyi | from _typeshed import WriteableBuffer
from io import BufferedIOBase, RawIOBase
from typing import Any, Callable, Tuple, Type, Union
BUFFER_SIZE: Any
class BaseStream(BufferedIOBase): ...
class DecompressReader(RawIOBase):
def __init__(
self,
fp: RawIOBase,
decomp_factory: Callable[..., object],
trailing_error: Union[Type[Exception], Tuple[Type[Exception], ...]] = ...,
**decomp_args: Any,
) -> None: ...
def readable(self) -> bool: ...
def close(self) -> None: ...
def seekable(self) -> bool: ...
def readinto(self, b: WriteableBuffer) -> int: ...
def read(self, size: int = ...) -> bytes: ...
def seek(self, offset: int, whence: int = ...) -> int: ...
def tell(self) -> int: ...
| 761 | Python | .py | 20 | 33.1 | 82 | 0.613821 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,254 | sre_constants.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/sre_constants.pyi | from typing import Any, Dict, List, Optional, Union
MAGIC: int
class error(Exception):
msg: str
pattern: Optional[Union[str, bytes]]
pos: Optional[int]
lineno: int
colno: int
def __init__(self, msg: str, pattern: Union[str, bytes] = ..., pos: int = ...) -> None: ...
class _NamedIntConstant(int):
name: Any
def __new__(cls, value: int, name: str) -> _NamedIntConstant: ...
MAXREPEAT: _NamedIntConstant
OPCODES: List[_NamedIntConstant]
ATCODES: List[_NamedIntConstant]
CHCODES: List[_NamedIntConstant]
OP_IGNORE: Dict[_NamedIntConstant, _NamedIntConstant]
AT_MULTILINE: Dict[_NamedIntConstant, _NamedIntConstant]
AT_LOCALE: Dict[_NamedIntConstant, _NamedIntConstant]
AT_UNICODE: Dict[_NamedIntConstant, _NamedIntConstant]
CH_LOCALE: Dict[_NamedIntConstant, _NamedIntConstant]
CH_UNICODE: Dict[_NamedIntConstant, _NamedIntConstant]
SRE_FLAG_TEMPLATE: int
SRE_FLAG_IGNORECASE: int
SRE_FLAG_LOCALE: int
SRE_FLAG_MULTILINE: int
SRE_FLAG_DOTALL: int
SRE_FLAG_UNICODE: int
SRE_FLAG_VERBOSE: int
SRE_FLAG_DEBUG: int
SRE_FLAG_ASCII: int
SRE_INFO_PREFIX: int
SRE_INFO_LITERAL: int
SRE_INFO_CHARSET: int
# Stubgen above; manually defined constants below (dynamic at runtime)
# from OPCODES
FAILURE: _NamedIntConstant
SUCCESS: _NamedIntConstant
ANY: _NamedIntConstant
ANY_ALL: _NamedIntConstant
ASSERT: _NamedIntConstant
ASSERT_NOT: _NamedIntConstant
AT: _NamedIntConstant
BRANCH: _NamedIntConstant
CALL: _NamedIntConstant
CATEGORY: _NamedIntConstant
CHARSET: _NamedIntConstant
BIGCHARSET: _NamedIntConstant
GROUPREF: _NamedIntConstant
GROUPREF_EXISTS: _NamedIntConstant
GROUPREF_IGNORE: _NamedIntConstant
IN: _NamedIntConstant
IN_IGNORE: _NamedIntConstant
INFO: _NamedIntConstant
JUMP: _NamedIntConstant
LITERAL: _NamedIntConstant
LITERAL_IGNORE: _NamedIntConstant
MARK: _NamedIntConstant
MAX_UNTIL: _NamedIntConstant
MIN_UNTIL: _NamedIntConstant
NOT_LITERAL: _NamedIntConstant
NOT_LITERAL_IGNORE: _NamedIntConstant
NEGATE: _NamedIntConstant
RANGE: _NamedIntConstant
REPEAT: _NamedIntConstant
REPEAT_ONE: _NamedIntConstant
SUBPATTERN: _NamedIntConstant
MIN_REPEAT_ONE: _NamedIntConstant
RANGE_IGNORE: _NamedIntConstant
MIN_REPEAT: _NamedIntConstant
MAX_REPEAT: _NamedIntConstant
# from ATCODES
AT_BEGINNING: _NamedIntConstant
AT_BEGINNING_LINE: _NamedIntConstant
AT_BEGINNING_STRING: _NamedIntConstant
AT_BOUNDARY: _NamedIntConstant
AT_NON_BOUNDARY: _NamedIntConstant
AT_END: _NamedIntConstant
AT_END_LINE: _NamedIntConstant
AT_END_STRING: _NamedIntConstant
AT_LOC_BOUNDARY: _NamedIntConstant
AT_LOC_NON_BOUNDARY: _NamedIntConstant
AT_UNI_BOUNDARY: _NamedIntConstant
AT_UNI_NON_BOUNDARY: _NamedIntConstant
# from CHCODES
CATEGORY_DIGIT: _NamedIntConstant
CATEGORY_NOT_DIGIT: _NamedIntConstant
CATEGORY_SPACE: _NamedIntConstant
CATEGORY_NOT_SPACE: _NamedIntConstant
CATEGORY_WORD: _NamedIntConstant
CATEGORY_NOT_WORD: _NamedIntConstant
CATEGORY_LINEBREAK: _NamedIntConstant
CATEGORY_NOT_LINEBREAK: _NamedIntConstant
CATEGORY_LOC_WORD: _NamedIntConstant
CATEGORY_LOC_NOT_WORD: _NamedIntConstant
CATEGORY_UNI_DIGIT: _NamedIntConstant
CATEGORY_UNI_NOT_DIGIT: _NamedIntConstant
CATEGORY_UNI_SPACE: _NamedIntConstant
CATEGORY_UNI_NOT_SPACE: _NamedIntConstant
CATEGORY_UNI_WORD: _NamedIntConstant
CATEGORY_UNI_NOT_WORD: _NamedIntConstant
CATEGORY_UNI_LINEBREAK: _NamedIntConstant
CATEGORY_UNI_NOT_LINEBREAK: _NamedIntConstant
| 3,348 | Python | .py | 103 | 31.116505 | 95 | 0.827927 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,255 | atexit.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/atexit.pyi | from typing import Any, Callable
def _clear() -> None: ...
def _ncallbacks() -> int: ...
def _run_exitfuncs() -> None: ...
def register(func: Callable[..., Any], *args: Any, **kwargs: Any) -> Callable[..., Any]: ...
def unregister(func: Callable[..., Any]) -> None: ...
| 271 | Python | .py | 6 | 44 | 92 | 0.602273 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,256 | gc.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/gc.pyi | import sys
from typing import Any, Dict, List, Optional, Tuple
DEBUG_COLLECTABLE: int
DEBUG_LEAK: int
DEBUG_SAVEALL: int
DEBUG_STATS: int
DEBUG_UNCOLLECTABLE: int
callbacks: List[Any]
garbage: List[Any]
def collect(generation: int = ...) -> int: ...
def disable() -> None: ...
def enable() -> None: ...
def get_count() -> Tuple[int, int, int]: ...
def get_debug() -> int: ...
if sys.version_info >= (3, 8):
def get_objects(generation: Optional[int] = ...) -> List[Any]: ...
else:
def get_objects() -> List[Any]: ...
if sys.version_info >= (3, 7):
def freeze() -> None: ...
def unfreeze() -> None: ...
def get_freeze_count() -> int: ...
def get_referents(*objs: Any) -> List[Any]: ...
def get_referrers(*objs: Any) -> List[Any]: ...
def get_stats() -> List[Dict[str, Any]]: ...
def get_threshold() -> Tuple[int, int, int]: ...
def is_tracked(__obj: Any) -> bool: ...
if sys.version_info >= (3, 9):
def is_finalized(__obj: Any) -> bool: ...
def isenabled() -> bool: ...
def set_debug(__flags: int) -> None: ...
def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ...) -> None: ...
| 1,135 | Python | .py | 32 | 33.46875 | 93 | 0.614612 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,257 | re.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/re.pyi | import enum
import sys
from typing import Any, AnyStr, Callable, Iterator, List, Optional, Tuple, Union, overload
# ----- re variables and constants -----
if sys.version_info >= (3, 7):
from typing import Match as Match, Pattern as Pattern
else:
from typing import Match, Pattern
class RegexFlag(enum.IntFlag):
A: int
ASCII: int
DEBUG: int
I: int
IGNORECASE: int
L: int
LOCALE: int
M: int
MULTILINE: int
S: int
DOTALL: int
X: int
VERBOSE: int
U: int
UNICODE: int
T: int
TEMPLATE: int
A = RegexFlag.A
ASCII = RegexFlag.ASCII
DEBUG = RegexFlag.DEBUG
I = RegexFlag.I
IGNORECASE = RegexFlag.IGNORECASE
L = RegexFlag.L
LOCALE = RegexFlag.LOCALE
M = RegexFlag.M
MULTILINE = RegexFlag.MULTILINE
S = RegexFlag.S
DOTALL = RegexFlag.DOTALL
X = RegexFlag.X
VERBOSE = RegexFlag.VERBOSE
U = RegexFlag.U
UNICODE = RegexFlag.UNICODE
T = RegexFlag.T
TEMPLATE = RegexFlag.TEMPLATE
_FlagsType = Union[int, RegexFlag]
if sys.version_info < (3, 7):
# undocumented
_pattern_type: type
class error(Exception):
msg: str
pattern: str
pos: Optional[int]
lineno: Optional[int]
colno: Optional[int]
@overload
def compile(pattern: AnyStr, flags: _FlagsType = ...) -> Pattern[AnyStr]: ...
@overload
def compile(pattern: Pattern[AnyStr], flags: _FlagsType = ...) -> Pattern[AnyStr]: ...
@overload
def search(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ...
@overload
def search(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ...
@overload
def match(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ...
@overload
def match(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ...
# New in Python 3.4
@overload
def fullmatch(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ...
@overload
def fullmatch(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ...
@overload
def split(pattern: AnyStr, string: AnyStr, maxsplit: int = ..., flags: _FlagsType = ...) -> List[AnyStr]: ...
@overload
def split(pattern: Pattern[AnyStr], string: AnyStr, maxsplit: int = ..., flags: _FlagsType = ...) -> List[AnyStr]: ...
@overload
def findall(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> List[Any]: ...
@overload
def findall(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> List[Any]: ...
# Return an iterator yielding match objects over all non-overlapping matches
# for the RE pattern in string. The string is scanned left-to-right, and
# matches are returned in the order found. Empty matches are included in the
# result unless they touch the beginning of another match.
@overload
def finditer(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> Iterator[Match[AnyStr]]: ...
@overload
def finditer(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> Iterator[Match[AnyStr]]: ...
@overload
def sub(pattern: AnyStr, repl: AnyStr, string: AnyStr, count: int = ..., flags: _FlagsType = ...) -> AnyStr: ...
@overload
def sub(
pattern: AnyStr, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: _FlagsType = ...
) -> AnyStr: ...
@overload
def sub(pattern: Pattern[AnyStr], repl: AnyStr, string: AnyStr, count: int = ..., flags: _FlagsType = ...) -> AnyStr: ...
@overload
def sub(
pattern: Pattern[AnyStr], repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: _FlagsType = ...
) -> AnyStr: ...
@overload
def subn(pattern: AnyStr, repl: AnyStr, string: AnyStr, count: int = ..., flags: _FlagsType = ...) -> Tuple[AnyStr, int]: ...
@overload
def subn(
pattern: AnyStr, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: _FlagsType = ...
) -> Tuple[AnyStr, int]: ...
@overload
def subn(
pattern: Pattern[AnyStr], repl: AnyStr, string: AnyStr, count: int = ..., flags: _FlagsType = ...
) -> Tuple[AnyStr, int]: ...
@overload
def subn(
pattern: Pattern[AnyStr], repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: _FlagsType = ...
) -> Tuple[AnyStr, int]: ...
def escape(pattern: AnyStr) -> AnyStr: ...
def purge() -> None: ...
def template(pattern: Union[AnyStr, Pattern[AnyStr]], flags: _FlagsType = ...) -> Pattern[AnyStr]: ...
| 4,442 | Python | .py | 115 | 36.478261 | 128 | 0.685344 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,258 | zipapp.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/zipapp.pyi | import sys
from pathlib import Path
from typing import BinaryIO, Callable, Optional, Union
_Path = Union[str, Path, BinaryIO]
class ZipAppError(ValueError): ...
if sys.version_info >= (3, 7):
def create_archive(
source: _Path,
target: Optional[_Path] = ...,
interpreter: Optional[str] = ...,
main: Optional[str] = ...,
filter: Optional[Callable[[Path], bool]] = ...,
compressed: bool = ...,
) -> None: ...
else:
def create_archive(
source: _Path, target: Optional[_Path] = ..., interpreter: Optional[str] = ..., main: Optional[str] = ...
) -> None: ...
def get_interpreter(archive: _Path) -> str: ...
| 678 | Python | .py | 19 | 30.631579 | 113 | 0.599388 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,259 | gettext.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/gettext.pyi | import sys
from _typeshed import StrPath
from typing import IO, Any, Container, Iterable, Optional, Sequence, Type, TypeVar, overload
from typing_extensions import Literal
class NullTranslations:
def __init__(self, fp: Optional[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, msgid1: str, msgid2: str, n: int) -> str: ...
def lngettext(self, msgid1: str, msgid2: str, n: int) -> str: ...
if sys.version_info >= (3, 8):
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
CONTEXT: str
VERSIONS: Sequence[int]
def find(domain: str, localedir: Optional[StrPath] = ..., languages: Optional[Iterable[str]] = ..., all: bool = ...) -> Any: ...
_T = TypeVar("_T")
@overload
def translation(
domain: str,
localedir: Optional[StrPath] = ...,
languages: Optional[Iterable[str]] = ...,
class_: None = ...,
fallback: bool = ...,
codeset: Optional[str] = ...,
) -> NullTranslations: ...
@overload
def translation(
domain: str,
localedir: Optional[StrPath] = ...,
languages: Optional[Iterable[str]] = ...,
class_: Type[_T] = ...,
fallback: Literal[False] = ...,
codeset: Optional[str] = ...,
) -> _T: ...
@overload
def translation(
domain: str,
localedir: Optional[StrPath] = ...,
languages: Optional[Iterable[str]] = ...,
class_: Type[_T] = ...,
fallback: Literal[True] = ...,
codeset: Optional[str] = ...,
) -> Any: ...
def install(
domain: str, localedir: Optional[StrPath] = ..., codeset: Optional[str] = ..., names: Optional[Container[str]] = ...
) -> None: ...
def textdomain(domain: Optional[str] = ...) -> str: ...
def bindtextdomain(domain: str, localedir: Optional[StrPath] = ...) -> 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, msgid1: str, msgid2: str, n: int) -> str: ...
def ldngettext(domain: str, msgid1: str, msgid2: str, n: int) -> str: ...
def gettext(message: str) -> str: ...
def lgettext(message: str) -> str: ...
def ngettext(msgid1: str, msgid2: str, n: int) -> str: ...
def lngettext(msgid1: str, msgid2: str, n: int) -> str: ...
if sys.version_info >= (3, 8):
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
| 3,208 | Python | .py | 74 | 39.891892 | 128 | 0.620205 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,260 | hashlib.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/hashlib.pyi | import sys
from _typeshed import ReadableBuffer
from typing import AbstractSet, Optional
class _Hash(object):
digest_size: int
block_size: int
# [Python documentation note] Changed in version 3.4: The name attribute has
# been present in CPython since its inception, but until Python 3.4 was not
# formally specified, so may not exist on some platforms
name: str
def __init__(self, data: ReadableBuffer = ...) -> None: ...
def copy(self) -> _Hash: ...
def digest(self) -> bytes: ...
def hexdigest(self) -> str: ...
def update(self, __data: ReadableBuffer) -> None: ...
if sys.version_info >= (3, 9):
def md5(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
def sha1(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
def sha224(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
def sha256(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
def sha384(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
def sha512(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
elif sys.version_info >= (3, 8):
def md5(string: ReadableBuffer = ...) -> _Hash: ...
def sha1(string: ReadableBuffer = ...) -> _Hash: ...
def sha224(string: ReadableBuffer = ...) -> _Hash: ...
def sha256(string: ReadableBuffer = ...) -> _Hash: ...
def sha384(string: ReadableBuffer = ...) -> _Hash: ...
def sha512(string: ReadableBuffer = ...) -> _Hash: ...
else:
def md5(__string: ReadableBuffer = ...) -> _Hash: ...
def sha1(__string: ReadableBuffer = ...) -> _Hash: ...
def sha224(__string: ReadableBuffer = ...) -> _Hash: ...
def sha256(__string: ReadableBuffer = ...) -> _Hash: ...
def sha384(__string: ReadableBuffer = ...) -> _Hash: ...
def sha512(__string: ReadableBuffer = ...) -> _Hash: ...
def new(name: str, data: ReadableBuffer = ...) -> _Hash: ...
algorithms_guaranteed: AbstractSet[str]
algorithms_available: AbstractSet[str]
def pbkdf2_hmac(
hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: Optional[int] = ...
) -> bytes: ...
class _VarLenHash(object):
digest_size: int
block_size: int
name: str
def __init__(self, data: ReadableBuffer = ...) -> None: ...
def copy(self) -> _VarLenHash: ...
def digest(self, __length: int) -> bytes: ...
def hexdigest(self, __length: int) -> str: ...
def update(self, __data: ReadableBuffer) -> None: ...
sha3_224 = _Hash
sha3_256 = _Hash
sha3_384 = _Hash
sha3_512 = _Hash
shake_128 = _VarLenHash
shake_256 = _VarLenHash
def scrypt(
password: ReadableBuffer,
*,
salt: Optional[ReadableBuffer] = ...,
n: Optional[int] = ...,
r: Optional[int] = ...,
p: Optional[int] = ...,
maxmem: int = ...,
dklen: int = ...,
) -> bytes: ...
class _BlakeHash(_Hash):
MAX_DIGEST_SIZE: int
MAX_KEY_SIZE: int
PERSON_SIZE: int
SALT_SIZE: int
if sys.version_info >= (3, 9):
def __init__(
self,
__data: ReadableBuffer = ...,
*,
digest_size: int = ...,
key: ReadableBuffer = ...,
salt: ReadableBuffer = ...,
person: ReadableBuffer = ...,
fanout: int = ...,
depth: int = ...,
leaf_size: int = ...,
node_offset: int = ...,
node_depth: int = ...,
inner_size: int = ...,
last_node: bool = ...,
usedforsecurity: bool = ...,
) -> None: ...
else:
def __init__(
self,
__data: ReadableBuffer = ...,
*,
digest_size: int = ...,
key: ReadableBuffer = ...,
salt: ReadableBuffer = ...,
person: ReadableBuffer = ...,
fanout: int = ...,
depth: int = ...,
leaf_size: int = ...,
node_offset: int = ...,
node_depth: int = ...,
inner_size: int = ...,
last_node: bool = ...,
) -> None: ...
blake2b = _BlakeHash
blake2s = _BlakeHash
| 4,195 | Python | .py | 109 | 31.963303 | 111 | 0.548625 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,261 | compileall.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/compileall.pyi | import sys
from _typeshed import AnyPath
from typing import Any, Optional, Pattern
if sys.version_info >= (3, 7):
from py_compile import PycInvalidationMode
if sys.version_info >= (3, 9):
def compile_dir(
dir: AnyPath,
maxlevels: Optional[int] = ...,
ddir: Optional[AnyPath] = ...,
force: bool = ...,
rx: Optional[Pattern[Any]] = ...,
quiet: int = ...,
legacy: bool = ...,
optimize: int = ...,
workers: int = ...,
invalidation_mode: Optional[PycInvalidationMode] = ...,
*,
stripdir: Optional[str] = ..., # TODO: change to Optional[AnyPath] once https://bugs.python.org/issue40447 is resolved
prependdir: Optional[AnyPath] = ...,
limit_sl_dest: Optional[AnyPath] = ...,
hardlink_dupes: bool = ...,
) -> int: ...
def compile_file(
fullname: AnyPath,
ddir: Optional[AnyPath] = ...,
force: bool = ...,
rx: Optional[Pattern[Any]] = ...,
quiet: int = ...,
legacy: bool = ...,
optimize: int = ...,
invalidation_mode: Optional[PycInvalidationMode] = ...,
*,
stripdir: Optional[str] = ..., # TODO: change to Optional[AnyPath] once https://bugs.python.org/issue40447 is resolved
prependdir: Optional[AnyPath] = ...,
limit_sl_dest: Optional[AnyPath] = ...,
hardlink_dupes: bool = ...,
) -> int: ...
elif sys.version_info >= (3, 7):
def compile_dir(
dir: AnyPath,
maxlevels: int = ...,
ddir: Optional[AnyPath] = ...,
force: bool = ...,
rx: Optional[Pattern[Any]] = ...,
quiet: int = ...,
legacy: bool = ...,
optimize: int = ...,
workers: int = ...,
invalidation_mode: Optional[PycInvalidationMode] = ...,
) -> int: ...
def compile_file(
fullname: AnyPath,
ddir: Optional[AnyPath] = ...,
force: bool = ...,
rx: Optional[Pattern[Any]] = ...,
quiet: int = ...,
legacy: bool = ...,
optimize: int = ...,
invalidation_mode: Optional[PycInvalidationMode] = ...,
) -> int: ...
else:
# rx can be any object with a 'search' method; once we have Protocols we can change the type
def compile_dir(
dir: AnyPath,
maxlevels: int = ...,
ddir: Optional[AnyPath] = ...,
force: bool = ...,
rx: Optional[Pattern[Any]] = ...,
quiet: int = ...,
legacy: bool = ...,
optimize: int = ...,
workers: int = ...,
) -> int: ...
def compile_file(
fullname: AnyPath,
ddir: Optional[AnyPath] = ...,
force: bool = ...,
rx: Optional[Pattern[Any]] = ...,
quiet: int = ...,
legacy: bool = ...,
optimize: int = ...,
) -> int: ...
if sys.version_info >= (3, 7):
def compile_path(
skip_curdir: bool = ...,
maxlevels: int = ...,
force: bool = ...,
quiet: int = ...,
legacy: bool = ...,
optimize: int = ...,
invalidation_mode: Optional[PycInvalidationMode] = ...,
) -> int: ...
else:
def compile_path(
skip_curdir: bool = ...,
maxlevels: int = ...,
force: bool = ...,
quiet: int = ...,
legacy: bool = ...,
optimize: int = ...,
) -> int: ...
| 3,367 | Python | .py | 102 | 25.362745 | 127 | 0.508438 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,262 | _tkinter.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_tkinter.pyi | from typing import Any, Tuple, Union
# _tkinter is meant to be only used internally by tkinter, but some tkinter
# functions e.g. return _tkinter.Tcl_Obj objects. Tcl_Obj represents a Tcl
# object that hasn't been converted to a string.
#
# There are not many ways to get Tcl_Objs from tkinter, and I'm not sure if the
# only existing ways are supposed to return Tcl_Objs as opposed to returning
# strings. Here's one of these things that return Tcl_Objs:
#
# >>> import tkinter
# >>> text = tkinter.Text()
# >>> text.tag_add('foo', '1.0', 'end')
# >>> text.tag_ranges('foo')
# (<textindex object: '1.0'>, <textindex object: '2.0'>)
class Tcl_Obj:
string: str # str(tclobj) returns this
typename: str
class TclError(Exception): ...
# This class allows running Tcl code. Tkinter uses it internally a lot, and
# it's often handy to drop a piece of Tcl code into a tkinter program. Example:
#
# >>> import tkinter, _tkinter
# >>> tkapp = tkinter.Tk().tk
# >>> isinstance(tkapp, _tkinter.TkappType)
# True
# >>> tkapp.call('set', 'foo', (1,2,3))
# (1, 2, 3)
# >>> tkapp.eval('return $foo')
# '1 2 3'
# >>>
#
# call args can be pretty much anything. Also, call(some_tuple) is same as call(*some_tuple).
#
# eval always returns str because _tkinter_tkapp_eval_impl in _tkinter.c calls
# Tkapp_UnicodeResult, and it returns a string when it succeeds.
class TkappType:
# Please keep in sync with tkinter.Tk
def call(self, __command: Union[str, Tuple[Any, ...]], *args: Any) -> Any: ...
def eval(self, __script: str) -> str: ...
adderrorinfo: Any
createcommand: Any
createfilehandler: Any
createtimerhandler: Any
deletecommand: Any
deletefilehandler: Any
dooneevent: Any
evalfile: Any
exprboolean: Any
exprdouble: Any
exprlong: Any
exprstring: Any
getboolean: Any
getdouble: Any
getint: Any
getvar: Any
globalgetvar: Any
globalsetvar: Any
globalunsetvar: Any
interpaddr: Any
loadtk: Any
mainloop: Any
quit: Any
record: Any
setvar: Any
split: Any
splitlist: Any
unsetvar: Any
wantobjects: Any
willdispatch: Any
ALL_EVENTS: int
FILE_EVENTS: int
IDLE_EVENTS: int
TIMER_EVENTS: int
WINDOW_EVENTS: int
DONT_WAIT: int
EXCEPTION: int
READABLE: int
WRITABLE: int
TCL_VERSION: str
TK_VERSION: str
# TODO: figure out what these are (with e.g. help()) and get rid of Any
TkttType: Any
_flatten: Any
create: Any
getbusywaitinterval: Any
setbusywaitinterval: Any
| 2,531 | Python | .py | 86 | 26.72093 | 93 | 0.694011 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,263 | subprocess.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/subprocess.pyi | import sys
from _typeshed import AnyPath
from types import TracebackType
from typing import IO, Any, AnyStr, Callable, Generic, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union, overload
from typing_extensions import Literal
if sys.version_info >= (3, 9):
from types import GenericAlias
# We prefer to annotate inputs to methods (eg subprocess.check_call) with these
# union types.
# For outputs we use laborious literal based overloads to try to determine
# which specific return types to use, and prefer to fall back to Any when
# this does not work, so the caller does not have to use an assertion to confirm
# which type.
#
# For example:
#
# try:
# x = subprocess.check_output(["ls", "-l"])
# reveal_type(x) # bytes, based on the overloads
# except TimeoutError as e:
# reveal_type(e.cmd) # Any, but morally is _CMD
_FILE = Union[None, int, IO[Any]]
_TXT = Union[bytes, str]
# Python 3.6 does't support _CMD being a single PathLike.
# See: https://bugs.python.org/issue31961
_CMD = Union[_TXT, Sequence[AnyPath]]
_ENV = Union[Mapping[bytes, _TXT], Mapping[str, _TXT]]
_S = TypeVar("_S")
_T = TypeVar("_T")
class CompletedProcess(Generic[_T]):
# morally: _CMD
args: Any
returncode: int
# These are really both Optional, but requiring checks would be tedious
# and writing all the overloads would be horrific.
stdout: _T
stderr: _T
def __init__(self, args: _CMD, returncode: int, stdout: Optional[_T] = ..., stderr: Optional[_T] = ...) -> None: ...
def check_returncode(self) -> None: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
if sys.version_info >= (3, 7):
# Nearly the same args as for 3.6, except for capture_output and text
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
capture_output: bool = ...,
check: bool = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
input: Optional[str] = ...,
text: Literal[True],
timeout: Optional[float] = ...,
) -> CompletedProcess[str]: ...
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
capture_output: bool = ...,
check: bool = ...,
encoding: str,
errors: Optional[str] = ...,
input: Optional[str] = ...,
text: Optional[bool] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[str]: ...
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
capture_output: bool = ...,
check: bool = ...,
encoding: Optional[str] = ...,
errors: str,
input: Optional[str] = ...,
text: Optional[bool] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[str]: ...
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
*,
universal_newlines: Literal[True],
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
# where the *real* keyword only args start
capture_output: bool = ...,
check: bool = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
input: Optional[str] = ...,
text: Optional[bool] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[str]: ...
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: Literal[False] = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
capture_output: bool = ...,
check: bool = ...,
encoding: None = ...,
errors: None = ...,
input: Optional[bytes] = ...,
text: Literal[None, False] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[bytes]: ...
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
capture_output: bool = ...,
check: bool = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
input: Optional[_TXT] = ...,
text: Optional[bool] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[Any]: ...
else:
# Nearly same args as Popen.__init__ except for timeout, input, and check
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
check: bool = ...,
encoding: str,
errors: Optional[str] = ...,
input: Optional[str] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[str]: ...
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
check: bool = ...,
encoding: Optional[str] = ...,
errors: str,
input: Optional[str] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[str]: ...
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
*,
universal_newlines: Literal[True],
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
# where the *real* keyword only args start
check: bool = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
input: Optional[str] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[str]: ...
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: Literal[False] = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
check: bool = ...,
encoding: None = ...,
errors: None = ...,
input: Optional[bytes] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[bytes]: ...
@overload
def run(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
check: bool = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
input: Optional[_TXT] = ...,
timeout: Optional[float] = ...,
) -> CompletedProcess[Any]: ...
# Same args as Popen.__init__
def call(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
) -> int: ...
# Same args as Popen.__init__
def check_call(
args: _CMD,
bufsize: int = ...,
executable: AnyPath = ...,
stdin: _FILE = ...,
stdout: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
timeout: Optional[float] = ...,
) -> int: ...
if sys.version_info >= (3, 7):
# 3.7 added text
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
text: Literal[True],
) -> str: ...
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: str,
errors: Optional[str] = ...,
text: Optional[bool] = ...,
) -> str: ...
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: Optional[str] = ...,
errors: str,
text: Optional[bool] = ...,
) -> str: ...
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
*,
universal_newlines: Literal[True],
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
# where the real keyword only ones start
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
text: Optional[bool] = ...,
) -> str: ...
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: Literal[False] = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: None = ...,
errors: None = ...,
text: Literal[None, False] = ...,
) -> bytes: ...
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
text: Optional[bool] = ...,
) -> Any: ... # morally: -> _TXT
else:
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: str,
errors: Optional[str] = ...,
) -> str: ...
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: Optional[str] = ...,
errors: str,
) -> str: ...
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
universal_newlines: Literal[True],
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
) -> str: ...
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: Literal[False] = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: None = ...,
errors: None = ...,
) -> bytes: ...
@overload
def check_output(
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: _FILE = ...,
stderr: _FILE = ...,
preexec_fn: Callable[[], Any] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Any = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
timeout: Optional[float] = ...,
input: _TXT = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
) -> Any: ... # morally: -> _TXT
PIPE: int
STDOUT: int
DEVNULL: int
class SubprocessError(Exception): ...
class TimeoutExpired(SubprocessError):
def __init__(self, cmd: _CMD, timeout: float, output: Optional[_TXT] = ..., stderr: Optional[_TXT] = ...) -> None: ...
# morally: _CMD
cmd: Any
timeout: float
# morally: Optional[_TXT]
output: Any
stdout: Any
stderr: Any
class CalledProcessError(SubprocessError):
returncode: int
# morally: _CMD
cmd: Any
# morally: Optional[_TXT]
output: Any
# morally: Optional[_TXT]
stdout: Any
stderr: Any
def __init__(self, returncode: int, cmd: _CMD, output: Optional[_TXT] = ..., stderr: Optional[_TXT] = ...) -> None: ...
class Popen(Generic[AnyStr]):
args: _CMD
stdin: Optional[IO[AnyStr]]
stdout: Optional[IO[AnyStr]]
stderr: Optional[IO[AnyStr]]
pid: int
returncode: int
universal_newlines: bool
# Technically it is wrong that Popen provides __new__ instead of __init__
# but this shouldn't come up hopefully?
if sys.version_info >= (3, 7):
# text is added in 3.7
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
text: Optional[bool] = ...,
encoding: str,
errors: Optional[str] = ...,
) -> Popen[str]: ...
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
text: Optional[bool] = ...,
encoding: Optional[str] = ...,
errors: str,
) -> Popen[str]: ...
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
*,
universal_newlines: Literal[True],
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
# where the *real* keyword only args start
text: Optional[bool] = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
) -> Popen[str]: ...
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
text: Literal[True],
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
) -> Popen[str]: ...
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: Literal[False] = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
text: Literal[None, False] = ...,
encoding: None = ...,
errors: None = ...,
) -> Popen[bytes]: ...
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
text: Optional[bool] = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
) -> Popen[Any]: ...
else:
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
encoding: str,
errors: Optional[str] = ...,
) -> Popen[str]: ...
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
encoding: Optional[str] = ...,
errors: str,
) -> Popen[str]: ...
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
*,
universal_newlines: Literal[True],
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
# where the *real* keyword only args start
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
) -> Popen[str]: ...
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: Literal[False] = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
encoding: None = ...,
errors: None = ...,
) -> Popen[bytes]: ...
@overload
def __new__(
cls,
args: _CMD,
bufsize: int = ...,
executable: Optional[AnyPath] = ...,
stdin: Optional[_FILE] = ...,
stdout: Optional[_FILE] = ...,
stderr: Optional[_FILE] = ...,
preexec_fn: Optional[Callable[[], Any]] = ...,
close_fds: bool = ...,
shell: bool = ...,
cwd: Optional[AnyPath] = ...,
env: Optional[_ENV] = ...,
universal_newlines: bool = ...,
startupinfo: Optional[Any] = ...,
creationflags: int = ...,
restore_signals: bool = ...,
start_new_session: bool = ...,
pass_fds: Any = ...,
*,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
) -> Popen[Any]: ...
def poll(self) -> Optional[int]: ...
if sys.version_info >= (3, 7):
def wait(self, timeout: Optional[float] = ...) -> int: ...
else:
def wait(self, timeout: Optional[float] = ..., endtime: Optional[float] = ...) -> int: ...
# Return str/bytes
def communicate(
self,
input: Optional[AnyStr] = ...,
timeout: Optional[float] = ...,
# morally this should be optional
) -> Tuple[AnyStr, AnyStr]: ...
def send_signal(self, sig: int) -> None: ...
def terminate(self) -> None: ...
def kill(self) -> None: ...
def __enter__(self: _S) -> _S: ...
def __exit__(
self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]
) -> None: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
# The result really is always a str.
def getstatusoutput(cmd: _TXT) -> Tuple[int, str]: ...
def getoutput(cmd: _TXT) -> str: ...
def list2cmdline(seq: Sequence[str]) -> str: ... # undocumented
if sys.platform == "win32":
class STARTUPINFO:
if sys.version_info >= (3, 7):
def __init__(
self,
*,
dwFlags: int = ...,
hStdInput: Optional[Any] = ...,
hStdOutput: Optional[Any] = ...,
hStdError: Optional[Any] = ...,
wShowWindow: int = ...,
lpAttributeList: Optional[Mapping[str, Any]] = ...,
) -> None: ...
dwFlags: int
hStdInput: Optional[Any]
hStdOutput: Optional[Any]
hStdError: Optional[Any]
wShowWindow: int
if sys.version_info >= (3, 7):
lpAttributeList: Mapping[str, Any]
STD_INPUT_HANDLE: Any
STD_OUTPUT_HANDLE: Any
STD_ERROR_HANDLE: Any
SW_HIDE: int
STARTF_USESTDHANDLES: int
STARTF_USESHOWWINDOW: int
CREATE_NEW_CONSOLE: int
CREATE_NEW_PROCESS_GROUP: int
if sys.version_info >= (3, 7):
ABOVE_NORMAL_PRIORITY_CLASS: int
BELOW_NORMAL_PRIORITY_CLASS: int
HIGH_PRIORITY_CLASS: int
IDLE_PRIORITY_CLASS: int
NORMAL_PRIORITY_CLASS: int
REALTIME_PRIORITY_CLASS: int
CREATE_NO_WINDOW: int
DETACHED_PROCESS: int
CREATE_DEFAULT_ERROR_MODE: int
CREATE_BREAKAWAY_FROM_JOB: int
| 34,320 | Python | .py | 1,034 | 24.218569 | 123 | 0.468737 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,264 | _ast.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_ast.pyi | import sys
import typing
from typing import Any, ClassVar, Optional
PyCF_ONLY_AST: int
if sys.version_info >= (3, 8):
PyCF_TYPE_COMMENTS: int
PyCF_ALLOW_TOP_LEVEL_AWAIT: int
_identifier = str
class AST:
_attributes: ClassVar[typing.Tuple[str, ...]]
_fields: ClassVar[typing.Tuple[str, ...]]
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
# TODO: Not all nodes have all of the following attributes
lineno: int
col_offset: int
if sys.version_info >= (3, 8):
end_lineno: Optional[int]
end_col_offset: Optional[int]
type_comment: Optional[str]
class mod(AST): ...
if sys.version_info >= (3, 8):
class type_ignore(AST): ...
class TypeIgnore(type_ignore): ...
class FunctionType(mod):
argtypes: typing.List[expr]
returns: expr
class Module(mod):
body: typing.List[stmt]
if sys.version_info >= (3, 8):
type_ignores: typing.List[TypeIgnore]
class Interactive(mod):
body: typing.List[stmt]
class Expression(mod):
body: expr
class stmt(AST): ...
class FunctionDef(stmt):
name: _identifier
args: arguments
body: typing.List[stmt]
decorator_list: typing.List[expr]
returns: Optional[expr]
class AsyncFunctionDef(stmt):
name: _identifier
args: arguments
body: typing.List[stmt]
decorator_list: typing.List[expr]
returns: Optional[expr]
class ClassDef(stmt):
name: _identifier
bases: typing.List[expr]
keywords: typing.List[keyword]
body: typing.List[stmt]
decorator_list: typing.List[expr]
class Return(stmt):
value: Optional[expr]
class Delete(stmt):
targets: typing.List[expr]
class Assign(stmt):
targets: typing.List[expr]
value: expr
class AugAssign(stmt):
target: expr
op: operator
value: expr
class AnnAssign(stmt):
target: expr
annotation: expr
value: Optional[expr]
simple: int
class For(stmt):
target: expr
iter: expr
body: typing.List[stmt]
orelse: typing.List[stmt]
class AsyncFor(stmt):
target: expr
iter: expr
body: typing.List[stmt]
orelse: typing.List[stmt]
class While(stmt):
test: expr
body: typing.List[stmt]
orelse: typing.List[stmt]
class If(stmt):
test: expr
body: typing.List[stmt]
orelse: typing.List[stmt]
class With(stmt):
items: typing.List[withitem]
body: typing.List[stmt]
class AsyncWith(stmt):
items: typing.List[withitem]
body: typing.List[stmt]
class Raise(stmt):
exc: Optional[expr]
cause: Optional[expr]
class Try(stmt):
body: typing.List[stmt]
handlers: typing.List[ExceptHandler]
orelse: typing.List[stmt]
finalbody: typing.List[stmt]
class Assert(stmt):
test: expr
msg: Optional[expr]
class Import(stmt):
names: typing.List[alias]
class ImportFrom(stmt):
module: Optional[_identifier]
names: typing.List[alias]
level: int
class Global(stmt):
names: typing.List[_identifier]
class Nonlocal(stmt):
names: typing.List[_identifier]
class Expr(stmt):
value: expr
class Pass(stmt): ...
class Break(stmt): ...
class Continue(stmt): ...
class expr(AST): ...
class BoolOp(expr):
op: boolop
values: typing.List[expr]
class BinOp(expr):
left: expr
op: operator
right: expr
class UnaryOp(expr):
op: unaryop
operand: expr
class Lambda(expr):
args: arguments
body: expr
class IfExp(expr):
test: expr
body: expr
orelse: expr
class Dict(expr):
keys: typing.List[Optional[expr]]
values: typing.List[expr]
class Set(expr):
elts: typing.List[expr]
class ListComp(expr):
elt: expr
generators: typing.List[comprehension]
class SetComp(expr):
elt: expr
generators: typing.List[comprehension]
class DictComp(expr):
key: expr
value: expr
generators: typing.List[comprehension]
class GeneratorExp(expr):
elt: expr
generators: typing.List[comprehension]
class Await(expr):
value: expr
class Yield(expr):
value: Optional[expr]
class YieldFrom(expr):
value: expr
class Compare(expr):
left: expr
ops: typing.List[cmpop]
comparators: typing.List[expr]
class Call(expr):
func: expr
args: typing.List[expr]
keywords: typing.List[keyword]
class FormattedValue(expr):
value: expr
conversion: Optional[int]
format_spec: Optional[expr]
class JoinedStr(expr):
values: typing.List[expr]
if sys.version_info < (3, 8):
class Num(expr): # Deprecated in 3.8; use Constant
n: complex
class Str(expr): # Deprecated in 3.8; use Constant
s: str
class Bytes(expr): # Deprecated in 3.8; use Constant
s: bytes
class NameConstant(expr): # Deprecated in 3.8; use Constant
value: Any
class Ellipsis(expr): ... # Deprecated in 3.8; use Constant
class Constant(expr):
value: Any # None, str, bytes, bool, int, float, complex, Ellipsis
kind: Optional[str]
# Aliases for value, for backwards compatibility
s: Any
n: complex
if sys.version_info >= (3, 8):
class NamedExpr(expr):
target: expr
value: expr
class Attribute(expr):
value: expr
attr: _identifier
ctx: expr_context
if sys.version_info >= (3, 9):
_SliceT = expr
else:
class slice(AST): ...
_SliceT = slice
class Slice(_SliceT):
lower: Optional[expr]
upper: Optional[expr]
step: Optional[expr]
if sys.version_info < (3, 9):
class ExtSlice(slice):
dims: typing.List[slice]
class Index(slice):
value: expr
class Subscript(expr):
value: expr
slice: _SliceT
ctx: expr_context
class Starred(expr):
value: expr
ctx: expr_context
class Name(expr):
id: _identifier
ctx: expr_context
class List(expr):
elts: typing.List[expr]
ctx: expr_context
class Tuple(expr):
elts: typing.List[expr]
ctx: expr_context
class expr_context(AST): ...
if sys.version_info < (3, 9):
class AugLoad(expr_context): ...
class AugStore(expr_context): ...
class Param(expr_context): ...
class Suite(mod):
body: typing.List[stmt]
class Del(expr_context): ...
class Load(expr_context): ...
class Store(expr_context): ...
class boolop(AST): ...
class And(boolop): ...
class Or(boolop): ...
class operator(AST): ...
class Add(operator): ...
class BitAnd(operator): ...
class BitOr(operator): ...
class BitXor(operator): ...
class Div(operator): ...
class FloorDiv(operator): ...
class LShift(operator): ...
class Mod(operator): ...
class Mult(operator): ...
class MatMult(operator): ...
class Pow(operator): ...
class RShift(operator): ...
class Sub(operator): ...
class unaryop(AST): ...
class Invert(unaryop): ...
class Not(unaryop): ...
class UAdd(unaryop): ...
class USub(unaryop): ...
class cmpop(AST): ...
class Eq(cmpop): ...
class Gt(cmpop): ...
class GtE(cmpop): ...
class In(cmpop): ...
class Is(cmpop): ...
class IsNot(cmpop): ...
class Lt(cmpop): ...
class LtE(cmpop): ...
class NotEq(cmpop): ...
class NotIn(cmpop): ...
class comprehension(AST):
target: expr
iter: expr
ifs: typing.List[expr]
is_async: int
class excepthandler(AST): ...
class ExceptHandler(excepthandler):
type: Optional[expr]
name: Optional[_identifier]
body: typing.List[stmt]
class arguments(AST):
if sys.version_info >= (3, 8):
posonlyargs: typing.List[arg]
args: typing.List[arg]
vararg: Optional[arg]
kwonlyargs: typing.List[arg]
kw_defaults: typing.List[Optional[expr]]
kwarg: Optional[arg]
defaults: typing.List[expr]
class arg(AST):
arg: _identifier
annotation: Optional[expr]
class keyword(AST):
arg: Optional[_identifier]
value: expr
class alias(AST):
name: _identifier
asname: Optional[_identifier]
class withitem(AST):
context_expr: expr
optional_vars: Optional[expr]
| 7,851 | Python | .py | 303 | 21.990099 | 71 | 0.68214 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,265 | builtins.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/builtins.pyi | import sys
from _typeshed import (
AnyPath,
OpenBinaryMode,
OpenBinaryModeReading,
OpenBinaryModeUpdating,
OpenBinaryModeWriting,
OpenTextMode,
ReadableBuffer,
SupportsKeysAndGetItem,
SupportsLessThan,
SupportsLessThanT,
SupportsWrite,
)
from ast import AST, mod
from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
from types import CodeType, TracebackType
from typing import (
IO,
AbstractSet,
Any,
BinaryIO,
ByteString,
Callable,
Container,
Dict,
FrozenSet,
Generic,
ItemsView,
Iterable,
Iterator,
KeysView,
List,
Mapping,
MutableMapping,
MutableSequence,
MutableSet,
NoReturn,
Optional,
Protocol,
Reversible,
Sequence,
Set,
Sized,
SupportsAbs,
SupportsBytes,
SupportsComplex,
SupportsFloat,
SupportsInt,
SupportsRound,
Tuple,
Type,
TypeVar,
Union,
ValuesView,
overload,
runtime_checkable,
)
from typing_extensions import Literal
if sys.version_info >= (3, 9):
from types import GenericAlias
class _SupportsIndex(Protocol):
def __index__(self) -> int: ...
class _SupportsTrunc(Protocol):
def __trunc__(self) -> int: ...
_T = TypeVar("_T")
_T_co = TypeVar("_T_co", covariant=True)
_KT = TypeVar("_KT")
_VT = TypeVar("_VT")
_S = TypeVar("_S")
_T1 = TypeVar("_T1")
_T2 = TypeVar("_T2")
_T3 = TypeVar("_T3")
_T4 = TypeVar("_T4")
_T5 = TypeVar("_T5")
_TT = TypeVar("_TT", bound="type")
_TBE = TypeVar("_TBE", bound="BaseException")
class object:
__doc__: Optional[str]
__dict__: Dict[str, Any]
__slots__: Union[str, Iterable[str]]
__module__: str
__annotations__: Dict[str, Any]
@property
def __class__(self: _T) -> Type[_T]: ...
@__class__.setter
def __class__(self, __type: Type[object]) -> None: ... # noqa: F811
def __init__(self) -> None: ...
def __new__(cls) -> Any: ...
def __setattr__(self, name: str, value: Any) -> None: ...
def __eq__(self, o: object) -> bool: ...
def __ne__(self, o: object) -> bool: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __hash__(self) -> int: ...
def __format__(self, format_spec: str) -> str: ...
def __getattribute__(self, name: str) -> Any: ...
def __delattr__(self, name: str) -> None: ...
def __sizeof__(self) -> int: ...
def __reduce__(self) -> Union[str, Tuple[Any, ...]]: ...
def __reduce_ex__(self, protocol: int) -> Union[str, Tuple[Any, ...]]: ...
def __dir__(self) -> Iterable[str]: ...
def __init_subclass__(cls) -> None: ...
class staticmethod(object): # Special, only valid as a decorator.
__func__: Callable[..., Any]
__isabstractmethod__: bool
def __init__(self, f: Callable[..., Any]) -> None: ...
def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...
def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ...
class classmethod(object): # Special, only valid as a decorator.
__func__: Callable[..., Any]
__isabstractmethod__: bool
def __init__(self, f: Callable[..., Any]) -> None: ...
def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...
def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ...
class type(object):
__base__: type
__bases__: Tuple[type, ...]
__basicsize__: int
__dict__: Dict[str, Any]
__dictoffset__: int
__flags__: int
__itemsize__: int
__module__: str
__mro__: Tuple[type, ...]
__name__: str
__qualname__: str
__text_signature__: Optional[str]
__weakrefoffset__: int
@overload
def __init__(self, o: object) -> None: ...
@overload
def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ...
@overload
def __new__(cls, o: object) -> type: ...
@overload
def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ...
def __call__(self, *args: Any, **kwds: Any) -> Any: ...
def __subclasses__(self: _TT) -> List[_TT]: ...
# Note: the documentation doesnt specify what the return type is, the standard
# implementation seems to be returning a list.
def mro(self) -> List[type]: ...
def __instancecheck__(self, instance: Any) -> bool: ...
def __subclasscheck__(self, subclass: type) -> bool: ...
@classmethod
def __prepare__(metacls, __name: str, __bases: Tuple[type, ...], **kwds: Any) -> Mapping[str, Any]: ...
class super(object):
@overload
def __init__(self, t: Any, obj: Any) -> None: ...
@overload
def __init__(self, t: Any) -> None: ...
@overload
def __init__(self) -> None: ...
class int:
@overload
def __new__(cls: Type[_T], x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc] = ...) -> _T: ...
@overload
def __new__(cls: Type[_T], x: Union[str, bytes, bytearray], base: int) -> _T: ...
@overload
def __init__(self, x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc] = ...) -> _T: ...
@overload
def __init__(self, x: Union[str, bytes, bytearray], base: int) -> _T: ...
if sys.version_info >= (3, 8):
def as_integer_ratio(self) -> Tuple[int, Literal[1]]: ...
@property
def real(self) -> int: ...
@property
def imag(self) -> int: ...
@property
def numerator(self) -> int: ...
@property
def denominator(self) -> int: ...
def conjugate(self) -> int: ...
def bit_length(self) -> int: ...
def to_bytes(self, length: int, byteorder: str, *, signed: bool = ...) -> bytes: ...
@classmethod
def from_bytes(
cls, bytes: Union[Iterable[int], SupportsBytes], byteorder: str, *, signed: bool = ...
) -> int: ... # TODO buffer object argument
def __add__(self, x: int) -> int: ...
def __sub__(self, x: int) -> int: ...
def __mul__(self, x: int) -> int: ...
def __floordiv__(self, x: int) -> int: ...
def __truediv__(self, x: int) -> float: ...
def __mod__(self, x: int) -> int: ...
def __divmod__(self, x: int) -> Tuple[int, int]: ...
def __radd__(self, x: int) -> int: ...
def __rsub__(self, x: int) -> int: ...
def __rmul__(self, x: int) -> int: ...
def __rfloordiv__(self, x: int) -> int: ...
def __rtruediv__(self, x: int) -> float: ...
def __rmod__(self, x: int) -> int: ...
def __rdivmod__(self, x: int) -> Tuple[int, int]: ...
@overload
def __pow__(self, __x: Literal[2], __modulo: Optional[int] = ...) -> int: ...
@overload
def __pow__(self, __x: int, __modulo: Optional[int] = ...) -> Any: ... # Return type can be int or float, depending on x.
def __rpow__(self, x: int, mod: Optional[int] = ...) -> Any: ...
def __and__(self, n: int) -> int: ...
def __or__(self, n: int) -> int: ...
def __xor__(self, n: int) -> int: ...
def __lshift__(self, n: int) -> int: ...
def __rshift__(self, n: int) -> int: ...
def __rand__(self, n: int) -> int: ...
def __ror__(self, n: int) -> int: ...
def __rxor__(self, n: int) -> int: ...
def __rlshift__(self, n: int) -> int: ...
def __rrshift__(self, n: int) -> int: ...
def __neg__(self) -> int: ...
def __pos__(self) -> int: ...
def __invert__(self) -> int: ...
def __trunc__(self) -> int: ...
def __ceil__(self) -> int: ...
def __floor__(self) -> int: ...
def __round__(self, ndigits: Optional[int] = ...) -> int: ...
def __getnewargs__(self) -> Tuple[int]: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: int) -> bool: ...
def __le__(self, x: int) -> bool: ...
def __gt__(self, x: int) -> bool: ...
def __ge__(self, x: int) -> bool: ...
def __str__(self) -> str: ...
def __float__(self) -> float: ...
def __int__(self) -> int: ...
def __abs__(self) -> int: ...
def __hash__(self) -> int: ...
def __bool__(self) -> bool: ...
def __index__(self) -> int: ...
class float:
def __new__(cls: Type[_T], x: Union[SupportsFloat, _SupportsIndex, str, bytes, bytearray] = ...) -> _T: ...
def as_integer_ratio(self) -> Tuple[int, int]: ...
def hex(self) -> str: ...
def is_integer(self) -> bool: ...
@classmethod
def fromhex(cls, __s: str) -> float: ...
@property
def real(self) -> float: ...
@property
def imag(self) -> float: ...
def conjugate(self) -> float: ...
def __add__(self, x: float) -> float: ...
def __sub__(self, x: float) -> float: ...
def __mul__(self, x: float) -> float: ...
def __floordiv__(self, x: float) -> float: ...
def __truediv__(self, x: float) -> float: ...
def __mod__(self, x: float) -> float: ...
def __divmod__(self, x: float) -> Tuple[float, float]: ...
def __pow__(
self, x: float, mod: None = ...
) -> float: ... # In Python 3, returns complex if self is negative and x is not whole
def __radd__(self, x: float) -> float: ...
def __rsub__(self, x: float) -> float: ...
def __rmul__(self, x: float) -> float: ...
def __rfloordiv__(self, x: float) -> float: ...
def __rtruediv__(self, x: float) -> float: ...
def __rmod__(self, x: float) -> float: ...
def __rdivmod__(self, x: float) -> Tuple[float, float]: ...
def __rpow__(self, x: float, mod: None = ...) -> float: ...
def __getnewargs__(self) -> Tuple[float]: ...
def __trunc__(self) -> int: ...
if sys.version_info >= (3, 9):
def __ceil__(self) -> int: ...
def __floor__(self) -> int: ...
@overload
def __round__(self, ndigits: None = ...) -> int: ...
@overload
def __round__(self, ndigits: int) -> float: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: float) -> bool: ...
def __le__(self, x: float) -> bool: ...
def __gt__(self, x: float) -> bool: ...
def __ge__(self, x: float) -> bool: ...
def __neg__(self) -> float: ...
def __pos__(self) -> float: ...
def __str__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __abs__(self) -> float: ...
def __hash__(self) -> int: ...
def __bool__(self) -> bool: ...
class complex:
@overload
def __new__(cls: Type[_T], real: float = ..., imag: float = ...) -> _T: ...
@overload
def __new__(cls: Type[_T], real: Union[str, SupportsComplex, _SupportsIndex]) -> _T: ...
@property
def real(self) -> float: ...
@property
def imag(self) -> float: ...
def conjugate(self) -> complex: ...
def __add__(self, x: complex) -> complex: ...
def __sub__(self, x: complex) -> complex: ...
def __mul__(self, x: complex) -> complex: ...
def __pow__(self, x: complex, mod: None = ...) -> complex: ...
def __truediv__(self, x: complex) -> complex: ...
def __radd__(self, x: complex) -> complex: ...
def __rsub__(self, x: complex) -> complex: ...
def __rmul__(self, x: complex) -> complex: ...
def __rpow__(self, x: complex, mod: None = ...) -> complex: ...
def __rtruediv__(self, x: complex) -> complex: ...
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __neg__(self) -> complex: ...
def __pos__(self) -> complex: ...
def __str__(self) -> str: ...
def __complex__(self) -> complex: ...
def __abs__(self) -> float: ...
def __hash__(self) -> int: ...
def __bool__(self) -> bool: ...
class _FormatMapMapping(Protocol):
def __getitem__(self, __key: str) -> Any: ...
class str(Sequence[str]):
@overload
def __new__(cls: Type[_T], o: object = ...) -> _T: ...
@overload
def __new__(cls: Type[_T], o: bytes, encoding: str = ..., errors: str = ...) -> _T: ...
@overload
def __init__(self, o: object = ...) -> _T: ...
@overload
def __init__(self, o: bytes, encoding: str = ..., errors: str = ...) -> _T: ...
def capitalize(self) -> str: ...
def casefold(self) -> str: ...
def center(self, __width: int, __fillchar: str = ...) -> str: ...
def count(self, x: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def encode(self, encoding: str = ..., errors: str = ...) -> bytes: ...
def endswith(self, suffix: Union[str, Tuple[str, ...]], start: Optional[int] = ..., end: Optional[int] = ...) -> bool: ...
def expandtabs(self, tabsize: int = ...) -> str: ...
def find(self, sub: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def format(self, *args: object, **kwargs: object) -> str: ...
def format_map(self, map: _FormatMapMapping) -> str: ...
def index(self, sub: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
if sys.version_info >= (3, 7):
def isascii(self) -> bool: ...
def isdecimal(self) -> bool: ...
def isdigit(self) -> bool: ...
def isidentifier(self) -> bool: ...
def islower(self) -> bool: ...
def isnumeric(self) -> bool: ...
def isprintable(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, __iterable: Iterable[str]) -> str: ...
def ljust(self, __width: int, __fillchar: str = ...) -> str: ...
def lower(self) -> str: ...
def lstrip(self, __chars: Optional[str] = ...) -> str: ...
def partition(self, __sep: str) -> Tuple[str, str, str]: ...
def replace(self, __old: str, __new: str, __count: int = ...) -> str: ...
if sys.version_info >= (3, 9):
def removeprefix(self, __prefix: str) -> str: ...
def removesuffix(self, __suffix: str) -> str: ...
def rfind(self, sub: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def rindex(self, sub: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def rjust(self, __width: int, __fillchar: str = ...) -> str: ...
def rpartition(self, __sep: str) -> Tuple[str, str, str]: ...
def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
def rstrip(self, __chars: Optional[str] = ...) -> str: ...
def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
def splitlines(self, keepends: bool = ...) -> List[str]: ...
def startswith(self, prefix: Union[str, Tuple[str, ...]], start: Optional[int] = ..., end: Optional[int] = ...) -> bool: ...
def strip(self, __chars: Optional[str] = ...) -> str: ...
def swapcase(self) -> str: ...
def title(self) -> str: ...
def translate(self, __table: Union[Mapping[int, Union[int, str, None]], Sequence[Union[int, str, None]]]) -> str: ...
def upper(self) -> str: ...
def zfill(self, __width: int) -> str: ...
@staticmethod
@overload
def maketrans(__x: Union[Dict[int, _T], Dict[str, _T], Dict[Union[str, int], _T]]) -> Dict[int, _T]: ...
@staticmethod
@overload
def maketrans(__x: str, __y: str, __z: Optional[str] = ...) -> Dict[int, Union[int, None]]: ...
def __add__(self, s: str) -> str: ...
# Incompatible with Sequence.__contains__
def __contains__(self, o: str) -> bool: ... # type: ignore
def __eq__(self, x: object) -> bool: ...
def __ge__(self, x: str) -> bool: ...
def __getitem__(self, i: Union[int, slice]) -> str: ...
def __gt__(self, x: str) -> bool: ...
def __hash__(self) -> int: ...
def __iter__(self) -> Iterator[str]: ...
def __le__(self, x: str) -> bool: ...
def __len__(self) -> int: ...
def __lt__(self, x: str) -> bool: ...
def __mod__(self, x: Any) -> str: ...
def __mul__(self, n: int) -> str: ...
def __ne__(self, x: object) -> bool: ...
def __repr__(self) -> str: ...
def __rmul__(self, n: int) -> str: ...
def __str__(self) -> str: ...
def __getnewargs__(self) -> Tuple[str]: ...
class bytes(ByteString):
@overload
def __new__(cls: Type[_T], ints: Iterable[int]) -> _T: ...
@overload
def __new__(cls: Type[_T], string: str, encoding: str, errors: str = ...) -> _T: ...
@overload
def __new__(cls: Type[_T], length: int) -> _T: ...
@overload
def __new__(cls: Type[_T]) -> _T: ...
@overload
def __new__(cls: Type[_T], o: SupportsBytes) -> _T: ...
def capitalize(self) -> bytes: ...
def center(self, __width: int, __fillchar: bytes = ...) -> bytes: ...
def count(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
def decode(self, encoding: str = ..., errors: str = ...) -> str: ...
def endswith(self, suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ...
def expandtabs(self, tabsize: int = ...) -> bytes: ...
def find(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
if sys.version_info >= (3, 8):
def hex(self, sep: Union[str, bytes] = ..., bytes_per_sep: int = ...) -> str: ...
else:
def hex(self) -> str: ...
def index(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
if sys.version_info >= (3, 7):
def isascii(self) -> bool: ...
def isdigit(self) -> bool: ...
def islower(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, __iterable_of_bytes: Iterable[Union[ByteString, memoryview]]) -> bytes: ...
def ljust(self, __width: int, __fillchar: bytes = ...) -> bytes: ...
def lower(self) -> bytes: ...
def lstrip(self, __bytes: Optional[bytes] = ...) -> bytes: ...
def partition(self, __sep: bytes) -> Tuple[bytes, bytes, bytes]: ...
def replace(self, __old: bytes, __new: bytes, __count: int = ...) -> bytes: ...
if sys.version_info >= (3, 9):
def removeprefix(self, __prefix: bytes) -> bytes: ...
def removesuffix(self, __suffix: bytes) -> bytes: ...
def rfind(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
def rindex(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
def rjust(self, __width: int, __fillchar: bytes = ...) -> bytes: ...
def rpartition(self, __sep: bytes) -> Tuple[bytes, bytes, bytes]: ...
def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ...
def rstrip(self, __bytes: Optional[bytes] = ...) -> bytes: ...
def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ...
def splitlines(self, keepends: bool = ...) -> List[bytes]: ...
def startswith(
self, prefix: Union[bytes, Tuple[bytes, ...]], start: Optional[int] = ..., end: Optional[int] = ...
) -> bool: ...
def strip(self, __bytes: Optional[bytes] = ...) -> bytes: ...
def swapcase(self) -> bytes: ...
def title(self) -> bytes: ...
def translate(self, __table: Optional[bytes], delete: bytes = ...) -> bytes: ...
def upper(self) -> bytes: ...
def zfill(self, __width: int) -> bytes: ...
@classmethod
def fromhex(cls, __s: str) -> bytes: ...
@classmethod
def maketrans(cls, frm: bytes, to: bytes) -> bytes: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[int]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __hash__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> bytes: ...
def __add__(self, s: bytes) -> bytes: ...
def __mul__(self, n: int) -> bytes: ...
def __rmul__(self, n: int) -> bytes: ...
def __mod__(self, value: Any) -> bytes: ...
# Incompatible with Sequence.__contains__
def __contains__(self, o: Union[int, bytes]) -> bool: ... # type: ignore
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: bytes) -> bool: ...
def __le__(self, x: bytes) -> bool: ...
def __gt__(self, x: bytes) -> bool: ...
def __ge__(self, x: bytes) -> bool: ...
def __getnewargs__(self) -> Tuple[bytes]: ...
class bytearray(MutableSequence[int], ByteString):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, ints: Iterable[int]) -> None: ...
@overload
def __init__(self, string: str, encoding: str, errors: str = ...) -> None: ...
@overload
def __init__(self, length: int) -> None: ...
def capitalize(self) -> bytearray: ...
def center(self, __width: int, __fillchar: bytes = ...) -> bytearray: ...
def count(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def copy(self) -> bytearray: ...
def decode(self, encoding: str = ..., errors: str = ...) -> str: ...
def endswith(self, __suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ...
def expandtabs(self, tabsize: int = ...) -> bytearray: ...
def find(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def hex(self) -> str: ...
def index(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def insert(self, __index: int, __item: int) -> None: ...
def isalnum(self) -> bool: ...
def isalpha(self) -> bool: ...
if sys.version_info >= (3, 7):
def isascii(self) -> bool: ...
def isdigit(self) -> bool: ...
def islower(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, __iterable_of_bytes: Iterable[Union[ByteString, memoryview]]) -> bytearray: ...
def ljust(self, __width: int, __fillchar: bytes = ...) -> bytearray: ...
def lower(self) -> bytearray: ...
def lstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ...
def partition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ...
if sys.version_info >= (3, 9):
def removeprefix(self, __prefix: bytes) -> bytearray: ...
def removesuffix(self, __suffix: bytes) -> bytearray: ...
def replace(self, __old: bytes, __new: bytes, __count: int = ...) -> bytearray: ...
def rfind(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def rindex(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
def rjust(self, __width: int, __fillchar: bytes = ...) -> bytearray: ...
def rpartition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ...
def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ...
def rstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ...
def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ...
def splitlines(self, keepends: bool = ...) -> List[bytearray]: ...
def startswith(
self, __prefix: Union[bytes, Tuple[bytes, ...]], __start: Optional[int] = ..., __end: Optional[int] = ...
) -> bool: ...
def strip(self, __bytes: Optional[bytes] = ...) -> bytearray: ...
def swapcase(self) -> bytearray: ...
def title(self) -> bytearray: ...
def translate(self, __table: Optional[bytes], delete: bytes = ...) -> bytearray: ...
def upper(self) -> bytearray: ...
def zfill(self, __width: int) -> bytearray: ...
@classmethod
def fromhex(cls, __string: str) -> bytearray: ...
@classmethod
def maketrans(cls, __frm: bytes, __to: bytes) -> bytes: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[int]: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
__hash__: None # type: ignore
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> bytearray: ...
@overload
def __setitem__(self, i: int, x: int) -> None: ...
@overload
def __setitem__(self, s: slice, x: Union[Iterable[int], bytes]) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
def __add__(self, s: bytes) -> bytearray: ...
def __iadd__(self, s: Iterable[int]) -> bytearray: ...
def __mul__(self, n: int) -> bytearray: ...
def __rmul__(self, n: int) -> bytearray: ...
def __imul__(self, n: int) -> bytearray: ...
def __mod__(self, value: Any) -> bytes: ...
# Incompatible with Sequence.__contains__
def __contains__(self, o: Union[int, bytes]) -> bool: ... # type: ignore
def __eq__(self, x: object) -> bool: ...
def __ne__(self, x: object) -> bool: ...
def __lt__(self, x: bytes) -> bool: ...
def __le__(self, x: bytes) -> bool: ...
def __gt__(self, x: bytes) -> bool: ...
def __ge__(self, x: bytes) -> bool: ...
class memoryview(Sized, Container[int]):
format: str
itemsize: int
shape: Optional[Tuple[int, ...]]
strides: Optional[Tuple[int, ...]]
suboffsets: Optional[Tuple[int, ...]]
readonly: bool
ndim: int
obj: Union[bytes, bytearray]
c_contiguous: bool
f_contiguous: bool
contiguous: bool
nbytes: int
def __init__(self, obj: ReadableBuffer) -> None: ...
def __enter__(self) -> memoryview: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> None: ...
def cast(self, format: str, shape: Union[List[int], Tuple[int]] = ...) -> memoryview: ...
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> memoryview: ...
def __contains__(self, x: object) -> bool: ...
def __iter__(self) -> Iterator[int]: ...
def __len__(self) -> int: ...
@overload
def __setitem__(self, s: slice, o: memoryview) -> None: ...
@overload
def __setitem__(self, i: int, o: bytes) -> None: ...
@overload
def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ...
if sys.version_info >= (3, 8):
def tobytes(self, order: Optional[Literal["C", "F", "A"]] = ...) -> bytes: ...
else:
def tobytes(self) -> bytes: ...
def tolist(self) -> List[int]: ...
if sys.version_info >= (3, 8):
def toreadonly(self) -> memoryview: ...
def release(self) -> None: ...
def hex(self) -> str: ...
class bool(int):
def __new__(cls: Type[_T], __o: object = ...) -> _T: ...
def __init__(self, o: object = ...): ...
@overload
def __and__(self, x: bool) -> bool: ...
@overload
def __and__(self, x: int) -> int: ...
@overload
def __or__(self, x: bool) -> bool: ...
@overload
def __or__(self, x: int) -> int: ...
@overload
def __xor__(self, x: bool) -> bool: ...
@overload
def __xor__(self, x: int) -> int: ...
@overload
def __rand__(self, x: bool) -> bool: ...
@overload
def __rand__(self, x: int) -> int: ...
@overload
def __ror__(self, x: bool) -> bool: ...
@overload
def __ror__(self, x: int) -> int: ...
@overload
def __rxor__(self, x: bool) -> bool: ...
@overload
def __rxor__(self, x: int) -> int: ...
def __getnewargs__(self) -> Tuple[int]: ...
class slice(object):
start: Any
step: Any
stop: Any
@overload
def __init__(self, stop: Any) -> None: ...
@overload
def __init__(self, start: Any, stop: Any, step: Any = ...) -> None: ...
__hash__: None # type: ignore
def indices(self, len: int) -> Tuple[int, int, int]: ...
class tuple(Sequence[_T_co], Generic[_T_co]):
def __new__(cls: Type[_T], iterable: Iterable[_T_co] = ...) -> _T: ...
def __init__(self, iterable: Iterable[_T_co] = ...): ...
def __len__(self) -> int: ...
def __contains__(self, x: object) -> bool: ...
@overload
def __getitem__(self, x: int) -> _T_co: ...
@overload
def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ...
def __iter__(self) -> Iterator[_T_co]: ...
def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __le__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ...
def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ...
@overload
def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ...
@overload
def __add__(self, x: Tuple[Any, ...]) -> Tuple[Any, ...]: ...
def __mul__(self, n: int) -> Tuple[_T_co, ...]: ...
def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ...
def count(self, __value: Any) -> int: ...
def index(self, __value: Any, __start: int = ..., __stop: int = ...) -> int: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class list(MutableSequence[_T], Generic[_T]):
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, iterable: Iterable[_T]) -> None: ...
def clear(self) -> None: ...
def copy(self) -> List[_T]: ...
def append(self, __object: _T) -> None: ...
def extend(self, __iterable: Iterable[_T]) -> None: ...
def pop(self, __index: int = ...) -> _T: ...
def index(self, __value: _T, __start: int = ..., __stop: int = ...) -> int: ...
def count(self, __value: _T) -> int: ...
def insert(self, __index: int, __object: _T) -> None: ...
def remove(self, __value: _T) -> None: ...
def reverse(self) -> None: ...
@overload
def sort(self: List[SupportsLessThanT], *, key: None = ..., reverse: bool = ...) -> None: ...
@overload
def sort(self, *, key: Callable[[_T], SupportsLessThan], reverse: bool = ...) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
__hash__: None # type: ignore
@overload
def __getitem__(self, i: int) -> _T: ...
@overload
def __getitem__(self, s: slice) -> List[_T]: ...
@overload
def __setitem__(self, i: int, o: _T) -> None: ...
@overload
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
def __add__(self, x: List[_T]) -> List[_T]: ...
def __iadd__(self: _S, x: Iterable[_T]) -> _S: ...
def __mul__(self, n: int) -> List[_T]: ...
def __rmul__(self, n: int) -> List[_T]: ...
def __imul__(self: _S, n: int) -> _S: ...
def __contains__(self, o: object) -> bool: ...
def __reversed__(self) -> Iterator[_T]: ...
def __gt__(self, x: List[_T]) -> bool: ...
def __ge__(self, x: List[_T]) -> bool: ...
def __lt__(self, x: List[_T]) -> bool: ...
def __le__(self, x: List[_T]) -> bool: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
# NOTE: Keyword arguments are special. If they are used, _KT must include
# str, but we have no way of enforcing it here.
@overload
def __init__(self, **kwargs: _VT) -> None: ...
@overload
def __init__(self, map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ...
def clear(self) -> None: ...
def copy(self) -> Dict[_KT, _VT]: ...
def popitem(self) -> Tuple[_KT, _VT]: ...
def setdefault(self, __key: _KT, __default: _VT = ...) -> _VT: ...
@overload
def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
@overload
def update(self, **kwargs: _VT) -> None: ...
def keys(self) -> KeysView[_KT]: ...
def values(self) -> ValuesView[_VT]: ...
def items(self) -> ItemsView[_KT, _VT]: ...
@classmethod
@overload
def fromkeys(cls, __iterable: Iterable[_T]) -> Dict[_T, Any]: ...
@classmethod
@overload
def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> Dict[_T, _S]: ...
def __len__(self) -> int: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __setitem__(self, k: _KT, v: _VT) -> None: ...
def __delitem__(self, v: _KT) -> None: ...
def __iter__(self) -> Iterator[_KT]: ...
if sys.version_info >= (3, 8):
def __reversed__(self) -> Iterator[_KT]: ...
def __str__(self) -> str: ...
__hash__: None # type: ignore
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
def __or__(self, __value: Mapping[_KT, _VT]) -> Dict[_KT, _VT]: ...
def __ior__(self, __value: Mapping[_KT, _VT]) -> Dict[_KT, _VT]: ...
class set(MutableSet[_T], Generic[_T]):
def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
def add(self, element: _T) -> None: ...
def clear(self) -> None: ...
def copy(self) -> Set[_T]: ...
def difference(self, *s: Iterable[Any]) -> Set[_T]: ...
def difference_update(self, *s: Iterable[Any]) -> None: ...
def discard(self, element: _T) -> None: ...
def intersection(self, *s: Iterable[Any]) -> Set[_T]: ...
def intersection_update(self, *s: Iterable[Any]) -> None: ...
def isdisjoint(self, s: Iterable[Any]) -> bool: ...
def issubset(self, s: Iterable[Any]) -> bool: ...
def issuperset(self, s: Iterable[Any]) -> bool: ...
def pop(self) -> _T: ...
def remove(self, element: _T) -> None: ...
def symmetric_difference(self, s: Iterable[_T]) -> Set[_T]: ...
def symmetric_difference_update(self, s: Iterable[_T]) -> None: ...
def union(self, *s: Iterable[_T]) -> Set[_T]: ...
def update(self, *s: Iterable[_T]) -> None: ...
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __and__(self, s: AbstractSet[object]) -> Set[_T]: ...
def __iand__(self, s: AbstractSet[object]) -> Set[_T]: ...
def __or__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
def __ior__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
def __sub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ...
def __isub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ...
def __xor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
def __ixor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
def __le__(self, s: AbstractSet[object]) -> bool: ...
def __lt__(self, s: AbstractSet[object]) -> bool: ...
def __ge__(self, s: AbstractSet[object]) -> bool: ...
def __gt__(self, s: AbstractSet[object]) -> bool: ...
__hash__: None # type: ignore
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class frozenset(AbstractSet[_T_co], Generic[_T_co]):
def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ...
def copy(self) -> FrozenSet[_T_co]: ...
def difference(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ...
def intersection(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ...
def isdisjoint(self, s: Iterable[_T_co]) -> bool: ...
def issubset(self, s: Iterable[object]) -> bool: ...
def issuperset(self, s: Iterable[object]) -> bool: ...
def symmetric_difference(self, s: Iterable[_T_co]) -> FrozenSet[_T_co]: ...
def union(self, *s: Iterable[_T_co]) -> FrozenSet[_T_co]: ...
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[_T_co]: ...
def __str__(self) -> str: ...
def __and__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ...
def __or__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ...
def __sub__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ...
def __xor__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ...
def __le__(self, s: AbstractSet[object]) -> bool: ...
def __lt__(self, s: AbstractSet[object]) -> bool: ...
def __ge__(self, s: AbstractSet[object]) -> bool: ...
def __gt__(self, s: AbstractSet[object]) -> bool: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class enumerate(Iterator[Tuple[int, _T]], Generic[_T]):
def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ...
def __iter__(self) -> Iterator[Tuple[int, _T]]: ...
def __next__(self) -> Tuple[int, _T]: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class range(Sequence[int]):
start: int
stop: int
step: int
@overload
def __init__(self, stop: int) -> None: ...
@overload
def __init__(self, start: int, stop: int, step: int = ...) -> None: ...
def count(self, value: int) -> int: ...
def index(self, value: int) -> int: ... # type: ignore
def __len__(self) -> int: ...
def __contains__(self, o: object) -> bool: ...
def __iter__(self) -> Iterator[int]: ...
@overload
def __getitem__(self, i: int) -> int: ...
@overload
def __getitem__(self, s: slice) -> range: ...
def __repr__(self) -> str: ...
def __reversed__(self) -> Iterator[int]: ...
class property(object):
def __init__(
self,
fget: Optional[Callable[[Any], Any]] = ...,
fset: Optional[Callable[[Any, Any], None]] = ...,
fdel: Optional[Callable[[Any], None]] = ...,
doc: Optional[str] = ...,
) -> None: ...
def getter(self, fget: Callable[[Any], Any]) -> property: ...
def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
def deleter(self, fdel: Callable[[Any], None]) -> property: ...
def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ...
def __set__(self, obj: Any, value: Any) -> None: ...
def __delete__(self, obj: Any) -> None: ...
def fget(self) -> Any: ...
def fset(self, value: Any) -> None: ...
def fdel(self) -> None: ...
class _NotImplementedType(Any): # type: ignore
# A little weird, but typing the __call__ as NotImplemented makes the error message
# for NotImplemented() much better
pass
NotImplemented: _NotImplementedType
def abs(__x: SupportsAbs[_T]) -> _T: ...
def all(__iterable: Iterable[object]) -> bool: ...
def any(__iterable: Iterable[object]) -> bool: ...
def ascii(__obj: object) -> str: ...
def bin(__number: Union[int, _SupportsIndex]) -> str: ...
if sys.version_info >= (3, 7):
def breakpoint(*args: Any, **kws: Any) -> None: ...
def callable(__obj: object) -> bool: ...
def chr(__i: int) -> str: ...
# This class is to be exported as PathLike from os,
# but we define it here as _PathLike to avoid import cycle issues.
# See https://github.com/python/typeshed/pull/991#issuecomment-288160993
_AnyStr_co = TypeVar("_AnyStr_co", str, bytes, covariant=True)
@runtime_checkable
class _PathLike(Protocol[_AnyStr_co]):
def __fspath__(self) -> _AnyStr_co: ...
if sys.version_info >= (3, 8):
def compile(
source: Union[str, bytes, mod, AST],
filename: Union[str, bytes, _PathLike[Any]],
mode: str,
flags: int = ...,
dont_inherit: int = ...,
optimize: int = ...,
*,
_feature_version: int = ...,
) -> Any: ...
else:
def compile(
source: Union[str, bytes, mod, AST],
filename: Union[str, bytes, _PathLike[Any]],
mode: str,
flags: int = ...,
dont_inherit: int = ...,
optimize: int = ...,
) -> Any: ...
def copyright() -> None: ...
def credits() -> None: ...
def delattr(__obj: Any, __name: str) -> None: ...
def dir(__o: object = ...) -> List[str]: ...
_N2 = TypeVar("_N2", int, float)
def divmod(__x: _N2, __y: _N2) -> Tuple[_N2, _N2]: ...
def eval(
__source: Union[str, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ...
) -> Any: ...
def exec(
__source: Union[str, bytes, CodeType],
__globals: Optional[Dict[str, Any]] = ...,
__locals: Optional[Mapping[str, Any]] = ...,
) -> Any: ...
def exit(code: object = ...) -> NoReturn: ...
@overload
def filter(__function: None, __iterable: Iterable[Optional[_T]]) -> Iterator[_T]: ...
@overload
def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> Iterator[_T]: ...
def format(__value: object, __format_spec: str = ...) -> str: ... # TODO unicode
def getattr(__o: Any, name: str, __default: Any = ...) -> Any: ...
def globals() -> Dict[str, Any]: ...
def hasattr(__obj: Any, __name: str) -> bool: ...
def hash(__obj: object) -> int: ...
def help(*args: Any, **kwds: Any) -> None: ...
def hex(__number: Union[int, _SupportsIndex]) -> str: ...
def id(__obj: object) -> int: ...
def input(__prompt: Any = ...) -> str: ...
@overload
def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ...
@overload
def iter(__function: Callable[[], Optional[_T]], __sentinel: None) -> Iterator[_T]: ...
@overload
def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ...
def isinstance(__obj: object, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ...
def issubclass(__cls: type, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ...
def len(__obj: Sized) -> int: ...
def license() -> None: ...
def locals() -> Dict[str, Any]: ...
@overload
def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> Iterator[_S]: ...
@overload
def map(__func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> Iterator[_S]: ...
@overload
def map(
__func: Callable[[_T1, _T2, _T3], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]
) -> Iterator[_S]: ...
@overload
def map(
__func: Callable[[_T1, _T2, _T3, _T4], _S],
__iter1: Iterable[_T1],
__iter2: Iterable[_T2],
__iter3: Iterable[_T3],
__iter4: Iterable[_T4],
) -> Iterator[_S]: ...
@overload
def map(
__func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],
__iter1: Iterable[_T1],
__iter2: Iterable[_T2],
__iter3: Iterable[_T3],
__iter4: Iterable[_T4],
__iter5: Iterable[_T5],
) -> Iterator[_S]: ...
@overload
def map(
__func: Callable[..., _S],
__iter1: Iterable[Any],
__iter2: Iterable[Any],
__iter3: Iterable[Any],
__iter4: Iterable[Any],
__iter5: Iterable[Any],
__iter6: Iterable[Any],
*iterables: Iterable[Any],
) -> Iterator[_S]: ...
@overload
def max(
__arg1: SupportsLessThanT, __arg2: SupportsLessThanT, *_args: SupportsLessThanT, key: None = ...
) -> SupportsLessThanT: ...
@overload
def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsLessThanT]) -> _T: ...
@overload
def max(__iterable: Iterable[SupportsLessThanT], *, key: None = ...) -> SupportsLessThanT: ...
@overload
def max(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsLessThanT]) -> _T: ...
@overload
def max(__iterable: Iterable[SupportsLessThanT], *, key: None = ..., default: _T) -> Union[SupportsLessThanT, _T]: ...
@overload
def max(__iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsLessThanT], default: _T2) -> Union[_T1, _T2]: ...
@overload
def min(
__arg1: SupportsLessThanT, __arg2: SupportsLessThanT, *_args: SupportsLessThanT, key: None = ...
) -> SupportsLessThanT: ...
@overload
def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsLessThanT]) -> _T: ...
@overload
def min(__iterable: Iterable[SupportsLessThanT], *, key: None = ...) -> SupportsLessThanT: ...
@overload
def min(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsLessThanT]) -> _T: ...
@overload
def min(__iterable: Iterable[SupportsLessThanT], *, key: None = ..., default: _T) -> Union[SupportsLessThanT, _T]: ...
@overload
def min(__iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsLessThanT], default: _T2) -> Union[_T1, _T2]: ...
@overload
def next(__i: Iterator[_T]) -> _T: ...
@overload
def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ...
def oct(__number: Union[int, _SupportsIndex]) -> str: ...
_OpenFile = Union[AnyPath, int]
_Opener = Callable[[str, int], int]
# Text mode: always returns a TextIOWrapper
@overload
def open(
file: _OpenFile,
mode: OpenTextMode = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
newline: Optional[str] = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
) -> TextIOWrapper: ...
# Unbuffered binary mode: returns a FileIO
@overload
def open(
file: _OpenFile,
mode: OpenBinaryMode,
buffering: Literal[0],
encoding: None = ...,
errors: None = ...,
newline: None = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
) -> FileIO: ...
# Buffering is on: return BufferedRandom, BufferedReader, or BufferedWriter
@overload
def open(
file: _OpenFile,
mode: OpenBinaryModeUpdating,
buffering: Literal[-1, 1] = ...,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
) -> BufferedRandom: ...
@overload
def open(
file: _OpenFile,
mode: OpenBinaryModeWriting,
buffering: Literal[-1, 1] = ...,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
) -> BufferedWriter: ...
@overload
def open(
file: _OpenFile,
mode: OpenBinaryModeReading,
buffering: Literal[-1, 1] = ...,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
) -> BufferedReader: ...
# Buffering cannot be determined: fall back to BinaryIO
@overload
def open(
file: _OpenFile,
mode: OpenBinaryMode,
buffering: int,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
) -> BinaryIO: ...
# Fallback if mode is not specified
@overload
def open(
file: _OpenFile,
mode: str,
buffering: int = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
newline: Optional[str] = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
) -> IO[Any]: ...
def ord(__c: Union[str, bytes]) -> int: ...
def print(
*values: object,
sep: Optional[str] = ...,
end: Optional[str] = ...,
file: Optional[SupportsWrite[str]] = ...,
flush: bool = ...,
) -> None: ...
_E = TypeVar("_E", contravariant=True)
_M = TypeVar("_M", contravariant=True)
class _SupportsPow2(Protocol[_E, _T_co]):
def __pow__(self, __other: _E) -> _T_co: ...
class _SupportsPow3(Protocol[_E, _M, _T_co]):
def __pow__(self, __other: _E, __modulo: _M) -> _T_co: ...
if sys.version_info >= (3, 8):
@overload
def pow(base: int, exp: int, mod: None = ...) -> Any: ... # returns int or float depending on whether exp is non-negative
@overload
def pow(base: int, exp: int, mod: int) -> int: ...
@overload
def pow(base: float, exp: float, mod: None = ...) -> float: ...
@overload
def pow(base: _SupportsPow2[_E, _T_co], exp: _E) -> _T_co: ...
@overload
def pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co: ...
else:
@overload
def pow(
__base: int, __exp: int, __mod: None = ...
) -> Any: ... # returns int or float depending on whether exp is non-negative
@overload
def pow(__base: int, __exp: int, __mod: int) -> int: ...
@overload
def pow(__base: float, __exp: float, __mod: None = ...) -> float: ...
@overload
def pow(__base: _SupportsPow2[_E, _T_co], __exp: _E) -> _T_co: ...
@overload
def pow(__base: _SupportsPow3[_E, _M, _T_co], __exp: _E, __mod: _M) -> _T_co: ...
def quit(code: object = ...) -> NoReturn: ...
@overload
def reversed(__sequence: Sequence[_T]) -> Iterator[_T]: ...
@overload
def reversed(__sequence: Reversible[_T]) -> Iterator[_T]: ...
def repr(__obj: object) -> str: ...
@overload
def round(number: float) -> int: ...
@overload
def round(number: float, ndigits: None) -> int: ...
@overload
def round(number: float, ndigits: int) -> float: ...
@overload
def round(number: SupportsRound[_T]) -> int: ...
@overload
def round(number: SupportsRound[_T], ndigits: None) -> int: ...
@overload
def round(number: SupportsRound[_T], ndigits: int) -> _T: ...
def setattr(__obj: Any, __name: str, __value: Any) -> None: ...
@overload
def sorted(__iterable: Iterable[SupportsLessThanT], *, key: None = ..., reverse: bool = ...) -> List[SupportsLessThanT]: ...
@overload
def sorted(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsLessThan], reverse: bool = ...) -> List[_T]: ...
if sys.version_info >= (3, 8):
@overload
def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ...
@overload
def sum(__iterable: Iterable[_T], start: _S) -> Union[_T, _S]: ...
else:
@overload
def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ...
@overload
def sum(__iterable: Iterable[_T], __start: _S) -> Union[_T, _S]: ...
def vars(__object: Any = ...) -> Dict[str, Any]: ...
@overload
def zip(__iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...
@overload
def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...
@overload
def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ...
@overload
def zip(
__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4]
) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ...
@overload
def zip(
__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5]
) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
@overload
def zip(
__iter1: Iterable[Any],
__iter2: Iterable[Any],
__iter3: Iterable[Any],
__iter4: Iterable[Any],
__iter5: Iterable[Any],
__iter6: Iterable[Any],
*iterables: Iterable[Any],
) -> Iterator[Tuple[Any, ...]]: ...
def __import__(
name: str,
globals: Optional[Mapping[str, Any]] = ...,
locals: Optional[Mapping[str, Any]] = ...,
fromlist: Sequence[str] = ...,
level: int = ...,
) -> Any: ...
# Actually the type of Ellipsis is <type 'ellipsis'>, but since it's
# not exposed anywhere under that name, we make it private here.
class ellipsis: ...
Ellipsis: ellipsis
class BaseException(object):
args: Tuple[Any, ...]
__cause__: Optional[BaseException]
__context__: Optional[BaseException]
__suppress_context__: bool
__traceback__: Optional[TracebackType]
def __init__(self, *args: object) -> None: ...
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def with_traceback(self: _TBE, tb: Optional[TracebackType]) -> _TBE: ...
class GeneratorExit(BaseException): ...
class KeyboardInterrupt(BaseException): ...
class SystemExit(BaseException):
code: int
class Exception(BaseException): ...
class StopIteration(Exception):
value: Any
_StandardError = Exception
class OSError(Exception):
errno: int
strerror: str
# filename, filename2 are actually Union[str, bytes, None]
filename: Any
filename2: Any
EnvironmentError = OSError
IOError = OSError
class ArithmeticError(_StandardError): ...
class AssertionError(_StandardError): ...
class AttributeError(_StandardError): ...
class BufferError(_StandardError): ...
class EOFError(_StandardError): ...
class ImportError(_StandardError):
def __init__(self, *args: object, name: Optional[str] = ..., path: Optional[str] = ...) -> None: ...
name: Optional[str]
path: Optional[str]
class LookupError(_StandardError): ...
class MemoryError(_StandardError): ...
class NameError(_StandardError): ...
class ReferenceError(_StandardError): ...
class RuntimeError(_StandardError): ...
class StopAsyncIteration(Exception):
value: Any
class SyntaxError(_StandardError):
msg: str
lineno: Optional[int]
offset: Optional[int]
text: Optional[str]
filename: Optional[str]
class SystemError(_StandardError): ...
class TypeError(_StandardError): ...
class ValueError(_StandardError): ...
class FloatingPointError(ArithmeticError): ...
class OverflowError(ArithmeticError): ...
class ZeroDivisionError(ArithmeticError): ...
class ModuleNotFoundError(ImportError): ...
class IndexError(LookupError): ...
class KeyError(LookupError): ...
class UnboundLocalError(NameError): ...
class WindowsError(OSError):
winerror: int
class BlockingIOError(OSError):
characters_written: int
class ChildProcessError(OSError): ...
class ConnectionError(OSError): ...
class BrokenPipeError(ConnectionError): ...
class ConnectionAbortedError(ConnectionError): ...
class ConnectionRefusedError(ConnectionError): ...
class ConnectionResetError(ConnectionError): ...
class FileExistsError(OSError): ...
class FileNotFoundError(OSError): ...
class InterruptedError(OSError): ...
class IsADirectoryError(OSError): ...
class NotADirectoryError(OSError): ...
class PermissionError(OSError): ...
class ProcessLookupError(OSError): ...
class TimeoutError(OSError): ...
class NotImplementedError(RuntimeError): ...
class RecursionError(RuntimeError): ...
class IndentationError(SyntaxError): ...
class TabError(IndentationError): ...
class UnicodeError(ValueError): ...
class UnicodeDecodeError(UnicodeError):
encoding: str
object: bytes
start: int
end: int
reason: str
def __init__(self, __encoding: str, __object: bytes, __start: int, __end: int, __reason: str) -> None: ...
class UnicodeEncodeError(UnicodeError):
encoding: str
object: str
start: int
end: int
reason: str
def __init__(self, __encoding: str, __object: str, __start: int, __end: int, __reason: str) -> None: ...
class UnicodeTranslateError(UnicodeError): ...
class Warning(Exception): ...
class UserWarning(Warning): ...
class DeprecationWarning(Warning): ...
class SyntaxWarning(Warning): ...
class RuntimeWarning(Warning): ...
class FutureWarning(Warning): ...
class PendingDeprecationWarning(Warning): ...
class ImportWarning(Warning): ...
class UnicodeWarning(Warning): ...
class BytesWarning(Warning): ...
class ResourceWarning(Warning): ...
| 54,524 | Python | .py | 1,311 | 37.28833 | 129 | 0.558424 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,266 | faulthandler.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/faulthandler.pyi | import sys
from _typeshed 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: ...
| 644 | Python | .py | 11 | 56.636364 | 123 | 0.635499 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,267 | sys.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/sys.pyi | import sys
from builtins import object as _object
from importlib.abc import MetaPathFinder, PathEntryFinder
from types import FrameType, ModuleType, TracebackType
from typing import (
Any,
AsyncGenerator,
Callable,
Dict,
List,
NoReturn,
Optional,
Sequence,
TextIO,
Tuple,
Type,
TypeVar,
Union,
overload,
)
_T = TypeVar("_T")
# The following type alias are stub-only and do not exist during runtime
_ExcInfo = Tuple[Type[BaseException], BaseException, TracebackType]
_OptExcInfo = Union[_ExcInfo, Tuple[None, None, None]]
# ----- sys variables -----
if sys.platform != "win32":
abiflags: str
argv: List[str]
base_exec_prefix: str
base_prefix: str
byteorder: str
builtin_module_names: Sequence[str] # actually a tuple of strings
copyright: str
if sys.platform == "win32":
dllhandle: int
dont_write_bytecode: bool
displayhook: Callable[[object], Any]
excepthook: Callable[[Type[BaseException], BaseException, TracebackType], Any]
exec_prefix: str
executable: str
float_repr_style: str
hexversion: int
last_type: Optional[Type[BaseException]]
last_value: Optional[BaseException]
last_traceback: Optional[TracebackType]
maxsize: int
maxunicode: int
meta_path: List[MetaPathFinder]
modules: Dict[str, ModuleType]
path: List[str]
path_hooks: List[Any] # TODO precise type; function, path to finder
path_importer_cache: Dict[str, Optional[PathEntryFinder]]
platform: str
if sys.version_info >= (3, 9):
platlibdir: str
prefix: str
if sys.version_info >= (3, 8):
pycache_prefix: Optional[str]
ps1: str
ps2: str
stdin: TextIO
stdout: TextIO
stderr: TextIO
__stdin__: TextIO
__stdout__: TextIO
__stderr__: TextIO
tracebacklimit: int
version: str
api_version: int
warnoptions: Any
# Each entry is a tuple of the form (action, message, category, module,
# lineno)
if sys.platform == "win32":
winver: str
_xoptions: Dict[Any, Any]
flags: _flags
class _flags:
debug: int
division_warning: int
inspect: int
interactive: int
optimize: int
dont_write_bytecode: int
no_user_site: int
no_site: int
ignore_environment: int
verbose: int
bytes_warning: int
quiet: int
hash_randomization: int
if sys.version_info >= (3, 7):
dev_mode: int
utf8_mode: int
float_info: _float_info
class _float_info:
epsilon: float # DBL_EPSILON
dig: int # DBL_DIG
mant_dig: int # DBL_MANT_DIG
max: float # DBL_MAX
max_exp: int # DBL_MAX_EXP
max_10_exp: int # DBL_MAX_10_EXP
min: float # DBL_MIN
min_exp: int # DBL_MIN_EXP
min_10_exp: int # DBL_MIN_10_EXP
radix: int # FLT_RADIX
rounds: int # FLT_ROUNDS
hash_info: _hash_info
class _hash_info:
width: int
modulus: int
inf: int
nan: int
imag: int
implementation: _implementation
class _implementation:
name: str
version: _version_info
hexversion: int
cache_tag: str
int_info: _int_info
class _int_info:
bits_per_digit: int
sizeof_digit: int
class _version_info(Tuple[int, int, int, str, int]):
major: int
minor: int
micro: int
releaselevel: str
serial: int
version_info: _version_info
def call_tracing(__func: Callable[..., _T], __args: Any) -> _T: ...
def _clear_type_cache() -> None: ...
def _current_frames() -> Dict[int, Any]: ...
def _debugmallocstats() -> None: ...
def __displayhook__(value: object) -> None: ...
def __excepthook__(type_: Type[BaseException], value: BaseException, traceback: TracebackType) -> None: ...
def exc_info() -> _OptExcInfo: ...
# sys.exit() accepts an optional argument of anything printable
def exit(__status: object = ...) -> NoReturn: ...
def getdefaultencoding() -> str: ...
if sys.platform != "win32":
def getdlopenflags() -> int: ...
def getfilesystemencoding() -> str: ...
def getfilesystemencodeerrors() -> str: ...
def getrefcount(__object: Any) -> int: ...
def getrecursionlimit() -> int: ...
@overload
def getsizeof(obj: object) -> int: ...
@overload
def getsizeof(obj: object, default: int) -> int: ...
def getswitchinterval() -> float: ...
def _getframe(__depth: int = ...) -> FrameType: ...
_ProfileFunc = Callable[[FrameType, str, Any], Any]
def getprofile() -> Optional[_ProfileFunc]: ...
def setprofile(profilefunc: Optional[_ProfileFunc]) -> None: ...
_TraceFunc = Callable[[FrameType, str, Any], Optional[Callable[[FrameType, str, Any], Any]]]
def gettrace() -> Optional[_TraceFunc]: ...
def settrace(tracefunc: Optional[_TraceFunc]) -> None: ...
class _WinVersion(Tuple[int, int, int, int, str, int, int, int, int, Tuple[int, int, int]]):
major: int
minor: int
build: int
platform: int
service_pack: str
service_pack_minor: int
service_pack_major: int
suite_mast: int
product_type: int
platform_version: Tuple[int, int, int]
if sys.platform == "win32":
def getwindowsversion() -> _WinVersion: ...
def intern(__string: str) -> str: ...
def is_finalizing() -> bool: ...
if sys.version_info >= (3, 7):
__breakpointhook__: Any # contains the original value of breakpointhook
def breakpointhook(*args: Any, **kwargs: Any) -> Any: ...
if sys.platform != "win32":
def setdlopenflags(__flags: int) -> None: ...
def setrecursionlimit(__limit: int) -> None: ...
def setswitchinterval(__interval: float) -> None: ...
def gettotalrefcount() -> int: ... # Debug builds only
if sys.version_info < (3, 9):
def getcheckinterval() -> int: ... # deprecated
def setcheckinterval(__n: int) -> None: ... # deprecated
if sys.version_info >= (3, 8):
# not exported by sys
class UnraisableHookArgs:
exc_type: Type[BaseException]
exc_value: Optional[BaseException]
exc_traceback: Optional[TracebackType]
err_msg: Optional[str]
object: Optional[_object]
unraisablehook: Callable[[UnraisableHookArgs], Any]
def addaudithook(hook: Callable[[str, Tuple[Any, ...]], Any]) -> None: ...
def audit(__event: str, *args: Any) -> None: ...
_AsyncgenHook = Optional[Callable[[AsyncGenerator[Any, Any]], None]]
class _asyncgen_hooks(Tuple[_AsyncgenHook, _AsyncgenHook]):
firstiter: _AsyncgenHook
finalizer: _AsyncgenHook
def get_asyncgen_hooks() -> _asyncgen_hooks: ...
def set_asyncgen_hooks(firstiter: _AsyncgenHook = ..., finalizer: _AsyncgenHook = ...) -> None: ...
| 6,337 | Python | .py | 201 | 28.40796 | 107 | 0.68748 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,268 | queue.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/queue.pyi | import sys
from threading import Condition, Lock
from typing import Any, Generic, Optional, TypeVar
if sys.version_info >= (3, 9):
from types import GenericAlias
_T = TypeVar("_T")
class Empty(Exception): ...
class Full(Exception): ...
class Queue(Generic[_T]):
maxsize: int
mutex: Lock # undocumented
not_empty: Condition # undocumented
not_full: Condition # undocumented
all_tasks_done: Condition # undocumented
unfinished_tasks: int # undocumented
queue: Any # undocumented
def __init__(self, maxsize: int = ...) -> None: ...
def _init(self, maxsize: int) -> None: ...
def empty(self) -> bool: ...
def full(self) -> bool: ...
def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
def get_nowait(self) -> _T: ...
def _get(self) -> _T: ...
def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
def put_nowait(self, item: _T) -> None: ...
def _put(self, item: _T) -> None: ...
def join(self) -> None: ...
def qsize(self) -> int: ...
def _qsize(self) -> int: ...
def task_done(self) -> None: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class PriorityQueue(Queue[_T]): ...
class LifoQueue(Queue[_T]): ...
if sys.version_info >= (3, 7):
class SimpleQueue(Generic[_T]):
def __init__(self) -> None: ...
def empty(self) -> bool: ...
def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
def get_nowait(self) -> _T: ...
def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
def put_nowait(self, item: _T) -> None: ...
def qsize(self) -> int: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
| 1,884 | Python | .py | 45 | 36.711111 | 95 | 0.56714 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,269 | _sitebuiltins.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_sitebuiltins.pyi | from typing import ClassVar, Iterable, NoReturn, Optional
from typing_extensions import Literal
class Quitter:
name: str
eof: str
def __init__(self, name: str, eof: str) -> None: ...
def __call__(self, code: Optional[int] = ...) -> NoReturn: ...
class _Printer:
MAXLINES: ClassVar[Literal[23]]
def __init__(self, name: str, data: str, files: Iterable[str] = ..., dirs: Iterable[str] = ...) -> None: ...
def __call__(self) -> None: ...
class _Helper:
def __call__(self, request: object) -> None: ...
| 534 | Python | .py | 13 | 37.384615 | 112 | 0.61583 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,270 | _tracemalloc.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_tracemalloc.pyi | import sys
from tracemalloc import _FrameTupleT, _TraceTupleT
from typing import Optional, Sequence, Tuple
def _get_object_traceback(__obj: object) -> Optional[Sequence[_FrameTupleT]]: ...
def _get_traces() -> Sequence[_TraceTupleT]: ...
def clear_traces() -> None: ...
def get_traceback_limit() -> int: ...
def get_traced_memory() -> Tuple[int, int]: ...
def get_tracemalloc_memory() -> int: ...
def is_tracing() -> bool: ...
if sys.version_info >= (3, 9):
def reset_peak() -> None: ...
def start(__nframe: int = ...) -> None: ...
def stop() -> None: ...
| 563 | Python | .py | 14 | 38.714286 | 81 | 0.650183 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,271 | resource.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/resource.pyi | import sys
from typing import NamedTuple, Tuple, overload
RLIMIT_AS: int
RLIMIT_CORE: int
RLIMIT_CPU: int
RLIMIT_DATA: int
RLIMIT_FSIZE: int
RLIMIT_MEMLOCK: int
RLIMIT_NOFILE: int
RLIMIT_NPROC: int
RLIMIT_RSS: int
RLIMIT_STACK: int
RLIM_INFINITY: int
RUSAGE_CHILDREN: int
RUSAGE_SELF: int
if sys.platform == "linux":
RLIMIT_MSGQUEUE: int
RLIMIT_NICE: int
RLIMIT_OFILE: int
RLIMIT_RTPRIO: int
RLIMIT_RTTIME: int
RLIMIT_SIGPENDING: int
RUSAGE_THREAD: int
class _RUsage(NamedTuple):
ru_utime: float
ru_stime: float
ru_maxrss: int
ru_ixrss: int
ru_idrss: int
ru_isrss: int
ru_minflt: int
ru_majflt: int
ru_nswap: int
ru_inblock: int
ru_oublock: int
ru_msgsnd: int
ru_msgrcv: int
ru_nsignals: int
ru_nvcsw: int
ru_nivcsw: int
def getpagesize() -> int: ...
def getrlimit(__resource: int) -> Tuple[int, int]: ...
def getrusage(__who: int) -> _RUsage: ...
def setrlimit(__resource: int, __limits: Tuple[int, int]) -> None: ...
if sys.platform == "linux":
@overload
def prlimit(pid: int, resource: int, limits: Tuple[int, int]) -> Tuple[int, int]: ...
@overload
def prlimit(pid: int, resource: int) -> Tuple[int, int]: ...
error = OSError
| 1,243 | Python | .py | 50 | 21.6 | 89 | 0.680976 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,272 | getopt.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/getopt.pyi | from typing import List, Tuple
def getopt(args: List[str], shortopts: str, longopts: List[str] = ...) -> Tuple[List[Tuple[str, str]], List[str]]: ...
def gnu_getopt(args: List[str], shortopts: str, longopts: List[str] = ...) -> Tuple[List[Tuple[str, str]], List[str]]: ...
class GetoptError(Exception):
msg: str
opt: str
error = GetoptError
| 352 | Python | .py | 7 | 47.714286 | 122 | 0.669591 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,273 | random.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/random.pyi | import _random
import sys
from typing import AbstractSet, Any, Callable, Iterable, List, MutableSequence, Optional, Sequence, Tuple, TypeVar, Union
_T = TypeVar("_T")
class Random(_random.Random):
def __init__(self, x: Any = ...) -> None: ...
def seed(self, a: Any = ..., version: int = ...) -> None: ...
def getstate(self) -> Tuple[Any, ...]: ...
def setstate(self, state: Tuple[Any, ...]) -> None: ...
def getrandbits(self, __k: int) -> int: ...
def randrange(self, start: int, stop: Optional[int] = ..., step: int = ...) -> int: ...
def randint(self, a: int, b: int) -> int: ...
if sys.version_info >= (3, 9):
def randbytes(self, n: int) -> bytes: ...
def choice(self, seq: Sequence[_T]) -> _T: ...
def choices(
self,
population: Sequence[_T],
weights: Optional[Sequence[float]] = ...,
*,
cum_weights: Optional[Sequence[float]] = ...,
k: int = ...,
) -> List[_T]: ...
def shuffle(self, x: MutableSequence[Any], random: Optional[Callable[[], float]] = ...) -> None: ...
if sys.version_info >= (3, 9):
def sample(
self, population: Union[Sequence[_T], AbstractSet[_T]], k: int, *, counts: Optional[Iterable[_T]] = ...
) -> List[_T]: ...
else:
def sample(self, population: Union[Sequence[_T], AbstractSet[_T]], k: int) -> List[_T]: ...
def random(self) -> float: ...
def uniform(self, a: float, b: float) -> float: ...
def triangular(self, low: float = ..., high: float = ..., mode: Optional[float] = ...) -> float: ...
def betavariate(self, alpha: float, beta: float) -> float: ...
def expovariate(self, lambd: float) -> float: ...
def gammavariate(self, alpha: float, beta: float) -> float: ...
def gauss(self, mu: float, sigma: float) -> float: ...
def lognormvariate(self, mu: float, sigma: float) -> float: ...
def normalvariate(self, mu: float, sigma: float) -> float: ...
def vonmisesvariate(self, mu: float, kappa: float) -> float: ...
def paretovariate(self, alpha: float) -> float: ...
def weibullvariate(self, alpha: float, beta: float) -> float: ...
# SystemRandom is not implemented for all OS's; good on Windows & Linux
class SystemRandom(Random): ...
# ----- random function stubs -----
def seed(a: Any = ..., version: int = ...) -> None: ...
def getstate() -> object: ...
def setstate(state: object) -> None: ...
def getrandbits(__k: int) -> int: ...
def randrange(start: int, stop: Union[None, int] = ..., step: int = ...) -> int: ...
def randint(a: int, b: int) -> int: ...
if sys.version_info >= (3, 9):
def randbytes(n: int) -> bytes: ...
def choice(seq: Sequence[_T]) -> _T: ...
def choices(
population: Sequence[_T],
weights: Optional[Sequence[float]] = ...,
*,
cum_weights: Optional[Sequence[float]] = ...,
k: int = ...,
) -> List[_T]: ...
def shuffle(x: MutableSequence[Any], random: Optional[Callable[[], float]] = ...) -> None: ...
if sys.version_info >= (3, 9):
def sample(population: Union[Sequence[_T], AbstractSet[_T]], k: int, *, counts: Optional[Iterable[_T]] = ...) -> List[_T]: ...
else:
def sample(population: Union[Sequence[_T], AbstractSet[_T]], k: int) -> List[_T]: ...
def random() -> float: ...
def uniform(a: float, b: float) -> float: ...
def triangular(low: float = ..., high: float = ..., mode: Optional[float] = ...) -> float: ...
def betavariate(alpha: float, beta: float) -> float: ...
def expovariate(lambd: float) -> float: ...
def gammavariate(alpha: float, beta: float) -> float: ...
def gauss(mu: float, sigma: float) -> float: ...
def lognormvariate(mu: float, sigma: float) -> float: ...
def normalvariate(mu: float, sigma: float) -> float: ...
def vonmisesvariate(mu: float, kappa: float) -> float: ...
def paretovariate(alpha: float) -> float: ...
def weibullvariate(alpha: float, beta: float) -> float: ...
| 3,901 | Python | .py | 78 | 45.974359 | 130 | 0.591505 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,274 | string.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/string.pyi | from typing import Any, Iterable, Mapping, Optional, Sequence, Tuple, Union
ascii_letters: str
ascii_lowercase: str
ascii_uppercase: str
digits: str
hexdigits: str
octdigits: str
punctuation: str
printable: str
whitespace: str
def capwords(s: str, sep: Optional[str] = ...) -> str: ...
class Template:
template: str
def __init__(self, template: str) -> None: ...
def substitute(self, __mapping: Mapping[str, object] = ..., **kwds: object) -> str: ...
def safe_substitute(self, __mapping: Mapping[str, object] = ..., **kwds: object) -> str: ...
# TODO(MichalPokorny): This is probably badly and/or loosely typed.
class Formatter:
def format(self, __format_string: str, *args: Any, **kwargs: Any) -> str: ...
def vformat(self, format_string: str, args: Sequence[Any], kwargs: Mapping[str, Any]) -> str: ...
def parse(self, format_string: str) -> Iterable[Tuple[str, Optional[str], Optional[str], Optional[str]]]: ...
def get_field(self, field_name: str, args: Sequence[Any], kwargs: Mapping[str, Any]) -> Any: ...
def get_value(self, key: Union[int, str], args: Sequence[Any], kwargs: Mapping[str, Any]) -> Any: ...
def check_unused_args(self, used_args: Sequence[Union[int, str]], args: Sequence[Any], kwargs: Mapping[str, Any]) -> None: ...
def format_field(self, value: Any, format_spec: str) -> Any: ...
def convert_field(self, value: Any, conversion: str) -> Any: ...
| 1,423 | Python | .py | 26 | 51.730769 | 130 | 0.668342 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,275 | _markupbase.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_markupbase.pyi | from typing import Tuple
class ParserBase:
def __init__(self) -> None: ...
def error(self, message: str) -> None: ...
def reset(self) -> None: ...
def getpos(self) -> Tuple[int, int]: ...
def unknown_decl(self, data: str) -> None: ...
| 256 | Python | .py | 7 | 32.571429 | 50 | 0.58871 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,276 | signal.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/signal.pyi | import sys
from enum import IntEnum
from types import FrameType
from typing import Any, Callable, Iterable, Optional, Set, Tuple, Union
if sys.platform != "win32":
class ItimerError(IOError): ...
ITIMER_PROF: int
ITIMER_REAL: int
ITIMER_VIRTUAL: int
NSIG: int
class Signals(IntEnum):
SIGABRT: int
if sys.platform != "win32":
SIGALRM: int
if sys.platform == "win32":
SIGBREAK: int
if sys.platform != "win32":
SIGBUS: int
SIGCHLD: int
if sys.platform != "darwin" and sys.platform != "win32":
SIGCLD: int
if sys.platform != "win32":
SIGCONT: int
SIGEMT: int
SIGFPE: int
if sys.platform != "win32":
SIGHUP: int
SIGILL: int
SIGINFO: int
SIGINT: int
if sys.platform != "win32":
SIGIO: int
SIGIOT: int
SIGKILL: int
SIGPIPE: int
if sys.platform != "darwin" and sys.platform != "win32":
SIGPOLL: int
SIGPWR: int
if sys.platform != "win32":
SIGPROF: int
SIGQUIT: int
if sys.platform != "darwin" and sys.platform != "win32":
SIGRTMAX: int
SIGRTMIN: int
SIGSEGV: int
if sys.platform != "win32":
SIGSTOP: int
SIGSYS: int
SIGTERM: int
if sys.platform != "win32":
SIGTRAP: int
SIGTSTP: int
SIGTTIN: int
SIGTTOU: int
SIGURG: int
SIGUSR1: int
SIGUSR2: int
SIGVTALRM: int
SIGWINCH: int
SIGXCPU: int
SIGXFSZ: int
class Handlers(IntEnum):
SIG_DFL: int
SIG_IGN: int
SIG_DFL = Handlers.SIG_DFL
SIG_IGN = Handlers.SIG_IGN
if sys.platform != "win32":
class Sigmasks(IntEnum):
SIG_BLOCK: int
SIG_UNBLOCK: int
SIG_SETMASK: int
SIG_BLOCK = Sigmasks.SIG_BLOCK
SIG_UNBLOCK = Sigmasks.SIG_UNBLOCK
SIG_SETMASK = Sigmasks.SIG_SETMASK
_SIGNUM = Union[int, Signals]
_HANDLER = Union[Callable[[Signals, FrameType], Any], int, Handlers, None]
SIGABRT: Signals
if sys.platform != "win32":
SIGALRM: Signals
if sys.platform == "win32":
SIGBREAK: Signals
if sys.platform != "win32":
SIGBUS: Signals
SIGCHLD: Signals
if sys.platform != "darwin" and sys.platform != "win32":
SIGCLD: Signals
if sys.platform != "win32":
SIGCONT: Signals
SIGEMT: Signals
SIGFPE: Signals
if sys.platform != "win32":
SIGHUP: Signals
SIGILL: Signals
SIGINFO: Signals
SIGINT: Signals
if sys.platform != "win32":
SIGIO: Signals
SIGIOT: Signals
SIGKILL: Signals
SIGPIPE: Signals
if sys.platform != "darwin" and sys.platform != "win32":
SIGPOLL: Signals
SIGPWR: Signals
if sys.platform != "win32":
SIGPROF: Signals
SIGQUIT: Signals
if sys.platform != "darwin" and sys.platform != "win32":
SIGRTMAX: Signals
SIGRTMIN: Signals
SIGSEGV: Signals
if sys.platform != "win32":
SIGSTOP: Signals
SIGSYS: Signals
SIGTERM: Signals
if sys.platform != "win32":
SIGTRAP: Signals
SIGTSTP: Signals
SIGTTIN: Signals
SIGTTOU: Signals
SIGURG: Signals
SIGUSR1: Signals
SIGUSR2: Signals
SIGVTALRM: Signals
SIGWINCH: Signals
SIGXCPU: Signals
SIGXFSZ: Signals
if sys.platform == "win32":
CTRL_C_EVENT: int
CTRL_BREAK_EVENT: int
if sys.platform != "win32":
class struct_siginfo(Tuple[int, int, int, int, int, int, int]):
def __init__(self, sequence: Iterable[int]) -> None: ...
@property
def si_signo(self) -> int: ...
@property
def si_code(self) -> int: ...
@property
def si_errno(self) -> int: ...
@property
def si_pid(self) -> int: ...
@property
def si_uid(self) -> int: ...
@property
def si_status(self) -> int: ...
@property
def si_band(self) -> int: ...
if sys.platform != "win32":
def alarm(__seconds: int) -> int: ...
def default_int_handler(signum: int, frame: FrameType) -> None: ...
if sys.platform != "win32":
def getitimer(__which: int) -> Tuple[float, float]: ...
def getsignal(__signalnum: _SIGNUM) -> _HANDLER: ...
if sys.version_info >= (3, 8):
def strsignal(__signalnum: _SIGNUM) -> Optional[str]: ...
def valid_signals() -> Set[Signals]: ...
def raise_signal(__signalnum: _SIGNUM) -> None: ...
if sys.platform != "win32":
def pause() -> None: ...
def pthread_kill(__thread_id: int, __signalnum: int) -> None: ...
def pthread_sigmask(__how: int, __mask: Iterable[int]) -> Set[_SIGNUM]: ...
if sys.version_info >= (3, 7):
def set_wakeup_fd(fd: int, *, warn_on_full_buffer: bool = ...) -> int: ...
else:
def set_wakeup_fd(fd: int) -> int: ...
if sys.platform != "win32":
def setitimer(__which: int, __seconds: float, __interval: float = ...) -> Tuple[float, float]: ...
def siginterrupt(__signalnum: int, __flag: bool) -> None: ...
def signal(__signalnum: _SIGNUM, __handler: _HANDLER) -> _HANDLER: ...
if sys.platform != "win32":
def sigpending() -> Any: ...
def sigtimedwait(sigset: Iterable[int], timeout: float) -> Optional[struct_siginfo]: ...
def sigwait(__sigset: Iterable[int]) -> _SIGNUM: ...
def sigwaitinfo(sigset: Iterable[int]) -> struct_siginfo: ...
| 5,209 | Python | .py | 173 | 24.942197 | 102 | 0.622134 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,277 | runpy.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/runpy.pyi | from types import ModuleType
from typing import Any, Dict, Optional, TypeVar
_T = TypeVar("_T")
class _TempModule:
mod_name: str = ...
module: ModuleType = ...
def __init__(self, mod_name: str) -> None: ...
def __enter__(self: _T) -> _T: ...
def __exit__(self, *args: Any) -> None: ...
class _ModifiedArgv0:
value: Any = ...
def __init__(self, value: Any) -> None: ...
def __enter__(self: _T) -> _T: ...
def __exit__(self, *args: Any) -> None: ...
def run_module(
mod_name: str, init_globals: Optional[Dict[str, Any]] = ..., run_name: Optional[str] = ..., alter_sys: bool = ...
) -> None: ...
def run_path(path_name: str, init_globals: Optional[Dict[str, Any]] = ..., run_name: str = ...) -> None: ...
| 746 | Python | .py | 18 | 38 | 117 | 0.563536 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,278 | macurl2path.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/macurl2path.pyi | import sys
from typing import Union
if sys.version_info < (3, 7):
def url2pathname(pathname: str) -> str: ...
def pathname2url(pathname: str) -> str: ...
def _pncomp2url(component: Union[str, bytes]) -> str: ...
| 225 | Python | .py | 6 | 34.333333 | 61 | 0.66055 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,279 | tempfile.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tempfile.pyi | import os
import sys
from types import TracebackType
from typing import IO, Any, AnyStr, Generic, Iterable, Iterator, List, Optional, Tuple, Type, TypeVar, Union, overload
from typing_extensions import Literal
if sys.version_info >= (3, 9):
from types import GenericAlias
# global variables
TMP_MAX: int
tempdir: Optional[str]
template: str
_S = TypeVar("_S")
_T = TypeVar("_T") # for pytype, define typevar in same file as alias
_DirT = Union[_T, os.PathLike[_T]]
if sys.version_info >= (3, 8):
@overload
def NamedTemporaryFile(
mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"],
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
delete: bool = ...,
*,
errors: Optional[str] = ...,
) -> IO[str]: ...
@overload
def NamedTemporaryFile(
mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
delete: bool = ...,
*,
errors: Optional[str] = ...,
) -> IO[bytes]: ...
@overload
def NamedTemporaryFile(
mode: str = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
delete: bool = ...,
*,
errors: Optional[str] = ...,
) -> IO[Any]: ...
else:
@overload
def NamedTemporaryFile(
mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"],
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
delete: bool = ...,
) -> IO[str]: ...
@overload
def NamedTemporaryFile(
mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
delete: bool = ...,
) -> IO[bytes]: ...
@overload
def NamedTemporaryFile(
mode: str = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
delete: bool = ...,
) -> IO[Any]: ...
if sys.platform == "win32":
TemporaryFile = NamedTemporaryFile
else:
if sys.version_info >= (3, 8):
@overload
def TemporaryFile(
mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"],
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
*,
errors: Optional[str] = ...,
) -> IO[str]: ...
@overload
def TemporaryFile(
mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
*,
errors: Optional[str] = ...,
) -> IO[bytes]: ...
@overload
def TemporaryFile(
mode: str = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
*,
errors: Optional[str] = ...,
) -> IO[Any]: ...
else:
@overload
def TemporaryFile(
mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"],
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
) -> IO[str]: ...
@overload
def TemporaryFile(
mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
) -> IO[bytes]: ...
@overload
def TemporaryFile(
mode: str = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[AnyStr] = ...,
prefix: Optional[AnyStr] = ...,
dir: Optional[_DirT[AnyStr]] = ...,
) -> IO[Any]: ...
# It does not actually derive from IO[AnyStr], but it does implement the
# protocol.
class SpooledTemporaryFile(IO[AnyStr]):
# bytes needs to go first, as default mode is to open as bytes
if sys.version_info >= (3, 8):
@overload
def __init__(
self: SpooledTemporaryFile[bytes],
max_size: int = ...,
mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[str] = ...,
prefix: Optional[str] = ...,
dir: Optional[str] = ...,
*,
errors: Optional[str] = ...,
) -> None: ...
@overload
def __init__(
self: SpooledTemporaryFile[str],
max_size: int = ...,
mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"] = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[str] = ...,
prefix: Optional[str] = ...,
dir: Optional[str] = ...,
*,
errors: Optional[str] = ...,
) -> None: ...
@overload
def __init__(
self,
max_size: int = ...,
mode: str = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[str] = ...,
prefix: Optional[str] = ...,
dir: Optional[str] = ...,
*,
errors: Optional[str] = ...,
) -> None: ...
@property
def errors(self) -> Optional[str]: ...
else:
@overload
def __init__(
self: SpooledTemporaryFile[bytes],
max_size: int = ...,
mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[str] = ...,
prefix: Optional[str] = ...,
dir: Optional[str] = ...,
) -> None: ...
@overload
def __init__(
self: SpooledTemporaryFile[str],
max_size: int = ...,
mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"] = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[str] = ...,
prefix: Optional[str] = ...,
dir: Optional[str] = ...,
) -> None: ...
@overload
def __init__(
self,
max_size: int = ...,
mode: str = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
newline: Optional[str] = ...,
suffix: Optional[str] = ...,
prefix: Optional[str] = ...,
dir: Optional[str] = ...,
) -> None: ...
def rollover(self) -> None: ...
def __enter__(self: _S) -> _S: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> Optional[bool]: ...
# These methods are copied from the abstract methods of IO, because
# SpooledTemporaryFile implements IO.
# See also https://github.com/python/typeshed/pull/2452#issuecomment-420657918.
def close(self) -> None: ...
def fileno(self) -> int: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def read(self, n: int = ...) -> AnyStr: ...
def readline(self, limit: int = ...) -> AnyStr: ...
def readlines(self, hint: int = ...) -> List[AnyStr]: ...
def seek(self, offset: int, whence: int = ...) -> int: ...
def tell(self) -> int: ...
def truncate(self, size: Optional[int] = ...) -> int: ...
def write(self, s: AnyStr) -> int: ...
def writelines(self, iterable: Iterable[AnyStr]) -> None: ...
def __iter__(self) -> Iterator[AnyStr]: ...
# Other than the following methods, which do not exist on SpooledTemporaryFile
def readable(self) -> bool: ...
def seekable(self) -> bool: ...
def writable(self) -> bool: ...
def __next__(self) -> AnyStr: ...
class TemporaryDirectory(Generic[AnyStr]):
name: str
def __init__(
self, suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ...
) -> None: ...
def cleanup(self) -> None: ...
def __enter__(self) -> AnyStr: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> None: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
def mkstemp(
suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., text: bool = ...
) -> Tuple[int, AnyStr]: ...
@overload
def mkdtemp() -> str: ...
@overload
def mkdtemp(suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ...) -> AnyStr: ...
def mktemp(suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ...) -> AnyStr: ...
def gettempdirb() -> bytes: ...
def gettempprefixb() -> bytes: ...
def gettempdir() -> str: ...
def gettempprefix() -> str: ...
| 11,371 | Python | .py | 295 | 29.718644 | 128 | 0.475016 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,280 | _posixsubprocess.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_posixsubprocess.pyi | # NOTE: These are incomplete!
from typing import Callable, Sequence, Tuple
def cloexec_pipe() -> Tuple[int, int]: ...
def fork_exec(
args: Sequence[str],
executable_list: Sequence[bytes],
close_fds: bool,
fds_to_keep: Sequence[int],
cwd: str,
env_list: Sequence[bytes],
p2cread: int,
p2cwrite: int,
c2pred: int,
c2pwrite: int,
errread: int,
errwrite: int,
errpipe_read: int,
errpipe_write: int,
restore_signals: int,
start_new_session: int,
preexec_fn: Callable[[], None],
) -> int: ...
| 557 | Python | .py | 22 | 21.136364 | 44 | 0.64728 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,281 | configparser.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/configparser.pyi | import sys
from _typeshed import AnyPath, StrPath, SupportsWrite
from typing import (
AbstractSet,
Any,
Callable,
ClassVar,
Dict,
Iterable,
Iterator,
List,
Mapping,
MutableMapping,
Optional,
Pattern,
Sequence,
Tuple,
Type,
TypeVar,
Union,
overload,
)
from typing_extensions import Literal
# Internal type aliases
_section = Mapping[str, str]
_parser = MutableMapping[str, _section]
_converter = Callable[[str], Any]
_converters = Dict[str, _converter]
_T = TypeVar("_T")
if sys.version_info >= (3, 7):
_Path = AnyPath
else:
_Path = StrPath
DEFAULTSECT: str
MAX_INTERPOLATION_DEPTH: int
class Interpolation:
def before_get(self, parser: _parser, section: str, option: str, value: str, defaults: _section) -> str: ...
def before_set(self, parser: _parser, section: str, option: str, value: str) -> str: ...
def before_read(self, parser: _parser, section: str, option: str, value: str) -> str: ...
def before_write(self, parser: _parser, section: str, option: str, value: str) -> str: ...
class BasicInterpolation(Interpolation): ...
class ExtendedInterpolation(Interpolation): ...
class LegacyInterpolation(Interpolation): ...
class RawConfigParser(_parser):
_SECT_TMPL: ClassVar[str] = ... # Undocumented
_OPT_TMPL: ClassVar[str] = ... # Undocumented
_OPT_NV_TMPL: ClassVar[str] = ... # Undocumented
SECTCRE: Pattern[str] = ...
OPTCRE: ClassVar[Pattern[str]] = ...
OPTCRE_NV: ClassVar[Pattern[str]] = ... # Undocumented
NONSPACECRE: ClassVar[Pattern[str]] = ... # Undocumented
BOOLEAN_STATES: ClassVar[Mapping[str, bool]] = ... # Undocumented
default_section: str
@overload
def __init__(
self,
defaults: Optional[Mapping[str, Optional[str]]] = ...,
dict_type: Type[Mapping[str, str]] = ...,
allow_no_value: Literal[True] = ...,
*,
delimiters: Sequence[str] = ...,
comment_prefixes: Sequence[str] = ...,
inline_comment_prefixes: Optional[Sequence[str]] = ...,
strict: bool = ...,
empty_lines_in_values: bool = ...,
default_section: str = ...,
interpolation: Optional[Interpolation] = ...,
converters: _converters = ...,
) -> None: ...
@overload
def __init__(
self,
defaults: Optional[_section] = ...,
dict_type: Type[Mapping[str, str]] = ...,
allow_no_value: bool = ...,
*,
delimiters: Sequence[str] = ...,
comment_prefixes: Sequence[str] = ...,
inline_comment_prefixes: Optional[Sequence[str]] = ...,
strict: bool = ...,
empty_lines_in_values: bool = ...,
default_section: str = ...,
interpolation: Optional[Interpolation] = ...,
converters: _converters = ...,
) -> None: ...
def __len__(self) -> int: ...
def __getitem__(self, section: str) -> SectionProxy: ...
def __setitem__(self, section: str, options: _section) -> None: ...
def __delitem__(self, section: str) -> None: ...
def __iter__(self) -> Iterator[str]: ...
def defaults(self) -> _section: ...
def sections(self) -> List[str]: ...
def add_section(self, section: str) -> None: ...
def has_section(self, section: str) -> bool: ...
def options(self, section: str) -> List[str]: ...
def has_option(self, section: str, option: str) -> bool: ...
def read(self, filenames: Union[_Path, Iterable[_Path]], encoding: Optional[str] = ...) -> List[str]: ...
def read_file(self, f: Iterable[str], source: Optional[str] = ...) -> None: ...
def read_string(self, string: str, source: str = ...) -> None: ...
def read_dict(self, dictionary: Mapping[str, Mapping[str, Any]], source: str = ...) -> None: ...
def readfp(self, fp: Iterable[str], filename: Optional[str] = ...) -> None: ...
# These get* methods are partially applied (with the same names) in
# SectionProxy; the stubs should be kept updated together
@overload
def getint(self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> int: ...
@overload
def getint(
self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ...
) -> Union[int, _T]: ...
@overload
def getfloat(self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> float: ...
@overload
def getfloat(
self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ...
) -> Union[float, _T]: ...
@overload
def getboolean(self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> bool: ...
@overload
def getboolean(
self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ...
) -> Union[bool, _T]: ...
def _get_conv(
self,
section: str,
option: str,
conv: Callable[[str], _T],
*,
raw: bool = ...,
vars: Optional[_section] = ...,
fallback: _T = ...,
) -> _T: ...
# This is incompatible with MutableMapping so we ignore the type
@overload # type: ignore
def get(self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> str: ...
@overload
def get(
self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T
) -> Union[str, _T]: ...
@overload
def items(self, *, raw: bool = ..., vars: Optional[_section] = ...) -> AbstractSet[Tuple[str, SectionProxy]]: ...
@overload
def items(self, section: str, raw: bool = ..., vars: Optional[_section] = ...) -> List[Tuple[str, str]]: ...
def set(self, section: str, option: str, value: Optional[str] = ...) -> None: ...
def write(self, fp: SupportsWrite[str], space_around_delimiters: bool = ...) -> None: ...
def remove_option(self, section: str, option: str) -> bool: ...
def remove_section(self, section: str) -> bool: ...
def optionxform(self, optionstr: str) -> str: ...
class ConfigParser(RawConfigParser): ...
class SafeConfigParser(ConfigParser): ...
class SectionProxy(MutableMapping[str, str]):
def __init__(self, parser: RawConfigParser, name: str) -> None: ...
def __getitem__(self, key: str) -> str: ...
def __setitem__(self, key: str, value: str) -> None: ...
def __delitem__(self, key: str) -> None: ...
def __contains__(self, key: object) -> bool: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[str]: ...
@property
def parser(self) -> RawConfigParser: ...
@property
def name(self) -> str: ...
def get(self, option: str, fallback: Optional[str] = ..., *, raw: bool = ..., vars: Optional[_section] = ..., _impl: Optional[Any] = ..., **kwargs: Any) -> str: ... # type: ignore
# These are partially-applied version of the methods with the same names in
# RawConfigParser; the stubs should be kept updated together
@overload
def getint(self, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> int: ...
@overload
def getint(self, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ...) -> Union[int, _T]: ...
@overload
def getfloat(self, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> float: ...
@overload
def getfloat(
self, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ...
) -> Union[float, _T]: ...
@overload
def getboolean(self, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> bool: ...
@overload
def getboolean(
self, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ...
) -> Union[bool, _T]: ...
# SectionProxy can have arbitrary attributes when custon converters are used
def __getattr__(self, key: str) -> Callable[..., Any]: ...
class ConverterMapping(MutableMapping[str, Optional[_converter]]):
GETTERCRE: Pattern[Any]
def __init__(self, parser: RawConfigParser) -> None: ...
def __getitem__(self, key: str) -> _converter: ...
def __setitem__(self, key: str, value: Optional[_converter]) -> None: ...
def __delitem__(self, key: str) -> None: ...
def __iter__(self) -> Iterator[str]: ...
def __len__(self) -> int: ...
class Error(Exception):
message: str
def __init__(self, msg: str = ...) -> None: ...
class NoSectionError(Error):
section: str
def __init__(self, section: str) -> None: ...
class DuplicateSectionError(Error):
section: str
source: Optional[str]
lineno: Optional[int]
def __init__(self, section: str, source: Optional[str] = ..., lineno: Optional[int] = ...) -> None: ...
class DuplicateOptionError(Error):
section: str
option: str
source: Optional[str]
lineno: Optional[int]
def __init__(self, section: str, option: str, source: Optional[str] = ..., lineno: Optional[str] = ...) -> None: ...
class NoOptionError(Error):
section: str
option: str
def __init__(self, option: str, section: str) -> None: ...
class InterpolationError(Error):
section: str
option: str
def __init__(self, option: str, section: str, msg: str) -> None: ...
class InterpolationDepthError(InterpolationError):
def __init__(self, option: str, section: str, rawval: object) -> None: ...
class InterpolationMissingOptionError(InterpolationError):
reference: str
def __init__(self, option: str, section: str, rawval: object, reference: str) -> None: ...
class InterpolationSyntaxError(InterpolationError): ...
class ParsingError(Error):
source: str
errors: List[Tuple[int, str]]
def __init__(self, source: Optional[str] = ..., filename: Optional[str] = ...) -> None: ...
def append(self, lineno: int, line: str) -> None: ...
class MissingSectionHeaderError(ParsingError):
lineno: int
line: str
def __init__(self, filename: str, lineno: int, line: str) -> None: ...
| 10,095 | Python | .py | 230 | 38.708696 | 184 | 0.597785 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,282 | _osx_support.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_osx_support.pyi | from typing import Dict, Iterable, List, Optional, Sequence, Tuple, TypeVar, Union
_T = TypeVar("_T")
_K = TypeVar("_K")
_V = TypeVar("_V")
__all__: List[str]
_UNIVERSAL_CONFIG_VARS: Tuple[str, ...] # undocumented
_COMPILER_CONFIG_VARS: Tuple[str, ...] # undocumented
_INITPRE: str # undocumented
def _find_executable(executable: str, path: Optional[str] = ...) -> Optional[str]: ... # undocumented
def _read_output(commandstring: str) -> Optional[str]: ... # undocumented
def _find_build_tool(toolname: str) -> str: ... # undocumented
_SYSTEM_VERSION: Optional[str] # undocumented
def _get_system_version() -> str: ... # undocumented
def _remove_original_values(_config_vars: Dict[str, str]) -> None: ... # undocumented
def _save_modified_value(_config_vars: Dict[str, str], cv: str, newvalue: str) -> None: ... # undocumented
def _supports_universal_builds() -> bool: ... # undocumented
def _find_appropriate_compiler(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented
def _remove_universal_flags(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented
def _remove_unsupported_archs(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented
def _override_all_archs(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented
def _check_for_unavailable_sdk(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented
def compiler_fixup(compiler_so: Iterable[str], cc_args: Sequence[str]) -> List[str]: ...
def customize_config_vars(_config_vars: Dict[str, str]) -> Dict[str, str]: ...
def customize_compiler(_config_vars: Dict[str, str]) -> Dict[str, str]: ...
def get_platform_osx(
_config_vars: Dict[str, str], osname: _T, release: _K, machine: _V
) -> Tuple[Union[str, _T], Union[str, _K], Union[str, _V]]: ...
| 1,796 | Python | .py | 27 | 65.148148 | 107 | 0.674419 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,283 | ntpath.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/ntpath.pyi | import os
import sys
from _typeshed import AnyPath, BytesPath, StrPath
from genericpath import exists as exists
from typing import Any, AnyStr, Optional, Sequence, Tuple, TypeVar, overload
_T = TypeVar("_T")
if sys.version_info >= (3, 6):
from builtins import _PathLike
# ----- os.path variables -----
supports_unicode_filenames: bool
# aliases (also in os)
curdir: str
pardir: str
sep: str
if sys.platform == "win32":
altsep: str
else:
altsep: Optional[str]
extsep: str
pathsep: str
defpath: str
devnull: str
# ----- os.path function stubs -----
if sys.version_info >= (3, 6):
# Overloads are necessary to work around python/mypy#3644.
@overload
def abspath(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def abspath(path: AnyStr) -> AnyStr: ...
@overload
def basename(p: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def basename(p: AnyStr) -> AnyStr: ...
@overload
def dirname(p: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def dirname(p: AnyStr) -> AnyStr: ...
@overload
def expanduser(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def expanduser(path: AnyStr) -> AnyStr: ...
@overload
def expandvars(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def expandvars(path: AnyStr) -> AnyStr: ...
@overload
def normcase(s: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def normcase(s: AnyStr) -> AnyStr: ...
@overload
def normpath(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def normpath(path: AnyStr) -> AnyStr: ...
if sys.platform == "win32":
@overload
def realpath(path: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def realpath(path: AnyStr) -> AnyStr: ...
else:
@overload
def realpath(filename: _PathLike[AnyStr]) -> AnyStr: ...
@overload
def realpath(filename: AnyStr) -> AnyStr: ...
else:
def abspath(path: AnyStr) -> AnyStr: ...
def basename(p: AnyStr) -> AnyStr: ...
def dirname(p: AnyStr) -> AnyStr: ...
def expanduser(path: AnyStr) -> AnyStr: ...
def expandvars(path: AnyStr) -> AnyStr: ...
def normcase(s: AnyStr) -> AnyStr: ...
def normpath(path: AnyStr) -> AnyStr: ...
if sys.platform == "win32":
def realpath(path: AnyStr) -> AnyStr: ...
else:
def realpath(filename: AnyStr) -> AnyStr: ...
if sys.version_info >= (3, 6):
# In reality it returns str for sequences of StrPath and bytes for sequences
# of BytesPath, but mypy does not accept such a signature.
def commonpath(paths: Sequence[AnyPath]) -> Any: ...
elif sys.version_info >= (3, 5):
def commonpath(paths: Sequence[AnyStr]) -> AnyStr: ...
# NOTE: Empty lists results in '' (str) regardless of contained type.
# So, fall back to Any
def commonprefix(m: Sequence[AnyPath]) -> Any: ...
def lexists(path: AnyPath) -> bool: ...
# These return float if os.stat_float_times() == True,
# but int is a subclass of float.
def getatime(filename: AnyPath) -> float: ...
def getmtime(filename: AnyPath) -> float: ...
def getctime(filename: AnyPath) -> float: ...
def getsize(filename: AnyPath) -> int: ...
def isabs(s: AnyPath) -> bool: ...
def isfile(path: AnyPath) -> bool: ...
def isdir(s: AnyPath) -> bool: ...
def islink(path: AnyPath) -> bool: ...
def ismount(path: AnyPath) -> bool: ...
if sys.version_info >= (3, 6):
@overload
def join(a: StrPath, *paths: StrPath) -> str: ...
@overload
def join(a: BytesPath, *paths: BytesPath) -> bytes: ...
else:
def join(a: AnyStr, *paths: AnyStr) -> AnyStr: ...
@overload
def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ...
@overload
def relpath(path: StrPath, start: Optional[StrPath] = ...) -> str: ...
def samefile(f1: AnyPath, f2: AnyPath) -> bool: ...
def sameopenfile(fp1: int, fp2: int) -> bool: ...
def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ...
if sys.version_info >= (3, 6):
@overload
def split(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ...
@overload
def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
@overload
def splitdrive(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ...
@overload
def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
@overload
def splitext(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ...
@overload
def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
else:
def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
if sys.version_info < (3, 7) and sys.platform == "win32":
def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated
| 4,721 | Python | .py | 129 | 32.751938 | 80 | 0.638846 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,284 | smtplib.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/smtplib.pyi | from email.message import Message as _Message
from socket import socket
from ssl import SSLContext
from types import TracebackType
from typing import Any, Dict, List, Optional, Pattern, Protocol, Sequence, Tuple, Type, Union, overload
_Reply = Tuple[int, bytes]
_SendErrs = Dict[str, _Reply]
# Should match source_address for socket.create_connection
_SourceAddress = Tuple[Union[bytearray, bytes, str], int]
SMTP_PORT: int
SMTP_SSL_PORT: int
CRLF: str
bCRLF: bytes
OLDSTYLE_AUTH: Pattern[str]
class SMTPException(OSError): ...
class SMTPNotSupportedError(SMTPException): ...
class SMTPServerDisconnected(SMTPException): ...
class SMTPResponseException(SMTPException):
smtp_code: int
smtp_error: Union[bytes, str]
args: Union[Tuple[int, Union[bytes, str]], Tuple[int, bytes, str]]
def __init__(self, code: int, msg: Union[bytes, str]) -> None: ...
class SMTPSenderRefused(SMTPResponseException):
smtp_code: int
smtp_error: bytes
sender: str
args: Tuple[int, bytes, str]
def __init__(self, code: int, msg: bytes, sender: str) -> None: ...
class SMTPRecipientsRefused(SMTPException):
recipients: _SendErrs
args: Tuple[_SendErrs]
def __init__(self, recipients: _SendErrs) -> None: ...
class SMTPDataError(SMTPResponseException): ...
class SMTPConnectError(SMTPResponseException): ...
class SMTPHeloError(SMTPResponseException): ...
class SMTPAuthenticationError(SMTPResponseException): ...
def quoteaddr(addrstring: str) -> str: ...
def quotedata(data: str) -> str: ...
class _AuthObject(Protocol):
@overload
def __call__(self, challenge: None = ...) -> Optional[str]: ...
@overload
def __call__(self, challenge: bytes) -> str: ...
class SMTP:
debuglevel: int = ...
sock: Optional[socket] = ...
# Type of file should match what socket.makefile() returns
file: Optional[Any] = ...
helo_resp: Optional[bytes] = ...
ehlo_msg: str = ...
ehlo_resp: Optional[bytes] = ...
does_esmtp: bool = ...
default_port: int = ...
timeout: float
esmtp_features: Dict[str, str]
command_encoding: str
source_address: Optional[_SourceAddress]
local_hostname: str
def __init__(
self,
host: str = ...,
port: int = ...,
local_hostname: Optional[str] = ...,
timeout: float = ...,
source_address: Optional[_SourceAddress] = ...,
) -> None: ...
def __enter__(self) -> SMTP: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], tb: Optional[TracebackType]
) -> None: ...
def set_debuglevel(self, debuglevel: int) -> None: ...
def connect(self, host: str = ..., port: int = ..., source_address: Optional[_SourceAddress] = ...) -> _Reply: ...
def send(self, s: Union[bytes, str]) -> None: ...
def putcmd(self, cmd: str, args: str = ...) -> None: ...
def getreply(self) -> _Reply: ...
def docmd(self, cmd: str, args: str = ...) -> _Reply: ...
def helo(self, name: str = ...) -> _Reply: ...
def ehlo(self, name: str = ...) -> _Reply: ...
def has_extn(self, opt: str) -> bool: ...
def help(self, args: str = ...) -> bytes: ...
def rset(self) -> _Reply: ...
def noop(self) -> _Reply: ...
def mail(self, sender: str, options: Sequence[str] = ...) -> _Reply: ...
def rcpt(self, recip: str, options: Sequence[str] = ...) -> _Reply: ...
def data(self, msg: Union[bytes, str]) -> _Reply: ...
def verify(self, address: str) -> _Reply: ...
vrfy = verify
def expn(self, address: str) -> _Reply: ...
def ehlo_or_helo_if_needed(self) -> None: ...
user: str
password: str
def auth(self, mechanism: str, authobject: _AuthObject, *, initial_response_ok: bool = ...) -> _Reply: ...
@overload
def auth_cram_md5(self, challenge: None = ...) -> None: ...
@overload
def auth_cram_md5(self, challenge: bytes) -> str: ...
def auth_plain(self, challenge: Optional[bytes] = ...) -> str: ...
def auth_login(self, challenge: Optional[bytes] = ...) -> str: ...
def login(self, user: str, password: str, *, initial_response_ok: bool = ...) -> _Reply: ...
def starttls(
self, keyfile: Optional[str] = ..., certfile: Optional[str] = ..., context: Optional[SSLContext] = ...
) -> _Reply: ...
def sendmail(
self,
from_addr: str,
to_addrs: Union[str, Sequence[str]],
msg: Union[bytes, str],
mail_options: Sequence[str] = ...,
rcpt_options: List[str] = ...,
) -> _SendErrs: ...
def send_message(
self,
msg: _Message,
from_addr: Optional[str] = ...,
to_addrs: Optional[Union[str, Sequence[str]]] = ...,
mail_options: List[str] = ...,
rcpt_options: Sequence[str] = ...,
) -> _SendErrs: ...
def close(self) -> None: ...
def quit(self) -> _Reply: ...
class SMTP_SSL(SMTP):
default_port: int = ...
keyfile: Optional[str]
certfile: Optional[str]
context: SSLContext
def __init__(
self,
host: str = ...,
port: int = ...,
local_hostname: Optional[str] = ...,
keyfile: Optional[str] = ...,
certfile: Optional[str] = ...,
timeout: float = ...,
source_address: Optional[_SourceAddress] = ...,
context: Optional[SSLContext] = ...,
) -> None: ...
LMTP_PORT: int
class LMTP(SMTP):
def __init__(
self,
host: str = ...,
port: int = ...,
local_hostname: Optional[str] = ...,
source_address: Optional[_SourceAddress] = ...,
) -> None: ...
| 5,606 | Python | .py | 145 | 33.482759 | 118 | 0.602166 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,285 | pipes.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/pipes.pyi | import os
class Template:
def __init__(self) -> None: ...
def reset(self) -> None: ...
def clone(self) -> Template: ...
def debug(self, flag: bool) -> None: ...
def append(self, cmd: str, kind: str) -> None: ...
def prepend(self, cmd: str, kind: str) -> None: ...
def open(self, file: str, rw: str) -> os._wrap_close: ...
def copy(self, file: str, rw: str) -> os._wrap_close: ...
# Not documented, but widely used.
# Documented as shlex.quote since 3.3.
def quote(s: str) -> str: ...
| 518 | Python | .py | 13 | 36.230769 | 61 | 0.586481 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,286 | selectors.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/selectors.pyi | import sys
from _typeshed import FileDescriptor, FileDescriptorLike
from abc import ABCMeta, abstractmethod
from typing import Any, List, Mapping, NamedTuple, Optional, Tuple
_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]: ...
if sys.platform != "win32":
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]: ...
| 3,644 | Python | .py | 60 | 55.916667 | 112 | 0.68951 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,287 | textwrap.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/textwrap.pyi | from typing import Callable, Dict, List, Optional, 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: ...
| 3,234 | Python | .py | 97 | 28.14433 | 119 | 0.551372 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,288 | secrets.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/secrets.pyi | from hmac import compare_digest as compare_digest
from random import SystemRandom as SystemRandom
from typing import Optional, Sequence, TypeVar
_T = TypeVar("_T")
def randbelow(exclusive_upper_bound: int) -> int: ...
def randbits(k: int) -> int: ...
def choice(seq: Sequence[_T]) -> _T: ...
def token_bytes(nbytes: Optional[int] = ...) -> bytes: ...
def token_hex(nbytes: Optional[int] = ...) -> str: ...
def token_urlsafe(nbytes: Optional[int] = ...) -> str: ...
| 467 | Python | .py | 10 | 45.5 | 58 | 0.681319 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,289 | _json.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_json.pyi | from typing import Any, Callable, Dict, Optional, Tuple
class make_encoder:
sort_keys: Any
skipkeys: Any
key_separator: Any
indent: Any
markers: Any
default: Any
encoder: Any
item_separator: Any
def __init__(
self,
markers: Optional[Dict[int, Any]],
default: Callable[[Any], Any],
encoder: Callable[[str], str],
indent: Optional[int],
key_separator: str,
item_separator: str,
sort_keys: bool,
skipkeys: bool,
allow_nan: bool,
) -> None: ...
def __call__(self, obj: object, _current_indent_level: int) -> Any: ...
class make_scanner:
object_hook: Any
object_pairs_hook: Any
parse_int: Any
parse_constant: Any
parse_float: Any
strict: bool
# TODO: 'context' needs the attrs above (ducktype), but not __call__.
def __init__(self, context: make_scanner) -> None: ...
def __call__(self, string: str, index: int) -> Tuple[Any, int]: ...
def encode_basestring_ascii(s: str) -> str: ...
def scanstring(string: str, end: int, strict: bool = ...) -> Tuple[str, int]: ...
| 1,124 | Python | .py | 35 | 26.457143 | 81 | 0.605893 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,290 | io.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/io.pyi | import builtins
import codecs
import sys
from _typeshed import ReadableBuffer, WriteableBuffer
from types import TracebackType
from typing import IO, Any, BinaryIO, Callable, Iterable, Iterator, List, Optional, TextIO, Tuple, Type, TypeVar, Union
DEFAULT_BUFFER_SIZE: int
SEEK_SET: int
SEEK_CUR: int
SEEK_END: int
_T = TypeVar("_T", bound=IOBase)
open = builtins.open
if sys.version_info >= (3, 8):
def open_code(path: str) -> IO[bytes]: ...
BlockingIOError = builtins.BlockingIOError
class UnsupportedOperation(OSError, ValueError): ...
class IOBase:
def __iter__(self) -> Iterator[bytes]: ...
def __next__(self) -> bytes: ...
def __enter__(self: _T) -> _T: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> Optional[bool]: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
def flush(self) -> None: ...
def isatty(self) -> bool: ...
def readable(self) -> bool: ...
def readlines(self, __hint: int = ...) -> List[bytes]: ...
def seek(self, __offset: int, __whence: int = ...) -> int: ...
def seekable(self) -> bool: ...
def tell(self) -> int: ...
def truncate(self, __size: Optional[int] = ...) -> int: ...
def writable(self) -> bool: ...
def writelines(self, __lines: Iterable[ReadableBuffer]) -> None: ...
def readline(self, __size: Optional[int] = ...) -> bytes: ...
def __del__(self) -> None: ...
@property
def closed(self) -> bool: ...
def _checkClosed(self, msg: Optional[str] = ...) -> None: ... # undocumented
class RawIOBase(IOBase):
def readall(self) -> bytes: ...
def readinto(self, __buffer: WriteableBuffer) -> Optional[int]: ...
def write(self, __b: ReadableBuffer) -> Optional[int]: ...
def read(self, __size: int = ...) -> Optional[bytes]: ...
class BufferedIOBase(IOBase):
raw: RawIOBase # This is not part of the BufferedIOBase API and may not exist on some implementations.
def detach(self) -> RawIOBase: ...
def readinto(self, __buffer: WriteableBuffer) -> int: ...
def write(self, __buffer: ReadableBuffer) -> int: ...
def readinto1(self, __buffer: WriteableBuffer) -> int: ...
def read(self, __size: Optional[int] = ...) -> bytes: ...
def read1(self, __size: int = ...) -> bytes: ...
class FileIO(RawIOBase, BinaryIO):
mode: str
# Technically this is whatever is passed in as file, either a str, a bytes, or an int.
name: Union[int, str] # type: ignore
def __init__(
self,
file: Union[str, bytes, int],
mode: str = ...,
closefd: bool = ...,
opener: Optional[Callable[[Union[int, str], str], int]] = ...,
) -> None: ...
@property
def closefd(self) -> bool: ...
def write(self, __b: ReadableBuffer) -> int: ...
def read(self, __size: int = ...) -> bytes: ...
def __enter__(self: _T) -> _T: ...
class BytesIO(BufferedIOBase, BinaryIO):
def __init__(self, initial_bytes: bytes = ...) -> None: ...
# BytesIO does not contain a "name" field. This workaround is necessary
# to allow BytesIO sub-classes to add this field, as it is defined
# as a read-only property on IO[].
name: Any
def __enter__(self: _T) -> _T: ...
def getvalue(self) -> bytes: ...
def getbuffer(self) -> memoryview: ...
if sys.version_info >= (3, 7):
def read1(self, __size: Optional[int] = ...) -> bytes: ...
else:
def read1(self, __size: Optional[int]) -> bytes: ... # type: ignore
class BufferedReader(BufferedIOBase, BinaryIO):
def __enter__(self: _T) -> _T: ...
def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
def peek(self, __size: int = ...) -> bytes: ...
if sys.version_info >= (3, 7):
def read1(self, __size: int = ...) -> bytes: ...
else:
def read1(self, __size: int) -> bytes: ... # type: ignore
class BufferedWriter(BufferedIOBase, BinaryIO):
def __enter__(self: _T) -> _T: ...
def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
def write(self, __buffer: ReadableBuffer) -> int: ...
class BufferedRandom(BufferedReader, BufferedWriter):
def __enter__(self: _T) -> _T: ...
def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
def seek(self, __target: int, __whence: int = ...) -> int: ...
if sys.version_info >= (3, 7):
def read1(self, __size: int = ...) -> bytes: ...
else:
def read1(self, __size: int) -> bytes: ... # type: ignore
class BufferedRWPair(BufferedIOBase):
def __init__(self, reader: RawIOBase, writer: RawIOBase, buffer_size: int = ...) -> None: ...
def peek(self, __size: int = ...) -> bytes: ...
class TextIOBase(IOBase):
encoding: str
errors: Optional[str]
newlines: Union[str, Tuple[str, ...], None]
def __iter__(self) -> Iterator[str]: ... # type: ignore
def __next__(self) -> str: ... # type: ignore
def detach(self) -> BinaryIO: ...
def write(self, __s: str) -> int: ...
def writelines(self, __lines: Iterable[str]) -> None: ... # type: ignore
def readline(self, __size: int = ...) -> str: ... # type: ignore
def readlines(self, __hint: int = ...) -> List[str]: ... # type: ignore
def read(self, __size: Optional[int] = ...) -> str: ...
def tell(self) -> int: ...
class TextIOWrapper(TextIOBase, TextIO):
def __init__(
self,
buffer: IO[bytes],
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
newline: Optional[str] = ...,
line_buffering: bool = ...,
write_through: bool = ...,
) -> None: ...
@property
def buffer(self) -> BinaryIO: ...
@property
def closed(self) -> bool: ...
@property
def line_buffering(self) -> bool: ...
if sys.version_info >= (3, 7):
@property
def write_through(self) -> bool: ...
def reconfigure(
self,
*,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
newline: Optional[str] = ...,
line_buffering: Optional[bool] = ...,
write_through: Optional[bool] = ...,
) -> None: ...
# These are inherited from TextIOBase, but must exist in the stub to satisfy mypy.
def __enter__(self: _T) -> _T: ...
def __iter__(self) -> Iterator[str]: ... # type: ignore
def __next__(self) -> str: ... # type: ignore
def writelines(self, __lines: Iterable[str]) -> None: ... # type: ignore
def readline(self, __size: int = ...) -> str: ... # type: ignore
def readlines(self, __hint: int = ...) -> List[str]: ... # type: ignore
def seek(self, __cookie: int, __whence: int = ...) -> int: ...
class StringIO(TextIOWrapper):
def __init__(self, initial_value: Optional[str] = ..., newline: Optional[str] = ...) -> None: ...
# StringIO does not contain a "name" field. This workaround is necessary
# to allow StringIO sub-classes to add this field, as it is defined
# as a read-only property on IO[].
name: Any
def getvalue(self) -> str: ...
class IncrementalNewlineDecoder(codecs.IncrementalDecoder):
def __init__(self, decoder: Optional[codecs.IncrementalDecoder], translate: bool, errors: str = ...) -> None: ...
def decode(self, input: Union[bytes, str], final: bool = ...) -> str: ...
@property
def newlines(self) -> Optional[Union[str, Tuple[str, ...]]]: ...
| 7,499 | Python | .py | 166 | 39.837349 | 120 | 0.582251 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,291 | xxlimited.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/xxlimited.pyi | from typing import Any
class Null: ...
class Str: ...
class Xxo:
def demo(self) -> None: ...
class error: ...
def foo(__i: int, __j: int) -> Any: ...
def new() -> Xxo: ...
def roj(__b: Any) -> None: ...
| 211 | Python | .py | 9 | 21.555556 | 39 | 0.550505 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,292 | heapq.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/heapq.pyi | from _typeshed import SupportsLessThan
from typing import Any, Callable, Iterable, List, Optional, TypeVar
_T = TypeVar("_T")
def heappush(__heap: List[_T], __item: _T) -> None: ...
def heappop(__heap: List[_T]) -> _T: ...
def heappushpop(__heap: List[_T], __item: _T) -> _T: ...
def heapify(__heap: List[_T]) -> None: ...
def heapreplace(__heap: List[_T], __item: _T) -> _T: ...
def merge(*iterables: Iterable[_T], key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> Iterable[_T]: ...
def nlargest(n: int, iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsLessThan]] = ...) -> List[_T]: ...
def nsmallest(n: int, iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsLessThan]] = ...) -> List[_T]: ...
def _heapify_max(__x: List[_T]) -> None: ... # undocumented
| 798 | Python | .py | 12 | 65.333333 | 119 | 0.609694 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,293 | functools.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/functools.pyi | import sys
from _typeshed import SupportsLessThan
from typing import (
Any,
Callable,
Dict,
Generic,
Hashable,
Iterable,
Mapping,
NamedTuple,
Optional,
Sequence,
Tuple,
Type,
TypeVar,
Union,
overload,
)
if sys.version_info >= (3, 9):
from types import GenericAlias
_AnyCallable = Callable[..., Any]
_T = TypeVar("_T")
_S = TypeVar("_S")
@overload
def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T) -> _T: ...
@overload
def reduce(function: Callable[[_T, _T], _T], sequence: Iterable[_T]) -> _T: ...
class _CacheInfo(NamedTuple):
hits: int
misses: int
maxsize: int
currsize: int
class _lru_cache_wrapper(Generic[_T]):
__wrapped__: Callable[..., _T]
def __call__(self, *args: Hashable, **kwargs: Hashable) -> _T: ...
def cache_info(self) -> _CacheInfo: ...
def cache_clear(self) -> None: ...
if sys.version_info >= (3, 8):
@overload
def lru_cache(maxsize: Optional[int] = ..., typed: bool = ...) -> Callable[[Callable[..., _T]], _lru_cache_wrapper[_T]]: ...
@overload
def lru_cache(maxsize: Callable[..., _T], typed: bool = ...) -> _lru_cache_wrapper[_T]: ...
else:
def lru_cache(maxsize: Optional[int] = ..., typed: bool = ...) -> Callable[[Callable[..., _T]], _lru_cache_wrapper[_T]]: ...
WRAPPER_ASSIGNMENTS: Sequence[str]
WRAPPER_UPDATES: Sequence[str]
def update_wrapper(wrapper: _T, wrapped: _AnyCallable, assigned: Sequence[str] = ..., updated: Sequence[str] = ...) -> _T: ...
def wraps(wrapped: _AnyCallable, assigned: Sequence[str] = ..., updated: Sequence[str] = ...) -> Callable[[_T], _T]: ...
def total_ordering(cls: Type[_T]) -> Type[_T]: ...
def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], SupportsLessThan]: ...
class partial(Generic[_T]):
func: Callable[..., _T]
args: Tuple[Any, ...]
keywords: Dict[str, Any]
def __init__(self, func: Callable[..., _T], *args: Any, **kwargs: Any) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> _T: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
# With protocols, this could change into a generic protocol that defines __get__ and returns _T
_Descriptor = Any
class partialmethod(Generic[_T]):
func: Union[Callable[..., _T], _Descriptor]
args: Tuple[Any, ...]
keywords: Dict[str, Any]
@overload
def __init__(self, __func: Callable[..., _T], *args: Any, **keywords: Any) -> None: ...
@overload
def __init__(self, __func: _Descriptor, *args: Any, **keywords: Any) -> None: ...
def __get__(self, obj: Any, cls: Type[Any]) -> Callable[..., _T]: ...
@property
def __isabstractmethod__(self) -> bool: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class _SingleDispatchCallable(Generic[_T]):
registry: Mapping[Any, Callable[..., _T]]
def dispatch(self, cls: Any) -> Callable[..., _T]: ...
@overload
def register(self, cls: Any) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
@overload
def register(self, cls: Any, func: Callable[..., _T]) -> Callable[..., _T]: ...
def _clear_cache(self) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> _T: ...
def singledispatch(func: Callable[..., _T]) -> _SingleDispatchCallable[_T]: ...
if sys.version_info >= (3, 8):
class singledispatchmethod(Generic[_T]):
dispatcher: _SingleDispatchCallable[_T]
func: Callable[..., _T]
def __init__(self, func: Callable[..., _T]) -> None: ...
@overload
def register(self, cls: Any, method: None = ...) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
@overload
def register(self, cls: Any, method: Callable[..., _T]) -> Callable[..., _T]: ...
def __call__(self, *args: Any, **kwargs: Any) -> _T: ...
class cached_property(Generic[_T]):
func: Callable[[Any], _T]
attrname: Optional[str]
def __init__(self, func: Callable[[Any], _T]) -> None: ...
@overload
def __get__(self, instance: None, owner: Optional[Type[Any]] = ...) -> cached_property[_T]: ...
@overload
def __get__(self, instance: _S, owner: Optional[Type[Any]] = ...) -> _T: ...
def __set_name__(self, owner: Type[Any], name: str) -> None: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
if sys.version_info >= (3, 9):
def cache(__user_function: Callable[..., _T]) -> _lru_cache_wrapper[_T]: ...
| 4,613 | Python | .py | 107 | 38.299065 | 128 | 0.578396 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,294 | spwd.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/spwd.pyi | from typing import List, NamedTuple
class struct_spwd(NamedTuple):
sp_namp: str
sp_pwdp: str
sp_lstchg: int
sp_min: int
sp_max: int
sp_warn: int
sp_inact: int
sp_expire: int
sp_flag: int
def getspall() -> List[struct_spwd]: ...
def getspnam(name: str) -> struct_spwd: ...
| 310 | Python | .py | 13 | 19.923077 | 43 | 0.650847 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,295 | stat.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/stat.pyi | import sys
def S_ISDIR(mode: int) -> bool: ...
def S_ISCHR(mode: int) -> bool: ...
def S_ISBLK(mode: int) -> bool: ...
def S_ISREG(mode: int) -> bool: ...
def S_ISFIFO(mode: int) -> bool: ...
def S_ISLNK(mode: int) -> bool: ...
def S_ISSOCK(mode: int) -> bool: ...
def S_IMODE(mode: int) -> int: ...
def S_IFMT(mode: int) -> int: ...
def filemode(mode: int) -> str: ...
ST_MODE: int
ST_INO: int
ST_DEV: int
ST_NLINK: int
ST_UID: int
ST_GID: int
ST_SIZE: int
ST_ATIME: int
ST_MTIME: int
ST_CTIME: int
S_IFSOCK: int
S_IFLNK: int
S_IFREG: int
S_IFBLK: int
S_IFDIR: int
S_IFCHR: int
S_IFIFO: int
S_ISUID: int
S_ISGID: int
S_ISVTX: int
S_IRWXU: int
S_IRUSR: int
S_IWUSR: int
S_IXUSR: int
S_IRWXG: int
S_IRGRP: int
S_IWGRP: int
S_IXGRP: int
S_IRWXO: int
S_IROTH: int
S_IWOTH: int
S_IXOTH: int
S_ENFMT: int
S_IREAD: int
S_IWRITE: int
S_IEXEC: int
UF_NODUMP: int
UF_IMMUTABLE: int
UF_APPEND: int
UF_OPAQUE: int
UF_NOUNLINK: int
if sys.platform == "darwin":
UF_COMPRESSED: int # OS X 10.6+ only
UF_HIDDEN: int # OX X 10.5+ only
SF_ARCHIVED: int
SF_IMMUTABLE: int
SF_APPEND: int
SF_NOUNLINK: int
SF_SNAPSHOT: int
FILE_ATTRIBUTE_ARCHIVE: int
FILE_ATTRIBUTE_COMPRESSED: int
FILE_ATTRIBUTE_DEVICE: int
FILE_ATTRIBUTE_DIRECTORY: int
FILE_ATTRIBUTE_ENCRYPTED: int
FILE_ATTRIBUTE_HIDDEN: int
FILE_ATTRIBUTE_INTEGRITY_STREAM: int
FILE_ATTRIBUTE_NORMAL: int
FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: int
FILE_ATTRIBUTE_NO_SCRUB_DATA: int
FILE_ATTRIBUTE_OFFLINE: int
FILE_ATTRIBUTE_READONLY: int
FILE_ATTRIBUTE_REPARSE_POINT: int
FILE_ATTRIBUTE_SPARSE_FILE: int
FILE_ATTRIBUTE_SYSTEM: int
FILE_ATTRIBUTE_TEMPORARY: int
FILE_ATTRIBUTE_VIRTUAL: int
if sys.platform == "win32" and sys.version_info >= (3, 8):
IO_REPARSE_TAG_SYMLINK: int
IO_REPARSE_TAG_MOUNT_POINT: int
IO_REPARSE_TAG_APPEXECLINK: int
| 1,805 | Python | .py | 81 | 20.91358 | 58 | 0.735706 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,296 | _compat_pickle.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/_compat_pickle.pyi | from typing import Dict, Tuple
IMPORT_MAPPING: Dict[str, str]
NAME_MAPPING: Dict[Tuple[str, str], Tuple[str, str]]
PYTHON2_EXCEPTIONS: Tuple[str, ...]
MULTIPROCESSING_EXCEPTIONS: Tuple[str, ...]
REVERSE_IMPORT_MAPPING: Dict[str, str]
REVERSE_NAME_MAPPING: Dict[Tuple[str, str], Tuple[str, str]]
PYTHON3_OSERROR_EXCEPTIONS: Tuple[str, ...]
PYTHON3_IMPORTERROR_EXCEPTIONS: Tuple[str, ...]
| 388 | Python | .py | 9 | 42 | 60 | 0.753968 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,297 | reprlib.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/reprlib.pyi | from array import array
from typing import Any, Callable, Deque, Dict, FrozenSet, List, Set, Tuple
_ReprFunc = Callable[[Any], str]
def recursive_repr(fillvalue: str = ...) -> Callable[[_ReprFunc], _ReprFunc]: ...
class Repr:
maxlevel: int
maxdict: int
maxlist: int
maxtuple: int
maxset: int
maxfrozenset: int
maxdeque: int
maxarray: int
maxlong: int
maxstring: int
maxother: int
def __init__(self) -> None: ...
def repr(self, x: Any) -> str: ...
def repr1(self, x: Any, level: int) -> str: ...
def repr_tuple(self, x: Tuple[Any, ...], level: int) -> str: ...
def repr_list(self, x: List[Any], level: int) -> str: ...
def repr_array(self, x: array[Any], level: int) -> str: ...
def repr_set(self, x: Set[Any], level: int) -> str: ...
def repr_frozenset(self, x: FrozenSet[Any], level: int) -> str: ...
def repr_deque(self, x: Deque[Any], level: int) -> str: ...
def repr_dict(self, x: Dict[Any, Any], level: int) -> str: ...
def repr_str(self, x: str, level: int) -> str: ...
def repr_int(self, x: int, level: int) -> str: ...
def repr_instance(self, x: Any, level: int) -> str: ...
aRepr: Repr
def repr(x: object) -> str: ...
| 1,228 | Python | .py | 31 | 35.354839 | 81 | 0.598993 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,298 | copyreg.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/copyreg.pyi | from typing import Any, Callable, Hashable, List, Optional, SupportsInt, Tuple, TypeVar, Union
_Type = TypeVar("_Type", bound=type)
_Reduce = Union[Tuple[Callable[..., _Type], Tuple[Any, ...]], Tuple[Callable[..., _Type], Tuple[Any, ...], Optional[Any]]]
__all__: List[str]
def pickle(
ob_type: _Type,
pickle_function: Callable[[_Type], Union[str, _Reduce[_Type]]],
constructor_ob: Optional[Callable[[_Reduce[_Type]], _Type]] = ...,
) -> None: ...
def constructor(object: Callable[[_Reduce[_Type]], _Type]) -> None: ...
def add_extension(module: Hashable, name: Hashable, code: SupportsInt) -> None: ...
def remove_extension(module: Hashable, name: Hashable, code: int) -> None: ...
def clear_extension_cache() -> None: ...
| 739 | Python | .py | 13 | 54.692308 | 122 | 0.661134 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,299 | sre_parse.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/sre_parse.pyi | import sys
from sre_constants import _NamedIntConstant as _NIC, error as _Error
from typing import Any, Dict, FrozenSet, Iterable, List, Match, Optional, Pattern as _Pattern, Tuple, Union, overload
SPECIAL_CHARS: str
REPEAT_CHARS: str
DIGITS: FrozenSet[str]
OCTDIGITS: FrozenSet[str]
HEXDIGITS: FrozenSet[str]
ASCIILETTERS: FrozenSet[str]
WHITESPACE: FrozenSet[str]
ESCAPES: Dict[str, Tuple[_NIC, int]]
CATEGORIES: Dict[str, Union[Tuple[_NIC, _NIC], Tuple[_NIC, List[Tuple[_NIC, _NIC]]]]]
FLAGS: Dict[str, int]
GLOBAL_FLAGS: int
class Verbose(Exception): ...
class _State:
flags: int
groupdict: Dict[str, int]
groupwidths: List[Optional[int]]
lookbehindgroups: Optional[int]
def __init__(self) -> None: ...
@property
def groups(self) -> int: ...
def opengroup(self, name: str = ...) -> int: ...
def closegroup(self, gid: int, p: SubPattern) -> None: ...
def checkgroup(self, gid: int) -> bool: ...
def checklookbehindgroup(self, gid: int, source: Tokenizer) -> None: ...
if sys.version_info >= (3, 8):
State = _State
else:
Pattern = _State
_OpSubpatternType = Tuple[Optional[int], int, int, SubPattern]
_OpGroupRefExistsType = Tuple[int, SubPattern, SubPattern]
_OpInType = List[Tuple[_NIC, int]]
_OpBranchType = Tuple[None, List[SubPattern]]
_AvType = Union[_OpInType, _OpBranchType, Iterable[SubPattern], _OpGroupRefExistsType, _OpSubpatternType]
_CodeType = Tuple[_NIC, _AvType]
class SubPattern:
data: List[_CodeType]
width: Optional[int]
if sys.version_info >= (3, 8):
state: State
def __init__(self, state: State, data: Optional[List[_CodeType]] = ...) -> None: ...
else:
pattern: Pattern
def __init__(self, pattern: Pattern, data: Optional[List[_CodeType]] = ...) -> None: ...
def dump(self, level: int = ...) -> None: ...
def __len__(self) -> int: ...
def __delitem__(self, index: Union[int, slice]) -> None: ...
def __getitem__(self, index: Union[int, slice]) -> Union[SubPattern, _CodeType]: ...
def __setitem__(self, index: Union[int, slice], code: _CodeType) -> None: ...
def insert(self, index: int, code: _CodeType) -> None: ...
def append(self, code: _CodeType) -> None: ...
def getwidth(self) -> int: ...
class Tokenizer:
istext: bool
string: Any
decoded_string: str
index: int
next: Optional[str]
def __init__(self, string: Any) -> None: ...
def match(self, char: str) -> bool: ...
def get(self) -> Optional[str]: ...
def getwhile(self, n: int, charset: Iterable[str]) -> str: ...
if sys.version_info >= (3, 8):
def getuntil(self, terminator: str, name: str) -> str: ...
else:
def getuntil(self, terminator: str) -> str: ...
@property
def pos(self) -> int: ...
def tell(self) -> int: ...
def seek(self, index: int) -> None: ...
def error(self, msg: str, offset: int = ...) -> _Error: ...
def fix_flags(src: Union[str, bytes], flags: int) -> int: ...
_TemplateType = Tuple[List[Tuple[int, int]], List[Optional[str]]]
_TemplateByteType = Tuple[List[Tuple[int, int]], List[Optional[bytes]]]
if sys.version_info >= (3, 8):
def parse(str: str, flags: int = ..., state: Optional[State] = ...) -> SubPattern: ...
@overload
def parse_template(source: str, state: _Pattern[Any]) -> _TemplateType: ...
@overload
def parse_template(source: bytes, state: _Pattern[Any]) -> _TemplateByteType: ...
else:
def parse(str: str, flags: int = ..., pattern: Optional[Pattern] = ...) -> SubPattern: ...
@overload
def parse_template(source: str, pattern: _Pattern[Any]) -> _TemplateType: ...
@overload
def parse_template(source: bytes, pattern: _Pattern[Any]) -> _TemplateByteType: ...
def expand_template(template: _TemplateType, match: Match[Any]) -> str: ...
| 3,820 | Python | .py | 89 | 38.955056 | 117 | 0.64157 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |