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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
28,800 | ssh_exception.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/ssh_exception.pyi | import socket
from typing import List, Mapping, Tuple, Union
from paramiko.pkey import PKey
class SSHException(Exception): ...
class AuthenticationException(SSHException): ...
class PasswordRequiredException(AuthenticationException): ...
class BadAuthenticationType(AuthenticationException):
allowed_types: List[str]
explanation: str
def __init__(self, explanation: str, types: List[str]) -> None: ...
class PartialAuthentication(AuthenticationException):
allowed_types: List[str]
def __init__(self, types: List[str]) -> None: ...
class ChannelException(SSHException):
code: int
text: str
def __init__(self, code: int, text: str) -> None: ...
class BadHostKeyException(SSHException):
hostname: str
key: PKey
expected_key: PKey
def __init__(self, hostname: str, got_key: PKey, expected_key: PKey) -> None: ...
class ProxyCommandFailure(SSHException):
command: str
error: str
def __init__(self, command: str, error: str) -> None: ...
class NoValidConnectionsError(socket.error):
errors: Mapping[Union[Tuple[str, int], Tuple[str, int, int, int]], Exception]
def __init__(self, errors: Mapping[Union[Tuple[str, int], Tuple[str, int, int, int]], Exception]) -> None: ...
def __reduce__(self) -> Tuple[type, Tuple[Mapping[Union[Tuple[str, int], Tuple[str, int, int, int]], Exception]]]: ...
class CouldNotCanonicalize(SSHException): ...
class ConfigParseError(SSHException): ...
| 1,454 | Python | .py | 32 | 41.90625 | 122 | 0.711253 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,801 | _winapi.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/_winapi.pyi | import builtins
import ctypes.wintypes
import sys
from types import TracebackType
from typing import Any, Optional, Type, TypeVar
assert sys.platform == "win32"
_T = TypeVar("_T")
def format_system_message(errno: int) -> Optional[str]: ...
class WindowsError(builtins.WindowsError):
def __init__(self, value: Optional[int] = ...) -> None: ...
@property
def message(self) -> str: ...
@property
def code(self) -> int: ...
def handle_nonzero_success(result: int) -> None: ...
GMEM_MOVEABLE: int
GlobalAlloc: Any
GlobalLock: Any
GlobalUnlock: Any
GlobalSize: Any
CreateFileMapping: Any
MapViewOfFile: Any
UnmapViewOfFile: Any
RtlMoveMemory: Any
class MemoryMap:
name: str
length: int
security_attributes: Any = ...
pos: int
filemap: Any = ...
view: Any = ...
def __init__(self, name: str, length: int, security_attributes: Optional[Any] = ...) -> None: ...
def __enter__(self: _T) -> _T: ...
def seek(self, pos: int) -> None: ...
def write(self, msg: bytes) -> None: ...
def read(self, n: int) -> bytes: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], tb: Optional[TracebackType]
) -> None: ...
READ_CONTROL: int
STANDARD_RIGHTS_REQUIRED: int
STANDARD_RIGHTS_READ: int
STANDARD_RIGHTS_WRITE: int
STANDARD_RIGHTS_EXECUTE: int
STANDARD_RIGHTS_ALL: int
POLICY_VIEW_LOCAL_INFORMATION: int
POLICY_VIEW_AUDIT_INFORMATION: int
POLICY_GET_PRIVATE_INFORMATION: int
POLICY_TRUST_ADMIN: int
POLICY_CREATE_ACCOUNT: int
POLICY_CREATE_SECRET: int
POLICY_CREATE_PRIVILEGE: int
POLICY_SET_DEFAULT_QUOTA_LIMITS: int
POLICY_SET_AUDIT_REQUIREMENTS: int
POLICY_AUDIT_LOG_ADMIN: int
POLICY_SERVER_ADMIN: int
POLICY_LOOKUP_NAMES: int
POLICY_NOTIFICATION: int
POLICY_ALL_ACCESS: int
POLICY_READ: int
POLICY_WRITE: int
POLICY_EXECUTE: int
class TokenAccess:
TOKEN_QUERY: int
class TokenInformationClass:
TokenUser: int
class TOKEN_USER(ctypes.Structure):
num: int
class SECURITY_DESCRIPTOR(ctypes.Structure):
SECURITY_DESCRIPTOR_CONTROL: Any
REVISION: int
class SECURITY_ATTRIBUTES(ctypes.Structure):
nLength: int
lpSecurityDescriptor: Any
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
@property
def descriptor(self) -> Any: ...
@descriptor.setter
def descriptor(self, value: Any) -> None: ...
def GetTokenInformation(token: Any, information_class: Any) -> Any: ...
def OpenProcessToken(proc_handle: Any, access: Any) -> Any: ...
def get_current_user() -> TOKEN_USER: ...
def get_security_attributes_for_user(user: Optional[TOKEN_USER] = ...) -> SECURITY_ATTRIBUTES: ...
| 2,649 | Python | .py | 83 | 29.204819 | 116 | 0.717476 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,802 | kex_ecdh_nist.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_ecdh_nist.pyi | import sys
from _typeshed import ReadableBuffer
from typing import Callable, Optional, Union
from cryptography.hazmat.primitives.asymmetric.ec2 import EllipticCurve, EllipticCurvePrivateKey, EllipticCurvePublicKey
from paramiko.message import Message
from paramiko.transport import Transport
if sys.version_info < (3, 0):
from hashlib import _hash as _Hash
else:
from hashlib import _Hash
c_MSG_KEXECDH_INIT: bytes
c_MSG_KEXECDH_REPLY: bytes
class KexNistp256:
name: str
hash_algo: Callable[[ReadableBuffer], _Hash]
curve: EllipticCurve
transport: Transport
P: Union[int, EllipticCurvePrivateKey]
Q_C: Optional[EllipticCurvePublicKey]
Q_S: Optional[EllipticCurvePublicKey]
def __init__(self, transport: Transport) -> None: ...
def start_kex(self) -> None: ...
def parse_next(self, ptype: int, m: Message) -> None: ...
class KexNistp384(KexNistp256):
name: str
hash_algo: Callable[[ReadableBuffer], _Hash]
curve: EllipticCurve
class KexNistp521(KexNistp256):
name: str
hash_algo: Callable[[ReadableBuffer], _Hash]
curve: EllipticCurve
| 1,112 | Python | .py | 31 | 32.354839 | 120 | 0.75814 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,803 | message.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/message.pyi | import sys
from typing import Any, Iterable, List, Optional, Text
from .common import _LikeBytes
if sys.version_info < (3, 0):
from StringIO import StringIO
BytesIO = StringIO[bytes]
else:
from io import BytesIO
class Message:
big_int: int
packet: BytesIO
seqno: int # only when packet.Packetizer.read_message() is used
def __init__(self, content: Optional[bytes] = ...) -> None: ...
def asbytes(self) -> bytes: ...
def rewind(self) -> None: ...
def get_remainder(self) -> bytes: ...
def get_so_far(self) -> bytes: ...
def get_bytes(self, n: int) -> bytes: ...
def get_byte(self) -> bytes: ...
def get_boolean(self) -> bool: ...
def get_adaptive_int(self) -> int: ...
def get_int(self) -> int: ...
def get_int64(self) -> int: ...
def get_mpint(self) -> int: ...
def get_string(self) -> bytes: ...
def get_text(self) -> Text: ...
def get_binary(self) -> bytes: ...
def get_list(self) -> List[str]: ...
def add_bytes(self, b: bytes) -> Message: ...
def add_byte(self, b: bytes) -> Message: ...
def add_boolean(self, b: bool) -> Message: ...
def add_int(self, n: int) -> Message: ...
def add_adaptive_int(self, n: int) -> Message: ...
def add_int64(self, n: int) -> Message: ...
def add_mpint(self, z: int) -> Message: ...
def add_string(self, s: _LikeBytes) -> Message: ...
def add_list(self, l: Iterable[str]) -> Message: ...
def add(self, *seq: Any) -> None: ...
| 1,496 | Python | .py | 38 | 34.894737 | 68 | 0.59216 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,804 | auth_handler.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/auth_handler.pyi | from threading import Event
from typing import Callable, List, Optional, Tuple
from paramiko.message import Message
from paramiko.pkey import PKey
from paramiko.server import InteractiveQuery
from paramiko.ssh_gss import _SSH_GSSAuth
from paramiko.transport import Transport
_InteractiveCallback = Callable[[str, str, List[Tuple[str, bool]]], List[str]]
class AuthHandler:
transport: Transport
username: Optional[str]
authenticated: bool
auth_event: Optional[Event]
auth_method: str
banner: Optional[str]
password: Optional[str]
private_key: Optional[PKey]
interactive_handler: Optional[_InteractiveCallback]
submethods: Optional[str]
auth_username: Optional[str]
auth_fail_count: int
gss_host: Optional[str]
gss_deleg_creds: bool
def __init__(self, transport: Transport) -> None: ...
def is_authenticated(self) -> bool: ...
def get_username(self) -> Optional[str]: ...
def auth_none(self, username: str, event: Event) -> None: ...
def auth_publickey(self, username: str, key: PKey, event: Event) -> None: ...
def auth_password(self, username: str, password: str, event: Event) -> None: ...
def auth_interactive(self, username: str, handler: _InteractiveCallback, event: Event, submethods: str = ...) -> None: ...
def auth_gssapi_with_mic(self, username: str, gss_host: str, gss_deleg_creds: bool, event: Event) -> None: ...
def auth_gssapi_keyex(self, username: str, event: Event) -> None: ...
def abort(self) -> None: ...
def wait_for_response(self, event: Event) -> List[str]: ...
class GssapiWithMicAuthHandler:
method: str
sshgss: _SSH_GSSAuth
def __init__(self, delegate: AuthHandler, sshgss: _SSH_GSSAuth) -> None: ...
def abort(self) -> None: ...
@property
def transport(self) -> Transport: ...
@property
def auth_username(self) -> str: ...
@property
def gss_host(self) -> str: ...
| 1,934 | Python | .py | 45 | 38.777778 | 126 | 0.689125 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,805 | file.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/file.pyi | from typing import AnyStr, Generic, Iterable, List, Optional, Tuple, Union
from paramiko.util import ClosingContextManager
class BufferedFile(ClosingContextManager, Generic[AnyStr]):
SEEK_SET: int
SEEK_CUR: int
SEEK_END: int
FLAG_READ: int
FLAG_WRITE: int
FLAG_APPEND: int
FLAG_BINARY: int
FLAG_BUFFERED: int
FLAG_LINE_BUFFERED: int
FLAG_UNIVERSAL_NEWLINE: int
newlines: Union[None, AnyStr, Tuple[AnyStr, ...]]
def __init__(self) -> None: ...
def __del__(self) -> None: ...
def __iter__(self) -> BufferedFile: ...
def close(self) -> None: ...
def flush(self) -> None: ...
def __next__(self) -> AnyStr: ...
def readable(self) -> bool: ...
def writable(self) -> bool: ...
def seekable(self) -> bool: ...
def readinto(self, buff: bytearray) -> int: ...
def read(self, size: Optional[int] = ...) -> AnyStr: ...
def readline(self, size: Optional[int] = ...) -> AnyStr: ...
def readlines(self, sizehint: Optional[int] = ...) -> List[AnyStr]: ...
def seek(self, offset: int, whence: int = ...) -> None: ...
def tell(self) -> int: ...
def write(self, data: AnyStr) -> None: ...
def writelines(self, sequence: Iterable[AnyStr]) -> None: ...
def xreadlines(self) -> BufferedFile: ...
@property
def closed(self) -> bool: ...
| 1,342 | Python | .py | 34 | 34.705882 | 75 | 0.609663 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,806 | proxy.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/proxy.pyi | from subprocess import Popen
from typing import List, Optional
from paramiko.util import ClosingContextManager
class ProxyCommand(ClosingContextManager):
cmd: List[str]
process: Popen
timeout: Optional[float]
def __init__(self, command_line: str) -> None: ...
def send(self, content: bytes) -> int: ...
def recv(self, size: int) -> bytes: ...
def close(self) -> None: ...
@property
def closed(self) -> bool: ...
def settimeout(self, timeout: float) -> None: ...
| 504 | Python | .py | 14 | 32 | 54 | 0.672131 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,807 | sftp_attr.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_attr.pyi | from os import stat_result
from typing import Dict, Optional
class SFTPAttributes:
FLAG_SIZE: int
FLAG_UIDGID: int
FLAG_PERMISSIONS: int
FLAG_AMTIME: int
FLAG_EXTENDED: int
st_size: Optional[int]
st_uid: Optional[int]
st_gid: Optional[int]
st_mode: Optional[int]
st_atime: Optional[int]
st_mtime: Optional[int]
filename: str # only when from_stat() is used
longname: str # only when from_stat() is used
attr: Dict[str, str]
def __init__(self) -> None: ...
@classmethod
def from_stat(cls, obj: stat_result, filename: Optional[str] = ...) -> SFTPAttributes: ...
def asbytes(self) -> bytes: ...
| 667 | Python | .py | 21 | 27.285714 | 94 | 0.660465 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,808 | sftp.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/sftp.pyi | from logging import Logger
from typing import Dict, List, Optional
from paramiko.channel import Channel
CMD_INIT: int
CMD_VERSION: int
CMD_OPEN: int
CMD_CLOSE: int
CMD_READ: int
CMD_WRITE: int
CMD_LSTAT: int
CMD_FSTAT: int
CMD_SETSTAT: int
CMD_FSETSTAT: int
CMD_OPENDIR: int
CMD_READDIR: int
CMD_REMOVE: int
CMD_MKDIR: int
CMD_RMDIR: int
CMD_REALPATH: int
CMD_STAT: int
CMD_RENAME: int
CMD_READLINK: int
CMD_SYMLINK: int
CMD_STATUS: int
CMD_HANDLE: int
CMD_DATA: int
CMD_NAME: int
CMD_ATTRS: int
CMD_EXTENDED: int
CMD_EXTENDED_REPLY: int
SFTP_OK: int
SFTP_EOF: int
SFTP_NO_SUCH_FILE: int
SFTP_PERMISSION_DENIED: int
SFTP_FAILURE: int
SFTP_BAD_MESSAGE: int
SFTP_NO_CONNECTION: int
SFTP_CONNECTION_LOST: int
SFTP_OP_UNSUPPORTED: int
SFTP_DESC: List[str]
SFTP_FLAG_READ: int
SFTP_FLAG_WRITE: int
SFTP_FLAG_APPEND: int
SFTP_FLAG_CREATE: int
SFTP_FLAG_TRUNC: int
SFTP_FLAG_EXCL: int
CMD_NAMES: Dict[int, str]
class SFTPError(Exception): ...
class BaseSFTP:
logger: Logger
sock: Optional[Channel]
ultra_debug: bool
def __init__(self) -> None: ...
| 1,065 | Python | .py | 53 | 18.641509 | 39 | 0.783865 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,809 | kex_curve25519.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_curve25519.pyi | import sys
from _typeshed import ReadableBuffer as ReadableBuffer
from typing import Any, Callable, Optional
from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey
from paramiko.message import Message
from paramiko.transport import Transport
if sys.version_info < (3, 0):
from hashlib import _hash as _Hash
else:
from hashlib import _Hash
c_MSG_KEXECDH_INIT: bytes
c_MSG_KEXECDH_REPLY: bytes
class KexCurve25519:
hash_algo: Callable[[ReadableBuffer], _Hash]
transport: Transport
key: Optional[X25519PrivateKey]
def __init__(self, transport: Transport) -> None: ...
@classmethod
def is_available(cls) -> bool: ...
def start_kex(self) -> None: ...
def parse_next(self, ptype: int, m: Message) -> None: ...
| 771 | Python | .py | 21 | 33.619048 | 77 | 0.747989 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,810 | pipe.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/pipe.pyi | from typing import Protocol, Tuple
class _BasePipe(Protocol):
def clear(self) -> None: ...
def set(self) -> None: ...
class _Pipe(_BasePipe, Protocol):
def close(self) -> None: ...
def fileno(self) -> int: ...
def set_forever(self) -> None: ...
def make_pipe() -> _Pipe: ...
class PosixPipe(object):
def __init__(self) -> None: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
def clear(self) -> None: ...
def set(self) -> None: ...
def set_forever(self) -> None: ...
class WindowsPipe(object):
def __init__(self) -> None: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
def clear(self) -> None: ...
def set(self) -> None: ...
def set_forever(self) -> None: ...
class OrPipe:
def __init__(self, pipe: _Pipe) -> None: ...
def set(self) -> None: ...
def clear(self) -> None: ...
def make_or_pipe(pipe: _Pipe) -> Tuple[OrPipe, OrPipe]: ...
| 951 | Python | .py | 28 | 29.857143 | 59 | 0.560044 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,811 | common.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/common.pyi | import sys
from typing import Any, Dict, Protocol, Text, Union
MSG_DISCONNECT: int
MSG_IGNORE: int
MSG_UNIMPLEMENTED: int
MSG_DEBUG: int
MSG_SERVICE_REQUEST: int
MSG_SERVICE_ACCEPT: int
MSG_KEXINIT: int
MSG_NEWKEYS: int
MSG_USERAUTH_REQUEST: int
MSG_USERAUTH_FAILURE: int
MSG_USERAUTH_SUCCESS: int
MSG_USERAUTH_BANNER: int
MSG_USERAUTH_PK_OK: int
MSG_USERAUTH_INFO_REQUEST: int
MSG_USERAUTH_INFO_RESPONSE: int
MSG_USERAUTH_GSSAPI_RESPONSE: int
MSG_USERAUTH_GSSAPI_TOKEN: int
MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE: int
MSG_USERAUTH_GSSAPI_ERROR: int
MSG_USERAUTH_GSSAPI_ERRTOK: int
MSG_USERAUTH_GSSAPI_MIC: int
HIGHEST_USERAUTH_MESSAGE_ID: int
MSG_GLOBAL_REQUEST: int
MSG_REQUEST_SUCCESS: int
MSG_REQUEST_FAILURE: int
MSG_CHANNEL_OPEN: int
MSG_CHANNEL_OPEN_SUCCESS: int
MSG_CHANNEL_OPEN_FAILURE: int
MSG_CHANNEL_WINDOW_ADJUST: int
MSG_CHANNEL_DATA: int
MSG_CHANNEL_EXTENDED_DATA: int
MSG_CHANNEL_EOF: int
MSG_CHANNEL_CLOSE: int
MSG_CHANNEL_REQUEST: int
MSG_CHANNEL_SUCCESS: int
MSG_CHANNEL_FAILURE: int
cMSG_DISCONNECT: bytes
cMSG_IGNORE: bytes
cMSG_UNIMPLEMENTED: bytes
cMSG_DEBUG: bytes
cMSG_SERVICE_REQUEST: bytes
cMSG_SERVICE_ACCEPT: bytes
cMSG_KEXINIT: bytes
cMSG_NEWKEYS: bytes
cMSG_USERAUTH_REQUEST: bytes
cMSG_USERAUTH_FAILURE: bytes
cMSG_USERAUTH_SUCCESS: bytes
cMSG_USERAUTH_BANNER: bytes
cMSG_USERAUTH_PK_OK: bytes
cMSG_USERAUTH_INFO_REQUEST: bytes
cMSG_USERAUTH_INFO_RESPONSE: bytes
cMSG_USERAUTH_GSSAPI_RESPONSE: bytes
cMSG_USERAUTH_GSSAPI_TOKEN: bytes
cMSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE: bytes
cMSG_USERAUTH_GSSAPI_ERROR: bytes
cMSG_USERAUTH_GSSAPI_ERRTOK: bytes
cMSG_USERAUTH_GSSAPI_MIC: bytes
cMSG_GLOBAL_REQUEST: bytes
cMSG_REQUEST_SUCCESS: bytes
cMSG_REQUEST_FAILURE: bytes
cMSG_CHANNEL_OPEN: bytes
cMSG_CHANNEL_OPEN_SUCCESS: bytes
cMSG_CHANNEL_OPEN_FAILURE: bytes
cMSG_CHANNEL_WINDOW_ADJUST: bytes
cMSG_CHANNEL_DATA: bytes
cMSG_CHANNEL_EXTENDED_DATA: bytes
cMSG_CHANNEL_EOF: bytes
cMSG_CHANNEL_CLOSE: bytes
cMSG_CHANNEL_REQUEST: bytes
cMSG_CHANNEL_SUCCESS: bytes
cMSG_CHANNEL_FAILURE: bytes
MSG_NAMES: Dict[int, str]
AUTH_SUCCESSFUL: int
AUTH_PARTIALLY_SUCCESSFUL: int
AUTH_FAILED: int
OPEN_SUCCEEDED: int
OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED: int
OPEN_FAILED_CONNECT_FAILED: int
OPEN_FAILED_UNKNOWN_CHANNEL_TYPE: int
OPEN_FAILED_RESOURCE_SHORTAGE: int
CONNECTION_FAILED_CODE: Dict[int, str]
DISCONNECT_SERVICE_NOT_AVAILABLE: int
DISCONNECT_AUTH_CANCELLED_BY_USER: int
DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE: int
zero_byte: bytes
one_byte: bytes
four_byte: bytes
max_byte: bytes
cr_byte: bytes
linefeed_byte: bytes
crlf: bytes
if sys.version_info < (3, 0):
cr_byte_value: bytes
linefeed_byte_value: bytes
else:
cr_byte_value: int
linefeed_byte_value: int
class _SupportsAsBytes(Protocol):
def asbytes(self) -> bytes: ...
_LikeBytes = Union[bytes, Text, _SupportsAsBytes]
def asbytes(s: _LikeBytes) -> bytes: ...
xffffffff: int
x80000000: int
o666: int
o660: int
o644: int
o600: int
o777: int
o700: int
o70: int
DEBUG: int
INFO: int
WARNING: int
ERROR: int
CRITICAL: int
io_sleep: float
DEFAULT_WINDOW_SIZE: int
DEFAULT_MAX_PACKET_SIZE: int
MIN_WINDOW_SIZE: int
MIN_PACKET_SIZE: int
MAX_WINDOW_SIZE: int
| 3,167 | Python | .py | 123 | 24.455285 | 51 | 0.820674 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,812 | kex_group14.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_group14.pyi | import sys
from _typeshed import ReadableBuffer
from typing import Callable
from paramiko.kex_group1 import KexGroup1 as KexGroup1
if sys.version_info < (3, 0):
from hashlib import _hash as _Hash
else:
from hashlib import _Hash
class KexGroup14(KexGroup1):
P: int
G: int
name: str
hash_algo: Callable[[ReadableBuffer], _Hash]
class KexGroup14SHA256(KexGroup14):
name: str
hash_algo: Callable[[ReadableBuffer], _Hash]
| 453 | Python | .py | 16 | 25.0625 | 54 | 0.755196 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,813 | kex_group1.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_group1.pyi | import sys
from _typeshed import ReadableBuffer
from typing import Callable
from paramiko.message import Message
from paramiko.transport import Transport
if sys.version_info < (3, 0):
from hashlib import _hash as _Hash
else:
from hashlib import _Hash
c_MSG_KEXDH_INIT: bytes
c_MSG_KEXDH_REPLY: bytes
b7fffffffffffffff: bytes
b0000000000000000: bytes
class KexGroup1:
P: int
G: int
name: str
hash_algo: Callable[[ReadableBuffer], _Hash]
transport: Transport
x: int
e: int
f: int
def __init__(self, transport: Transport) -> None: ...
def start_kex(self) -> None: ...
def parse_next(self, ptype: int, m: Message) -> None: ...
| 679 | Python | .py | 25 | 23.92 | 61 | 0.715385 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,814 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/markupsafe/__init__.pyi | import string
import sys
from collections import Mapping
from typing import Any, Callable, Iterable, List, Optional, Sequence, Text, Tuple, Union
from markupsafe._compat import text_type
from markupsafe._native import escape as escape, escape_silent as escape_silent, soft_unicode as soft_unicode
class Markup(text_type):
def __new__(cls, base: Text = ..., encoding: Optional[Text] = ..., errors: Text = ...) -> Markup: ...
def __html__(self) -> Markup: ...
def __add__(self, other: text_type) -> Markup: ...
def __radd__(self, other: text_type) -> Markup: ...
def __mul__(self, num: int) -> Markup: ...
def __rmul__(self, num: int) -> Markup: ...
def __mod__(self, *args: Any) -> Markup: ...
def join(self, seq: Iterable[text_type]): ...
def split(self, sep: Optional[text_type] = ..., maxsplit: int = ...) -> List[text_type]: ...
def rsplit(self, sep: Optional[text_type] = ..., maxsplit: int = ...) -> List[text_type]: ...
def splitlines(self, keepends: bool = ...) -> List[text_type]: ...
def unescape(self) -> Text: ...
def striptags(self) -> Text: ...
@classmethod
def escape(cls, s: text_type) -> Markup: ... # noqa: F811
def partition(self, sep: text_type) -> Tuple[Markup, Markup, Markup]: ...
def rpartition(self, sep: text_type) -> Tuple[Markup, Markup, Markup]: ...
def format(self, *args, **kwargs) -> Markup: ...
def __html_format__(self, format_spec) -> Markup: ...
def __getslice__(self, start: int, stop: int) -> Markup: ...
def __getitem__(self, i: Union[int, slice]) -> Markup: ...
def capitalize(self) -> Markup: ...
def title(self) -> Markup: ...
def lower(self) -> Markup: ...
def upper(self) -> Markup: ...
def swapcase(self) -> Markup: ...
def replace(self, old: text_type, new: text_type, count: int = ...) -> Markup: ...
def ljust(self, width: int, fillchar: text_type = ...) -> Markup: ...
def rjust(self, width: int, fillchar: text_type = ...) -> Markup: ...
def lstrip(self, chars: Optional[text_type] = ...) -> Markup: ...
def rstrip(self, chars: Optional[text_type] = ...) -> Markup: ...
def strip(self, chars: Optional[text_type] = ...) -> Markup: ...
def center(self, width: int, fillchar: text_type = ...) -> Markup: ...
def zfill(self, width: int) -> Markup: ...
def translate(
self, table: Union[Mapping[int, Union[int, text_type, None]], Sequence[Union[int, text_type, None]]]
) -> Markup: ...
def expandtabs(self, tabsize: int = ...) -> Markup: ...
class EscapeFormatter(string.Formatter):
escape: Callable[[text_type], Markup]
def __init__(self, escape: Callable[[text_type], Markup]) -> None: ... # noqa: F811
def format_field(self, value: text_type, format_spec: text_type) -> Markup: ...
if sys.version_info >= (3,):
soft_str = soft_unicode
| 2,861 | Python | .py | 51 | 51.647059 | 109 | 0.606914 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,815 | _speedups.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/markupsafe/_speedups.pyi | from typing import Text, Union
from . import Markup
from ._compat import text_type
def escape(s: Union[Markup, Text]) -> Markup: ...
def escape_silent(s: Union[None, Markup, Text]) -> Markup: ...
def soft_unicode(s: Text) -> text_type: ...
| 242 | Python | .py | 6 | 39 | 62 | 0.700855 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,816 | _native.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/markupsafe/_native.pyi | from typing import Text, Union
from . import Markup
from ._compat import text_type
def escape(s: Union[Markup, Text]) -> Markup: ...
def escape_silent(s: Union[None, Markup, Text]) -> Markup: ...
def soft_unicode(s: Text) -> text_type: ...
| 242 | Python | .py | 6 | 39 | 62 | 0.700855 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,817 | _compat.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/2and3/markupsafe/_compat.pyi | import sys
from typing import Iterator, Mapping, Tuple, TypeVar
_K = TypeVar("_K")
_V = TypeVar("_V")
PY2: bool
def iteritems(d: Mapping[_K, _V]) -> Iterator[Tuple[_K, _V]]: ...
if sys.version_info >= (3,):
text_type = str
string_types = (str,)
unichr = chr
int_types = (int,)
else:
from __builtin__ import unichr as unichr
text_type = unicode
string_types = (str, unicode)
int_types = (int, long)
| 435 | Python | .py | 16 | 23.875 | 65 | 0.63285 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,818 | orjson.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/orjson.pyi | from typing import Any, Callable, Optional, Union
__version__: str
def dumps(__obj: Any, default: Optional[Callable[[Any], Any]] = ..., option: Optional[int] = ...) -> bytes: ...
def loads(__obj: Union[bytes, bytearray, str]) -> Any: ...
class JSONDecodeError(ValueError): ...
class JSONEncodeError(TypeError): ...
OPT_APPEND_NEWLINE: int
OPT_INDENT_2: int
OPT_NAIVE_UTC: int
OPT_NON_STR_KEYS: int
OPT_OMIT_MICROSECONDS: int
OPT_PASSTHROUGH_DATACLASS: int
OPT_PASSTHROUGH_DATETIME: int
OPT_PASSTHROUGH_SUBCLASS: int
OPT_SERIALIZE_DATACLASS: int
OPT_SERIALIZE_NUMPY: int
OPT_SERIALIZE_UUID: int
OPT_SORT_KEYS: int
OPT_STRICT_INTEGER: int
OPT_UTC_Z: int
| 656 | Python | .py | 20 | 31.6 | 111 | 0.753165 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,819 | dataclasses.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/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) |
28,820 | frozendict.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/frozendict.pyi | import collections
from typing import Any, Dict, Generic, Iterable, Iterator, Mapping, Tuple, Type, TypeVar, overload
_S = TypeVar("_S")
_KT = TypeVar("_KT")
_VT = TypeVar("_VT")
class frozendict(Mapping[_KT, _VT], Generic[_KT, _VT]):
dict_cls: Type[Dict] = ...
@overload
def __init__(self, **kwargs: _VT) -> None: ...
@overload
def __init__(self, mapping: Mapping[_KT, _VT]) -> None: ...
@overload
def __init__(self, iterable: Iterable[Tuple[_KT, _VT]]) -> None: ...
def __getitem__(self, key: _KT) -> _VT: ...
def __contains__(self, key: object) -> bool: ...
def copy(self: _S, **add_or_replace: _VT) -> _S: ...
def __iter__(self) -> Iterator[_KT]: ...
def __len__(self) -> int: ...
def __repr__(self) -> str: ...
def __hash__(self) -> int: ...
class FrozenOrderedDict(frozendict):
dict_cls: Type[collections.OrderedDict] = ...
| 895 | Python | .py | 22 | 36.727273 | 98 | 0.576037 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,821 | contextvars.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/contextvars.pyi | import sys
from typing import Any, Callable, ClassVar, Generic, Iterator, Mapping, TypeVar
if sys.version_info >= (3, 9):
from types import GenericAlias
_T = TypeVar("_T")
class ContextVar(Generic[_T]):
def __init__(self, name: str, *, default: _T = ...) -> None: ...
@property
def name(self) -> str: ...
def get(self, default: _T = ...) -> _T: ...
def set(self, value: _T) -> Token[_T]: ...
def reset(self, token: Token[_T]) -> None: ...
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,405 | Python | .py | 32 | 39.71875 | 97 | 0.601317 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,822 | algorithms.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/jwt/algorithms.pyi | import sys
from hashlib import _Hash
from typing import Any, ClassVar, Dict, Generic, Optional, Set, TypeVar, Union
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric.ec import (
EllipticCurvePrivateKey,
EllipticCurvePrivateKeyWithSerialization,
EllipticCurvePrivateNumbers,
EllipticCurvePublicKey,
EllipticCurvePublicKeyWithSerialization,
EllipticCurvePublicNumbers,
)
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
from cryptography.hazmat.primitives.asymmetric.rsa import (
RSAPrivateKey,
RSAPrivateKeyWithSerialization,
RSAPrivateNumbers,
RSAPublicKey,
RSAPublicKeyWithSerialization,
RSAPublicNumbers,
)
from cryptography.hazmat.primitives.asymmetric.utils import Prehashed
from cryptography.hazmat.primitives.hashes import HashAlgorithm
requires_cryptography = Set[str]
def get_default_algorithms() -> Dict[str, Algorithm[Any]]: ...
_K = TypeVar("_K")
class Algorithm(Generic[_K]):
def prepare_key(self, key: _K) -> _K: ...
def sign(self, msg: bytes, key: _K) -> bytes: ...
def verify(self, msg: bytes, key: _K, sig: bytes) -> bool: ...
@staticmethod
def to_jwk(key_obj: _K) -> str: ...
@staticmethod
def from_jwk(jwk: str) -> _K: ...
class NoneAlgorithm(Algorithm[None]):
def prepare_key(self, key: Optional[str]) -> None: ...
class _HashAlg:
def __call__(self, arg: Union[bytes, bytearray, memoryview] = ...) -> _Hash: ...
class HMACAlgorithm(Algorithm[bytes]):
SHA256: ClassVar[_HashAlg]
SHA384: ClassVar[_HashAlg]
SHA512: ClassVar[_HashAlg]
hash_alg: _HashAlg
def __init__(self, hash_alg: _HashAlg) -> None: ...
def prepare_key(self, key: Union[str, bytes]) -> bytes: ...
@staticmethod
def to_jwk(key_obj: Union[str, bytes]) -> str: ...
@staticmethod
def from_jwk(jwk: Union[str, bytes]) -> bytes: ...
# Only defined if cryptography is installed.
class RSAAlgorithm(Algorithm[Any]):
SHA256: ClassVar[hashes.SHA256]
SHA384: ClassVar[hashes.SHA384]
SHA512: ClassVar[hashes.SHA512]
hash_alg: Union[HashAlgorithm, Prehashed]
def __init__(self, hash_alg: Union[HashAlgorithm, Prehashed]) -> None: ...
def prepare_key(self, key: Union[bytes, str, RSAPrivateKey, RSAPublicKey]) -> Union[RSAPrivateKey, RSAPublicKey]: ...
@staticmethod
def from_jwk(jwk: Union[str, bytes, Dict[str, Any]]) -> Union[RSAPrivateKey, RSAPublicKey]: ...
def sign(self, msg: bytes, key: RSAPrivateKey) -> bytes: ...
def verify(self, msg: bytes, key: RSAPublicKey, sig: bytes) -> bool: ...
# Only defined if cryptography is installed.
class ECAlgorithm(Algorithm[Any]):
SHA256: ClassVar[hashes.SHA256]
SHA384: ClassVar[hashes.SHA384]
SHA512: ClassVar[hashes.SHA512]
hash_alg: Union[HashAlgorithm, Prehashed]
def __init__(self, hash_alg: Union[HashAlgorithm, Prehashed]) -> None: ...
def prepare_key(
self, key: Union[bytes, str, EllipticCurvePrivateKey, EllipticCurvePublicKey]
) -> Union[EllipticCurvePrivateKey, EllipticCurvePublicKey]: ...
@staticmethod
def to_jwk(key_obj: Union[EllipticCurvePrivateKeyWithSerialization, EllipticCurvePublicKeyWithSerialization]) -> str: ...
@staticmethod
def from_jwk(jwk: Union[str, bytes]) -> Union[EllipticCurvePrivateKey, EllipticCurvePublicKey]: ...
def sign(self, msg: bytes, key: EllipticCurvePrivateKey) -> bytes: ...
def verify(self, msg: bytes, key: EllipticCurvePublicKey, sig: bytes) -> bool: ...
# Only defined if cryptography is installed. Types should be tightened when
# cryptography gets type hints.
# See https://github.com/python/typeshed/issues/2542
class RSAPSSAlgorithm(RSAAlgorithm):
def sign(self, msg: bytes, key: Any) -> bytes: ...
def verify(self, msg: bytes, key: Any, sig: bytes) -> bool: ...
# Only defined if cryptography is installed.
class Ed25519Algorithm(Algorithm[Any]):
def __init__(self, **kwargs: Any) -> None: ...
def prepare_key(self, key: Union[str, bytes, Ed25519PrivateKey, Ed25519PublicKey]) -> Any: ...
def sign(self, msg: Union[str, bytes], key: Ed25519PrivateKey) -> bytes: ...
def verify(self, msg: Union[str, bytes], key: Ed25519PublicKey, sig: Union[str, bytes]) -> bool: ...
| 4,299 | Python | .py | 89 | 44.382022 | 125 | 0.719628 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,823 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/jwt/__init__.pyi | from typing import Any, Dict, Mapping, Optional, Union
from cryptography.hazmat.primitives.asymmetric import rsa
from . import algorithms
def decode(
jwt: Union[str, bytes],
key: Union[str, bytes, rsa.RSAPublicKey, rsa.RSAPrivateKey] = ...,
verify: bool = ...,
algorithms: Optional[Any] = ...,
options: Optional[Mapping[Any, Any]] = ...,
**kwargs: Any,
) -> Dict[str, Any]: ...
def encode(
payload: Mapping[str, Any],
key: Union[str, bytes, rsa.RSAPublicKey, rsa.RSAPrivateKey],
algorithm: str = ...,
headers: Optional[Mapping[str, Any]] = ...,
json_encoder: Optional[Any] = ...,
) -> bytes: ...
def register_algorithm(alg_id: str, alg_obj: algorithms.Algorithm[Any]) -> None: ...
def unregister_algorithm(alg_id: str) -> None: ...
class PyJWTError(Exception): ...
class InvalidTokenError(PyJWTError): ...
class DecodeError(InvalidTokenError): ...
class ExpiredSignatureError(InvalidTokenError): ...
class InvalidAudienceError(InvalidTokenError): ...
class InvalidIssuerError(InvalidTokenError): ...
class InvalidIssuedAtError(InvalidTokenError): ...
class ImmatureSignatureError(InvalidTokenError): ...
class InvalidKeyError(PyJWTError): ...
class InvalidAlgorithmError(InvalidTokenError): ...
class MissingRequiredClaimError(InvalidTokenError): ...
class InvalidSignatureError(DecodeError): ...
# Compatibility aliases (deprecated)
ExpiredSignature = ExpiredSignatureError
InvalidAudience = InvalidAudienceError
InvalidIssuer = InvalidIssuerError
# These aren't actually documented, but the package
# exports them in __init__.py, so we should at least
# make sure that mypy doesn't raise spurious errors
# if they're used.
get_unverified_header: Any
PyJWT: Any
PyJWS: Any
| 1,724 | Python | .py | 43 | 37.930233 | 84 | 0.751642 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,824 | py_ecdsa.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/jwt/contrib/algorithms/py_ecdsa.pyi | import hashlib
from typing import Any
from jwt.algorithms import Algorithm
class ECAlgorithm(Algorithm[Any]):
SHA256: hashlib._Hash
SHA384: hashlib._Hash
SHA512: hashlib._Hash
def __init__(self, hash_alg: hashlib._Hash) -> None: ...
| 251 | Python | .py | 8 | 28.125 | 60 | 0.73029 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,825 | pycrypto.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/jwt/contrib/algorithms/pycrypto.pyi | import hashlib
from typing import Any
from jwt.algorithms import Algorithm
class RSAAlgorithm(Algorithm[Any]):
SHA256: hashlib._Hash
SHA384: hashlib._Hash
SHA512: hashlib._Hash
def __init__(self, hash_alg: hashlib._Hash) -> None: ...
| 252 | Python | .py | 8 | 28.25 | 60 | 0.731405 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,826 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/six/__init__.pyi | from __future__ import print_function
import types
import typing
import unittest
from builtins import next as next
from functools import wraps as wraps
from io import BytesIO as BytesIO, StringIO as StringIO
from typing import (
Any,
AnyStr,
Callable,
Dict,
ItemsView,
Iterable,
KeysView,
Mapping,
NoReturn,
Optional,
Pattern,
Tuple,
Type,
TypeVar,
Union,
ValuesView,
overload,
)
from . import moves as moves
_T = TypeVar("_T")
_K = TypeVar("_K")
_V = TypeVar("_V")
__version__: str
# TODO make constant, then move this stub to 2and3
# https://github.com/python/typeshed/issues/17
PY2 = False
PY3 = True
PY34: bool
string_types = (str,)
integer_types = (int,)
class_types = (type,)
text_type = str
binary_type = bytes
MAXSIZE: int
def callable(obj: object) -> bool: ...
def get_unbound_function(unbound: types.FunctionType) -> types.FunctionType: ...
def create_bound_method(func: types.FunctionType, obj: object) -> types.MethodType: ...
def create_unbound_method(func: types.FunctionType, cls: type) -> types.FunctionType: ...
Iterator = object
def get_method_function(meth: types.MethodType) -> types.FunctionType: ...
def get_method_self(meth: types.MethodType) -> Optional[object]: ...
def get_function_closure(fun: types.FunctionType) -> Optional[Tuple[types._Cell, ...]]: ...
def get_function_code(fun: types.FunctionType) -> types.CodeType: ...
def get_function_defaults(fun: types.FunctionType) -> Optional[Tuple[Any, ...]]: ...
def get_function_globals(fun: types.FunctionType) -> Dict[str, Any]: ...
def iterkeys(d: Mapping[_K, _V]) -> typing.Iterator[_K]: ...
def itervalues(d: Mapping[_K, _V]) -> typing.Iterator[_V]: ...
def iteritems(d: Mapping[_K, _V]) -> typing.Iterator[Tuple[_K, _V]]: ...
# def iterlists
def viewkeys(d: Mapping[_K, _V]) -> KeysView[_K]: ...
def viewvalues(d: Mapping[_K, _V]) -> ValuesView[_V]: ...
def viewitems(d: Mapping[_K, _V]) -> ItemsView[_K, _V]: ...
def b(s: str) -> binary_type: ...
def u(s: str) -> text_type: ...
unichr = chr
def int2byte(i: int) -> bytes: ...
def byte2int(bs: binary_type) -> int: ...
def indexbytes(buf: binary_type, i: int) -> int: ...
def iterbytes(buf: binary_type) -> typing.Iterator[int]: ...
def assertCountEqual(self: unittest.TestCase, first: Iterable[_T], second: Iterable[_T], msg: Optional[str] = ...) -> None: ...
@overload
def assertRaisesRegex(self: unittest.TestCase, msg: Optional[str] = ...) -> Any: ...
@overload
def assertRaisesRegex(self: unittest.TestCase, callable_obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ...
def assertRegex(
self: unittest.TestCase, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Optional[str] = ...
) -> None: ...
exec_ = exec
def reraise(
tp: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] = ...
) -> NoReturn: ...
def raise_from(value: Union[BaseException, Type[BaseException]], from_value: Optional[BaseException]) -> NoReturn: ...
print_ = print
def with_metaclass(meta: type, *bases: type) -> type: ...
def add_metaclass(metaclass: type) -> Callable[[_T], _T]: ...
def ensure_binary(s: Union[bytes, str], encoding: str = ..., errors: str = ...) -> bytes: ...
def ensure_str(s: Union[bytes, str], encoding: str = ..., errors: str = ...) -> str: ...
def ensure_text(s: Union[bytes, str], encoding: str = ..., errors: str = ...) -> str: ...
def python_2_unicode_compatible(klass: _T) -> _T: ...
class _LazyDescriptor:
name: str
def __init__(self, name: str) -> None: ...
def __get__(self, obj: Optional[object], type: Optional[type] = ...) -> Any: ...
class MovedModule(_LazyDescriptor):
mod: str
def __init__(self, name: str, old: str, new: Optional[str] = ...) -> None: ...
def __getattr__(self, attr: str) -> Any: ...
class MovedAttribute(_LazyDescriptor):
mod: str
attr: str
def __init__(
self, name: str, old_mod: str, new_mod: str, old_attr: Optional[str] = ..., new_attr: Optional[str] = ...
) -> None: ...
def add_move(move: Union[MovedModule, MovedAttribute]) -> None: ...
def remove_move(name: str) -> None: ...
| 4,169 | Python | .py | 103 | 38.058252 | 127 | 0.664194 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,827 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/six/moves/__init__.pyi | # Stubs for six.moves
#
# Note: Commented out items means they weren't implemented at the time.
# Uncomment them when the modules have been added to the typeshed.
import importlib
import shlex
from builtins import filter as filter, input as input, map as map, range as range, zip as zip
from collections import UserDict as UserDict, UserList as UserList, UserString as UserString
from functools import reduce as reduce
from io import StringIO as StringIO
from itertools import filterfalse as filterfalse, zip_longest as zip_longest
from os import getcwd as getcwd, getcwdb as getcwdb
from sys import intern as intern
# import tkinter.font as tkinter_font
# import tkinter.messagebox as tkinter_messagebox
# import tkinter.simpledialog as tkinter_tksimpledialog
# import tkinter.dnd as tkinter_dnd
# import tkinter.colorchooser as tkinter_colorchooser
# import tkinter.scrolledtext as tkinter_scrolledtext
# import tkinter.simpledialog as tkinter_simpledialog
# import tkinter.tix as tkinter_tix
# import copyreg as copyreg
# import dbm.gnu as dbm_gnu
from . import (
BaseHTTPServer as BaseHTTPServer,
CGIHTTPServer as CGIHTTPServer,
SimpleHTTPServer as SimpleHTTPServer,
_dummy_thread as _dummy_thread,
_thread as _thread,
builtins as builtins,
configparser as configparser,
cPickle as cPickle,
email_mime_base as email_mime_base,
email_mime_multipart as email_mime_multipart,
email_mime_nonmultipart as email_mime_nonmultipart,
email_mime_text as email_mime_text,
html_entities as html_entities,
html_parser as html_parser,
http_client as http_client,
http_cookiejar as http_cookiejar,
http_cookies as http_cookies,
queue as queue,
reprlib as reprlib,
socketserver as socketserver,
tkinter as tkinter,
tkinter_commondialog as tkinter_commondialog,
tkinter_constants as tkinter_constants,
tkinter_dialog as tkinter_dialog,
tkinter_filedialog as tkinter_filedialog,
tkinter_tkfiledialog as tkinter_tkfiledialog,
tkinter_ttk as tkinter_ttk,
urllib as urllib,
urllib_error as urllib_error,
urllib_parse as urllib_parse,
urllib_robotparser as urllib_robotparser,
)
# import xmlrpc.client as xmlrpc_client
# import xmlrpc.server as xmlrpc_server
xrange = range
reload_module = importlib.reload
cStringIO = StringIO
shlex_quote = shlex.quote
| 2,363 | Python | .py | 62 | 35.064516 | 93 | 0.792863 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,828 | response.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/six/moves/urllib/response.pyi | # Stubs for six.moves.urllib.response
#
# Note: Commented out items means they weren't implemented at the time.
# Uncomment them when the modules have been added to the typeshed.
# from urllib.response import addbase as addbase
# from urllib.response import addclosehook as addclosehook
# from urllib.response import addinfo as addinfo
from urllib.response import addinfourl as addinfourl
| 389 | Python | .py | 8 | 47.625 | 71 | 0.826772 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,829 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/six/moves/urllib/__init__.pyi | import six.moves.urllib.error as error
import six.moves.urllib.parse as parse
import six.moves.urllib.request as request
import six.moves.urllib.response as response
import six.moves.urllib.robotparser as robotparser
| 217 | Python | .py | 5 | 42.4 | 50 | 0.858491 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,830 | error.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/six/moves/urllib/error.pyi | from urllib.error import ContentTooShortError as ContentTooShortError, HTTPError as HTTPError, URLError as URLError
| 116 | Python | .py | 1 | 115 | 115 | 0.878261 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,831 | request.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/six/moves/urllib/request.pyi | # Stubs for six.moves.urllib.request
#
# Note: Commented out items means they weren't implemented at the time.
# Uncomment them when the modules have been added to the typeshed.
# from urllib.request import proxy_bypass as proxy_bypass
from urllib.request import (
AbstractBasicAuthHandler as AbstractBasicAuthHandler,
AbstractDigestAuthHandler as AbstractDigestAuthHandler,
BaseHandler as BaseHandler,
CacheFTPHandler as CacheFTPHandler,
FancyURLopener as FancyURLopener,
FileHandler as FileHandler,
FTPHandler as FTPHandler,
HTTPBasicAuthHandler as HTTPBasicAuthHandler,
HTTPCookieProcessor as HTTPCookieProcessor,
HTTPDefaultErrorHandler as HTTPDefaultErrorHandler,
HTTPDigestAuthHandler as HTTPDigestAuthHandler,
HTTPErrorProcessor as HTTPErrorProcessor,
HTTPHandler as HTTPHandler,
HTTPPasswordMgr as HTTPPasswordMgr,
HTTPPasswordMgrWithDefaultRealm as HTTPPasswordMgrWithDefaultRealm,
HTTPRedirectHandler as HTTPRedirectHandler,
HTTPSHandler as HTTPSHandler,
OpenerDirector as OpenerDirector,
ProxyBasicAuthHandler as ProxyBasicAuthHandler,
ProxyDigestAuthHandler as ProxyDigestAuthHandler,
ProxyHandler as ProxyHandler,
Request as Request,
UnknownHandler as UnknownHandler,
URLopener as URLopener,
build_opener as build_opener,
getproxies as getproxies,
install_opener as install_opener,
parse_http_list as parse_http_list,
parse_keqv_list as parse_keqv_list,
pathname2url as pathname2url,
url2pathname as url2pathname,
urlcleanup as urlcleanup,
urlopen as urlopen,
urlretrieve as urlretrieve,
)
| 1,639 | Python | .py | 41 | 35.658537 | 71 | 0.811014 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,832 | parse.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/six/moves/urllib/parse.pyi | # Stubs for six.moves.urllib.parse
#
# Note: Commented out items means they weren't implemented at the time.
# Uncomment them when the modules have been added to the typeshed.
# from urllib.parse import splitquery as splitquery
# from urllib.parse import splittag as splittag
# from urllib.parse import splituser as splituser
from urllib.parse import (
ParseResult as ParseResult,
SplitResult as SplitResult,
parse_qs as parse_qs,
parse_qsl as parse_qsl,
quote as quote,
quote_plus as quote_plus,
unquote as unquote,
unquote_plus as unquote_plus,
unquote_to_bytes as unquote_to_bytes,
urldefrag as urldefrag,
urlencode as urlencode,
urljoin as urljoin,
urlparse as urlparse,
urlsplit as urlsplit,
urlunparse as urlunparse,
urlunsplit as urlunsplit,
uses_fragment as uses_fragment,
uses_netloc as uses_netloc,
uses_params as uses_params,
uses_query as uses_query,
uses_relative as uses_relative,
)
| 981 | Python | .py | 30 | 28.9 | 71 | 0.752892 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,833 | nodes.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/docutils/nodes.pyi | from typing import Any, List
class reference:
def __init__(self, rawsource: str = ..., text: str = ..., *children: List[Any], **attributes: Any) -> None: ...
def __getattr__(name: str) -> Any: ...
| 203 | Python | .py | 4 | 48.25 | 115 | 0.604061 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,834 | examples.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/docutils/examples.pyi | from typing import Any
html_parts: Any
def __getattr__(name: str) -> Any: ...
| 80 | Python | .py | 3 | 25 | 38 | 0.68 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,835 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/docutils/__init__.pyi | from typing import Any
def __getattr__(name: str) -> Any: ...
| 63 | Python | .py | 2 | 30 | 38 | 0.65 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,836 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/docutils/parsers/__init__.pyi | from typing import Any
def __getattr__(name: str) -> Any: ...
| 63 | Python | .py | 2 | 30 | 38 | 0.65 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,837 | nodes.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/nodes.pyi | from typing import Any
def __getattr__(name: str) -> Any: ...
| 63 | Python | .py | 2 | 30 | 38 | 0.65 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,838 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/__init__.pyi | from typing import Any
def __getattr__(name: str) -> Any: ...
| 63 | Python | .py | 2 | 30 | 38 | 0.65 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,839 | roles.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/roles.pyi | from typing import Any, Callable, Dict, List, Tuple
import docutils.nodes
import docutils.parsers.rst.states
_RoleFn = Callable[
[str, str, str, int, docutils.parsers.rst.states.Inliner, Dict[str, Any], List[str]],
Tuple[List[docutils.nodes.reference], List[docutils.nodes.reference]],
]
def register_local_role(name: str, role_fn: _RoleFn) -> None: ...
def __getattr__(name: str) -> Any: ... # incomplete
| 418 | Python | .py | 9 | 44.222222 | 89 | 0.721675 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,840 | states.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/states.pyi | from typing import Any
class Inliner:
def __init__(self) -> None: ...
def __getattr__(name: str) -> Any: ...
| 115 | Python | .py | 4 | 26.25 | 38 | 0.605505 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,841 | utils.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/pyrfc3339/utils.pyi | from datetime import datetime, timedelta, tzinfo
from typing import Optional
class FixedOffset(tzinfo):
def __init__(self, hours: float, minutes: float) -> None: ...
def dst(self, dt: Optional[datetime]) -> timedelta: ...
def utcoffset(self, dt: Optional[datetime]) -> timedelta: ...
def tzname(self, dt: Optional[datetime]) -> str: ...
def timedelta_seconds(td: timedelta) -> int: ...
def timezone(utcoffset: float) -> str: ...
| 447 | Python | .py | 9 | 46.666667 | 65 | 0.68578 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,842 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/pyrfc3339/__init__.pyi | from .generator import generate as generate
from .parser import parse as parse
| 79 | Python | .py | 2 | 38.5 | 43 | 0.844156 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,843 | parser.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/pyrfc3339/parser.pyi | from datetime import datetime
def parse(timestamp: str, utc: bool = ..., produce_naive: bool = ...) -> datetime: ...
| 118 | Python | .py | 2 | 57.5 | 86 | 0.669565 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,844 | generator.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/pyrfc3339/generator.pyi | from datetime import datetime
def generate(dt: datetime, utc: bool = ..., accept_naive: bool = ..., microseconds: bool = ...) -> str: ...
| 139 | Python | .py | 2 | 68 | 107 | 0.647059 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,845 | base.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/aiofiles/base.pyi | from types import CodeType, FrameType, TracebackType, coroutine
from typing import Any, Coroutine, Generator, Generic, Iterator, Optional, Type, TypeVar, Union
_T = TypeVar("_T")
_T_co = TypeVar("_T_co", covariant=True)
_V_co = TypeVar("_V_co", covariant=True)
_T_contra = TypeVar("_T_contra", contravariant=True)
class AsyncBase(Generic[_T]):
def __init__(self, file: str, loop: Any, executor: Any) -> None: ...
async def __aiter__(self) -> Iterator[_T]: ...
async def __anext__(self) -> _T: ...
class AiofilesContextManager(Generic[_T_co, _T_contra, _V_co]):
def __init__(self, coro: Coroutine[_T_co, _T_contra, _V_co]) -> None: ...
def send(self, value: _T_contra) -> _T_co: ...
def throw(
self, typ: Type[BaseException], val: Union[BaseException, object] = ..., tb: Optional[TracebackType] = ...
) -> _T_co: ...
def close(self) -> None: ...
@property
def gi_frame(self) -> FrameType: ...
@property
def gi_running(self) -> bool: ...
@property
def gi_code(self) -> CodeType: ...
def __next__(self) -> _T_co: ...
@coroutine
def __iter__(self) -> Iterator[Coroutine[_T_co, _T_contra, _V_co]]: ...
def __await__(self) -> Generator[Any, None, _V_co]: ...
async def __anext__(self) -> _V_co: ...
async def __aenter__(self) -> _V_co: ...
async def __aexit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> None: ...
| 1,490 | Python | .py | 32 | 42.21875 | 120 | 0.604811 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,846 | os.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/aiofiles/os.pyi | import sys
from _typeshed import AnyPath
from os import stat_result
from typing import Optional, Sequence, Union, overload
_FdOrAnyPath = Union[int, AnyPath]
async def stat(path: _FdOrAnyPath, *, dir_fd: Optional[int] = ..., follow_symlinks: bool = ...) -> stat_result: ...
async def rename(src: AnyPath, dst: AnyPath, *, src_dir_fd: Optional[int] = ..., dst_dir_fd: Optional[int] = ...) -> None: ...
async def remove(path: AnyPath, *, dir_fd: Optional[int] = ...) -> None: ...
async def mkdir(path: AnyPath, mode: int = ..., *, dir_fd: Optional[int] = ...) -> None: ...
async def rmdir(path: AnyPath, *, dir_fd: Optional[int] = ...) -> None: ...
if sys.platform != "win32":
@overload
async def sendfile(__out_fd: int, __in_fd: int, offset: Optional[int], count: int) -> int: ...
@overload
async def sendfile(
__out_fd: int,
__in_fd: int,
offset: int,
count: int,
headers: Sequence[bytes] = ...,
trailers: Sequence[bytes] = ...,
flags: int = ...,
) -> int: ...
| 1,040 | Python | .py | 23 | 40.782609 | 126 | 0.598619 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,847 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/__init__.pyi | from _typeshed import AnyPath, OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, OpenBinaryModeWriting, OpenTextMode
from asyncio import AbstractEventLoop
from typing import Any, Callable, Optional, TypeVar, Union, overload
from typing_extensions import Literal
from ..base import AiofilesContextManager
from .binary import AsyncBufferedIOBase, AsyncBufferedReader, AsyncFileIO, _UnknownAsyncBinaryIO
from .text import AsyncTextIOWrapper
_OpenFile = TypeVar("_OpenFile", bound=Union[AnyPath, int])
_Opener = Callable[[str, int], int]
# Text mode: always returns AsyncTextIOWrapper
@overload
def open(
file: _OpenFile,
mode: OpenTextMode = ...,
buffering: int = ...,
encoding: Optional[str] = ...,
errors: Optional[str] = ...,
newline: Optional[str] = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
*,
loop: Optional[AbstractEventLoop] = ...,
executor: Optional[Any] = ...,
) -> AiofilesContextManager[None, None, AsyncTextIOWrapper]: ...
# Unbuffered binary: returns a FileIO
@overload
def open(
file: _OpenFile,
mode: OpenBinaryMode,
buffering: Literal[0],
encoding: None = ...,
errors: None = ...,
newline: None = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
*,
loop: Optional[AbstractEventLoop] = ...,
executor: Optional[Any] = ...,
) -> AiofilesContextManager[None, None, AsyncFileIO]: ...
# Buffered binary reading/updating: AsyncBufferedReader
@overload
def open(
file: _OpenFile,
mode: Union[OpenBinaryModeReading, OpenBinaryModeUpdating],
buffering: Literal[-1, 1] = ...,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
*,
loop: Optional[AbstractEventLoop] = ...,
executor: Optional[Any] = ...,
) -> AiofilesContextManager[None, None, AsyncBufferedReader]: ...
# Buffered binary writing: AsyncBufferedIOBase
@overload
def open(
file: _OpenFile,
mode: OpenBinaryModeWriting,
buffering: Literal[-1, 1] = ...,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
*,
loop: Optional[AbstractEventLoop] = ...,
executor: Optional[Any] = ...,
) -> AiofilesContextManager[None, None, AsyncBufferedIOBase]: ...
# Buffering cannot be determined: fall back to _UnknownAsyncBinaryIO
@overload
def open(
file: _OpenFile,
mode: OpenBinaryMode,
buffering: int,
encoding: None = ...,
errors: None = ...,
newline: None = ...,
closefd: bool = ...,
opener: Optional[_Opener] = ...,
*,
loop: Optional[AbstractEventLoop] = ...,
executor: Optional[Any] = ...,
) -> AiofilesContextManager[None, None, _UnknownAsyncBinaryIO]: ...
| 2,812 | Python | .py | 84 | 29.77381 | 129 | 0.672179 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,848 | binary.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/binary.pyi | from _typeshed import AnyPath, ReadableBuffer, WriteableBuffer
from io import FileIO
from typing import Iterable, List, Optional, Union
from ..base import AsyncBase
class _UnknownAsyncBinaryIO(AsyncBase[bytes]):
async def close(self) -> None: ...
async def flush(self) -> None: ...
async def isatty(self) -> bool: ...
async def read(self, __size: int = ...) -> bytes: ...
async def readinto(self, __buffer: WriteableBuffer) -> Optional[int]: ...
async def readline(self, __size: Optional[int] = ...) -> bytes: ...
async def readlines(self, __hint: int = ...) -> List[bytes]: ...
async def seek(self, __offset: int, __whence: int = ...) -> int: ...
async def seekable(self) -> bool: ...
async def tell(self) -> int: ...
async def truncate(self, __size: Optional[int] = ...) -> int: ...
async def writable(self) -> bool: ...
async def write(self, __b: ReadableBuffer) -> int: ...
async def writelines(self, __lines: Iterable[ReadableBuffer]) -> None: ...
def fileno(self) -> int: ...
def readable(self) -> bool: ...
@property
def closed(self) -> bool: ...
@property
def mode(self) -> str: ...
@property
def name(self) -> Union[AnyPath, int]: ...
class AsyncBufferedIOBase(_UnknownAsyncBinaryIO):
async def read1(self, __size: int = ...) -> bytes: ...
def detach(self) -> FileIO: ...
@property
def raw(self) -> FileIO: ...
class AsyncBufferedReader(AsyncBufferedIOBase):
async def peek(self, __size: int = ...) -> bytes: ...
class AsyncFileIO(_UnknownAsyncBinaryIO):
async def readall(self) -> bytes: ...
| 1,619 | Python | .py | 36 | 40.722222 | 78 | 0.626743 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,849 | text.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/text.pyi | from _typeshed import AnyPath
from typing import BinaryIO, Iterable, List, Optional, Tuple, Union
from ..base import AsyncBase
class AsyncTextIOWrapper(AsyncBase[str]):
async def close(self) -> None: ...
async def flush(self) -> None: ...
async def isatty(self) -> bool: ...
async def read(self, __size: Optional[int] = ...) -> str: ...
async def readline(self, __size: int = ...) -> str: ...
async def readlines(self, __hint: int = ...) -> List[str]: ...
async def seek(self, __offset: int, __whence: int = ...) -> int: ...
async def seekable(self) -> bool: ...
async def tell(self) -> int: ...
async def truncate(self, __size: Optional[int] = ...) -> int: ...
async def writable(self) -> bool: ...
async def write(self, __b: str) -> int: ...
async def writelines(self, __lines: Iterable[str]) -> None: ...
def detach(self) -> BinaryIO: ...
def fileno(self) -> int: ...
def readable(self) -> bool: ...
@property
def buffer(self) -> BinaryIO: ...
@property
def closed(self) -> bool: ...
@property
def encoding(self) -> str: ...
@property
def errors(self) -> Optional[str]: ...
@property
def line_buffering(self) -> bool: ...
@property
def newlines(self) -> Union[str, Tuple[str, ...], None]: ...
@property
def name(self) -> Union[AnyPath, int]: ...
@property
def mode(self) -> str: ...
| 1,416 | Python | .py | 36 | 34.722222 | 72 | 0.585631 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,850 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/pkg_resources/__init__.pyi | import importlib.abc
import types
import zipimport
from abc import ABCMeta
from typing import IO, Any, Callable, Dict, Generator, Iterable, List, Optional, Sequence, Set, Tuple, TypeVar, Union, overload
_T = TypeVar("_T")
_NestedStr = Union[str, Iterable[Union[str, Iterable[Any]]]]
_InstallerType = Callable[[Requirement], Optional[Distribution]]
_EPDistType = Union[Distribution, Requirement, str]
_MetadataType = Optional[IResourceProvider]
_PkgReqType = Union[str, Requirement]
_DistFinderType = Callable[[_Importer, str, bool], Generator[Distribution, None, None]]
_NSHandlerType = Callable[[_Importer, str, str, types.ModuleType], str]
def declare_namespace(name: str) -> None: ...
def fixup_namespace_packages(path_item: str) -> None: ...
class WorkingSet:
entries: List[str]
def __init__(self, entries: Optional[Iterable[str]] = ...) -> None: ...
def require(self, *requirements: _NestedStr) -> Sequence[Distribution]: ...
def run_script(self, requires: str, script_name: str) -> None: ...
def iter_entry_points(self, group: str, name: Optional[str] = ...) -> Generator[EntryPoint, None, None]: ...
def add_entry(self, entry: str) -> None: ...
def __contains__(self, dist: Distribution) -> bool: ...
def __iter__(self) -> Generator[Distribution, None, None]: ...
def find(self, req: Requirement) -> Optional[Distribution]: ...
def resolve(
self, requirements: Iterable[Requirement], env: Optional[Environment] = ..., installer: Optional[_InstallerType] = ...
) -> List[Distribution]: ...
def add(self, dist: Distribution, entry: Optional[str] = ..., insert: bool = ..., replace: bool = ...) -> None: ...
def subscribe(self, callback: Callable[[Distribution], None]) -> None: ...
def find_plugins(
self, plugin_env: Environment, full_env: Optional[Environment] = ..., fallback: bool = ...
) -> Tuple[List[Distribution], Dict[Distribution, Exception]]: ...
working_set: WorkingSet
def require(*requirements: _NestedStr) -> Sequence[Distribution]: ...
def run_script(requires: str, script_name: str) -> None: ...
def iter_entry_points(group: str, name: Optional[str] = ...) -> Generator[EntryPoint, None, None]: ...
def add_activation_listener(callback: Callable[[Distribution], None]) -> None: ...
class Environment:
def __init__(
self, search_path: Optional[Sequence[str]] = ..., platform: Optional[str] = ..., python: Optional[str] = ...
) -> None: ...
def __getitem__(self, project_name: str) -> List[Distribution]: ...
def __iter__(self) -> Generator[str, None, None]: ...
def add(self, dist: Distribution) -> None: ...
def remove(self, dist: Distribution) -> None: ...
def can_add(self, dist: Distribution) -> bool: ...
def __add__(self, other: Union[Distribution, Environment]) -> Environment: ...
def __iadd__(self, other: Union[Distribution, Environment]) -> Environment: ...
@overload
def best_match(self, req: Requirement, working_set: WorkingSet) -> Distribution: ...
@overload
def best_match(self, req: Requirement, working_set: WorkingSet, installer: Callable[[Requirement], _T] = ...) -> _T: ...
@overload
def obtain(self, requirement: Requirement) -> None: ...
@overload
def obtain(self, requirement: Requirement, installer: Callable[[Requirement], _T] = ...) -> _T: ...
def scan(self, search_path: Optional[Sequence[str]] = ...) -> None: ...
def parse_requirements(strs: Union[str, Iterable[str]]) -> Generator[Requirement, None, None]: ...
class Requirement:
unsafe_name: str
project_name: str
key: str
extras: Tuple[str, ...]
specs: List[Tuple[str, str]]
# TODO: change this to Optional[packaging.markers.Marker] once we can import
# packaging.markers
marker: Optional[Any]
@staticmethod
def parse(s: Union[str, Iterable[str]]) -> Requirement: ...
def __contains__(self, item: Union[Distribution, str, Tuple[str, ...]]) -> bool: ...
def __eq__(self, other_requirement: Any) -> bool: ...
def load_entry_point(dist: _EPDistType, group: str, name: str) -> Any: ...
def get_entry_info(dist: _EPDistType, group: str, name: str) -> Optional[EntryPoint]: ...
@overload
def get_entry_map(dist: _EPDistType) -> Dict[str, Dict[str, EntryPoint]]: ...
@overload
def get_entry_map(dist: _EPDistType, group: str) -> Dict[str, EntryPoint]: ...
class EntryPoint:
name: str
module_name: str
attrs: Tuple[str, ...]
extras: Tuple[str, ...]
dist: Optional[Distribution]
def __init__(
self,
name: str,
module_name: str,
attrs: Tuple[str, ...] = ...,
extras: Tuple[str, ...] = ...,
dist: Optional[Distribution] = ...,
) -> None: ...
@classmethod
def parse(cls, src: str, dist: Optional[Distribution] = ...) -> EntryPoint: ...
@classmethod
def parse_group(
cls, group: str, lines: Union[str, Sequence[str]], dist: Optional[Distribution] = ...
) -> Dict[str, EntryPoint]: ...
@classmethod
def parse_map(
cls, data: Union[Dict[str, Union[str, Sequence[str]]], str, Sequence[str]], dist: Optional[Distribution] = ...
) -> Dict[str, EntryPoint]: ...
def load(self, require: bool = ..., env: Optional[Environment] = ..., installer: Optional[_InstallerType] = ...) -> Any: ...
def require(self, env: Optional[Environment] = ..., installer: Optional[_InstallerType] = ...) -> None: ...
def resolve(self) -> Any: ...
def find_distributions(path_item: str, only: bool = ...) -> Generator[Distribution, None, None]: ...
def get_distribution(dist: Union[Requirement, str, Distribution]) -> Distribution: ...
class Distribution(IResourceProvider, IMetadataProvider):
PKG_INFO: str
location: str
project_name: str
key: str
extras: List[str]
version: str
parsed_version: Tuple[str, ...]
py_version: str
platform: Optional[str]
precedence: int
def __init__(
self,
location: Optional[str] = ...,
metadata: _MetadataType = ...,
project_name: Optional[str] = ...,
version: Optional[str] = ...,
py_version: str = ...,
platform: Optional[str] = ...,
precedence: int = ...,
) -> None: ...
@classmethod
def from_location(
cls, location: str, basename: str, metadata: _MetadataType = ..., **kw: Union[str, None, int]
) -> Distribution: ...
@classmethod
def from_filename(cls, filename: str, metadata: _MetadataType = ..., **kw: Union[str, None, int]) -> Distribution: ...
def activate(self, path: Optional[List[str]] = ...) -> None: ...
def as_requirement(self) -> Requirement: ...
def requires(self, extras: Tuple[str, ...] = ...) -> List[Requirement]: ...
def clone(self, **kw: Union[str, int, None]) -> Requirement: ...
def egg_name(self) -> str: ...
def __cmp__(self, other: Any) -> bool: ...
def get_entry_info(self, group: str, name: str) -> Optional[EntryPoint]: ...
@overload
def get_entry_map(self) -> Dict[str, Dict[str, EntryPoint]]: ...
@overload
def get_entry_map(self, group: str) -> Dict[str, EntryPoint]: ...
def load_entry_point(self, group: str, name: str) -> Any: ...
EGG_DIST: int
BINARY_DIST: int
SOURCE_DIST: int
CHECKOUT_DIST: int
DEVELOP_DIST: int
def resource_exists(package_or_requirement: _PkgReqType, resource_name: str) -> bool: ...
def resource_stream(package_or_requirement: _PkgReqType, resource_name: str) -> IO[bytes]: ...
def resource_string(package_or_requirement: _PkgReqType, resource_name: str) -> bytes: ...
def resource_isdir(package_or_requirement: _PkgReqType, resource_name: str) -> bool: ...
def resource_listdir(package_or_requirement: _PkgReqType, resource_name: str) -> List[str]: ...
def resource_filename(package_or_requirement: _PkgReqType, resource_name: str) -> str: ...
def set_extraction_path(path: str) -> None: ...
def cleanup_resources(force: bool = ...) -> List[str]: ...
class IResourceManager:
def resource_exists(self, package_or_requirement: _PkgReqType, resource_name: str) -> bool: ...
def resource_stream(self, package_or_requirement: _PkgReqType, resource_name: str) -> IO[bytes]: ...
def resource_string(self, package_or_requirement: _PkgReqType, resource_name: str) -> bytes: ...
def resource_isdir(self, package_or_requirement: _PkgReqType, resource_name: str) -> bool: ...
def resource_listdir(self, package_or_requirement: _PkgReqType, resource_name: str) -> List[str]: ...
def resource_filename(self, package_or_requirement: _PkgReqType, resource_name: str) -> str: ...
def set_extraction_path(self, path: str) -> None: ...
def cleanup_resources(self, force: bool = ...) -> List[str]: ...
def get_cache_path(self, archive_name: str, names: Iterable[str] = ...) -> str: ...
def extraction_error(self) -> None: ...
def postprocess(self, tempname: str, filename: str) -> None: ...
@overload
def get_provider(package_or_requirement: str) -> IResourceProvider: ...
@overload
def get_provider(package_or_requirement: Requirement) -> Distribution: ...
class IMetadataProvider:
def has_metadata(self, name: str) -> bool: ...
def metadata_isdir(self, name: str) -> bool: ...
def metadata_listdir(self, name: str) -> List[str]: ...
def get_metadata(self, name: str) -> str: ...
def get_metadata_lines(self, name: str) -> Generator[str, None, None]: ...
def run_script(self, script_name: str, namespace: Dict[str, Any]) -> None: ...
class ResolutionError(Exception): ...
class DistributionNotFound(ResolutionError):
@property
def req(self) -> Requirement: ...
@property
def requirers(self) -> Set[str]: ...
@property
def requirers_str(self) -> str: ...
def report(self) -> str: ...
class VersionConflict(ResolutionError):
@property
def dist(self) -> Any: ...
@property
def req(self) -> Any: ...
def report(self) -> str: ...
def with_context(self, required_by: Set[Union[Distribution, str]]) -> VersionConflict: ...
class ContextualVersionConflict(VersionConflict):
@property
def required_by(self) -> Set[Union[Distribution, str]]: ...
class UnknownExtra(ResolutionError): ...
class ExtractionError(Exception):
manager: IResourceManager
cache_path: str
original_error: Exception
class _Importer(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader, metaclass=ABCMeta): ...
def register_finder(importer_type: type, distribution_finder: _DistFinderType) -> None: ...
def register_loader_type(loader_type: type, provider_factory: Callable[[types.ModuleType], IResourceProvider]) -> None: ...
def register_namespace_handler(importer_type: type, namespace_handler: _NSHandlerType) -> None: ...
class IResourceProvider(IMetadataProvider): ...
class NullProvider: ...
class EggProvider(NullProvider): ...
class DefaultProvider(EggProvider): ...
class PathMetadata(DefaultProvider, IResourceProvider):
def __init__(self, path: str, egg_info: str) -> None: ...
class ZipProvider(EggProvider): ...
class EggMetadata(ZipProvider, IResourceProvider):
def __init__(self, zipimporter: zipimport.zipimporter) -> None: ...
class EmptyProvider(NullProvider): ...
empty_provider: EmptyProvider
class FileMetadata(EmptyProvider, IResourceProvider):
def __init__(self, path_to_pkg_info: str) -> None: ...
def parse_version(v: str) -> Tuple[str, ...]: ...
def yield_lines(strs: _NestedStr) -> Generator[str, None, None]: ...
def split_sections(strs: _NestedStr) -> Generator[Tuple[Optional[str], str], None, None]: ...
def safe_name(name: str) -> str: ...
def safe_version(version: str) -> str: ...
def safe_extra(extra: str) -> str: ...
def to_filename(name_or_version: str) -> str: ...
def get_build_platform() -> str: ...
def get_platform() -> str: ...
def get_supported_platform() -> str: ...
def compatible_platforms(provided: Optional[str], required: Optional[str]) -> bool: ...
def get_default_cache() -> str: ...
def get_importer(path_item: str) -> _Importer: ...
def ensure_directory(path: str) -> None: ...
def normalize_path(filename: str) -> str: ...
| 12,105 | Python | .py | 238 | 46.865546 | 128 | 0.662667 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,851 | rfc7230.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/rfc7230.pyi | from typing import Pattern
from .compat import tobytes as tobytes
WS: str
OWS: str
RWS: str
BWS = str
TCHAR: str
OBS_TEXT: str
TOKEN: str
VCHAR: str
FIELD_VCHAR: str
FIELD_CONTENT: str
FIELD_VALUE: str
HEADER_FIELD: Pattern
| 226 | Python | .py | 14 | 15 | 38 | 0.814286 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,852 | proxy_headers.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/proxy_headers.pyi | from collections import namedtuple
from logging import Logger
from typing import Any, Callable, Mapping, Optional, Sequence, Set
from .utilities import BadRequest as BadRequest
PROXY_HEADERS: frozenset
Forwarded = namedtuple("Forwarded", ["by", "for_", "host", "proto"])
class MalformedProxyHeader(Exception):
header: str = ...
reason: str = ...
value: str = ...
def __init__(self, header: str, reason: str, value: str) -> None: ...
def proxy_headers_middleware(
app: Any,
trusted_proxy: Optional[str] = ...,
trusted_proxy_count: int = ...,
trusted_proxy_headers: Optional[Set[str]] = ...,
clear_untrusted: bool = ...,
log_untrusted: bool = ...,
logger: Logger = ...,
) -> Callable[..., Any]: ...
def parse_proxy_headers(
environ: Mapping[str, str], trusted_proxy_count: int, trusted_proxy_headers: Set[str], logger: Logger = ...
) -> Set[str]: ...
def strip_brackets(addr: str) -> str: ...
def clear_untrusted_headers(
environ: Mapping[str, str], untrusted_headers: Sequence[str], log_warning: bool = ..., logger: Logger = ...
) -> None: ...
| 1,100 | Python | .py | 27 | 37.62963 | 111 | 0.661049 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,853 | channel.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/channel.pyi | from socket import SocketType
from threading import Condition, Lock
from typing import Mapping, Optional, Sequence, Tuple
from waitress.adjustments import Adjustments
from waitress.buffers import OverflowableBuffer
from waitress.parser import HTTPRequestParser
from waitress.server import BaseWSGIServer
from waitress.task import ErrorTask, WSGITask
from . import wasyncore as wasyncore
class ClientDisconnected(Exception): ...
class HTTPChannel(wasyncore.dispatcher):
task_class: WSGITask = ...
error_task_class: ErrorTask = ...
parser_class: HTTPRequestParser = ...
request: HTTPRequestParser = ...
last_activity: float = ...
will_close: bool = ...
close_when_flushed: bool = ...
requests: Sequence[HTTPRequestParser] = ...
sent_continue: bool = ...
total_outbufs_len: int = ...
current_outbuf_count: int = ...
server: BaseWSGIServer = ...
adj: Adjustments = ...
outbufs: Sequence[OverflowableBuffer] = ...
creation_time: float = ...
sendbuf_len: int = ...
task_lock: Lock = ...
outbuf_lock: Condition = ...
addr: Tuple[str, int] = ...
def __init__(
self, server: BaseWSGIServer, sock: SocketType, addr: str, adj: Adjustments, map: Optional[Mapping[int, SocketType]] = ...
) -> None: ...
def writable(self) -> bool: ...
def handle_write(self) -> None: ...
def readable(self) -> bool: ...
def handle_read(self) -> None: ...
def received(self, data: bytes) -> bool: ...
connected: bool = ...
def handle_close(self) -> None: ...
def add_channel(self, map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
def del_channel(self, map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
def write_soon(self, data: bytes) -> int: ...
def service(self) -> None: ...
def cancel(self) -> None: ...
| 1,843 | Python | .py | 45 | 36.755556 | 130 | 0.660535 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,854 | task.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/task.pyi | from logging import Logger
from threading import Condition, Lock
from typing import Any, Deque, Mapping, Optional, Sequence, Set, Tuple
from .channel import HTTPChannel
from .utilities import Error
rename_headers: Mapping[str, str]
hop_by_hop: frozenset
class ThreadedTaskDispatcher:
stop_count: int = ...
active_count: int = ...
logger: Logger = ...
queue_logger: Logger = ...
threads: Set = ...
queue: Deque[Task] = ...
lock: Lock = ...
queue_cv: Condition = ...
thread_exit_cv: Condition = ...
def __init__(self) -> None: ...
def start_new_thread(self, target: Any, args: Any) -> None: ...
def handler_thread(self, thread_no: int) -> None: ...
def set_thread_count(self, count: int) -> None: ...
def add_task(self, task: Task) -> None: ...
def shutdown(self, cancel_pending: bool = ..., timeout: int = ...) -> bool: ...
class Task:
close_on_finish: bool = ...
status: str = ...
wrote_header: bool = ...
start_time: int = ...
content_length: Optional[int] = ...
content_bytes_written: int = ...
logged_write_excess: bool = ...
logged_write_no_body: bool = ...
complete: bool = ...
chunked_response: bool = ...
logger: Logger = ...
channel: HTTPChannel = ...
request: Error = ...
response_headers: Sequence[Tuple[str, str]] = ...
version: str = ...
def __init__(self, channel: HTTPChannel, request: Error) -> None: ...
def service(self) -> None: ...
@property
def has_body(self) -> bool: ...
def build_response_header(self) -> bytes: ...
def remove_content_length_header(self) -> None: ...
def start(self) -> None: ...
def finish(self) -> None: ...
def write(self, data: bytes) -> None: ...
class ErrorTask(Task):
complete: bool = ...
status: str = ...
close_on_finish: bool = ...
content_length: int = ...
def execute(self) -> None: ...
class WSGITask(Task):
environ: Optional[Any] = ...
response_headers: Sequence[Tuple[str, str]] = ...
complete: bool = ...
status: str = ...
content_length: int = ...
close_on_finish: bool = ...
def execute(self) -> None: ...
def get_environment(self) -> Any: ...
| 2,216 | Python | .py | 63 | 30.777778 | 83 | 0.599907 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,855 | server.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/server.pyi | from socket import SocketType
from typing import Any, Optional, Sequence, Tuple, Union
from waitress.adjustments import Adjustments
from waitress.channel import HTTPChannel
from waitress.task import Task, ThreadedTaskDispatcher
from . import wasyncore
def create_server(
application: Any,
map: Optional[Any] = ...,
_start: bool = ...,
_sock: Optional[SocketType] = ...,
_dispatcher: Optional[ThreadedTaskDispatcher] = ...,
**kw: Any,
) -> Union[MultiSocketServer, BaseWSGIServer]: ...
class MultiSocketServer:
asyncore: Any = ...
adj: Adjustments = ...
map: Any = ...
effective_listen: Sequence[Tuple[str, int]] = ...
task_dispatcher: ThreadedTaskDispatcher = ...
def __init__(
self,
map: Optional[Any] = ...,
adj: Optional[Adjustments] = ...,
effective_listen: Optional[Sequence[Tuple[str, int]]] = ...,
dispatcher: Optional[ThreadedTaskDispatcher] = ...,
) -> None: ...
def print_listen(self, format_str: str) -> None: ...
def run(self) -> None: ...
def close(self) -> None: ...
class BaseWSGIServer(wasyncore.dispatcher):
channel_class: HTTPChannel = ...
next_channel_cleanup: int = ...
socketmod: SocketType = ...
asyncore: Any = ...
sockinfo: Tuple[int, int, int, Tuple[str, int]] = ...
family: int = ...
socktype: int = ...
application: Any = ...
adj: Adjustments = ...
trigger: int = ...
task_dispatcher: ThreadedTaskDispatcher = ...
server_name: str = ...
active_channels: HTTPChannel = ...
def __init__(
self,
application: Any,
map: Optional[Any] = ...,
_start: bool = ...,
_sock: Optional[Any] = ...,
dispatcher: Optional[ThreadedTaskDispatcher] = ...,
adj: Optional[Adjustments] = ...,
sockinfo: Optional[Any] = ...,
bind_socket: bool = ...,
**kw: Any,
) -> None: ...
def bind_server_socket(self) -> None: ...
def get_server_name(self, ip: str) -> str: ...
def getsockname(self) -> Any: ...
accepting: bool = ...
def accept_connections(self) -> None: ...
def add_task(self, task: Task) -> None: ...
def readable(self) -> bool: ...
def writable(self) -> bool: ...
def handle_read(self) -> None: ...
def handle_connect(self) -> None: ...
def handle_accept(self) -> None: ...
def run(self) -> None: ...
def pull_trigger(self) -> None: ...
def set_socket_options(self, conn: Any) -> None: ...
def fix_addr(self, addr: Any) -> Any: ...
def maintenance(self, now: int) -> None: ...
def print_listen(self, format_str: str) -> None: ...
def close(self) -> None: ...
class TcpWSGIServer(BaseWSGIServer):
def bind_server_socket(self) -> None: ...
def getsockname(self) -> Tuple[str, Tuple[str, int]]: ...
def set_socket_options(self, conn: SocketType) -> None: ...
class UnixWSGIServer(BaseWSGIServer):
def __init__(
self,
application: Any,
map: Optional[Any] = ...,
_start: bool = ...,
_sock: Optional[Any] = ...,
dispatcher: Optional[Any] = ...,
adj: Optional[Adjustments] = ...,
sockinfo: Optional[Any] = ...,
**kw: Any,
) -> None: ...
def bind_server_socket(self) -> None: ...
def getsockname(self) -> Tuple[str, Tuple[str, int]]: ...
def fix_addr(self, addr: Any) -> Tuple[str, None]: ...
def get_server_name(self, ip: Any) -> str: ...
WSGIServer: TcpWSGIServer
| 3,500 | Python | .py | 95 | 31.294737 | 68 | 0.590521 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,856 | utilities.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/utilities.pyi | from logging import Logger
from typing import Any, Callable, Mapping, Match, Pattern, Sequence, Tuple
from .rfc7230 import OBS_TEXT as OBS_TEXT, VCHAR as VCHAR
logger: Logger
queue_logger: Logger
def find_double_newline(s: bytes) -> int: ...
def concat(*args: Any) -> str: ...
def join(seq: Any, field: str = ...) -> str: ...
def group(s: Any) -> str: ...
short_days: Sequence[str]
long_days: Sequence[str]
short_day_reg: str
long_day_reg: str
daymap: Mapping[str, int]
hms_reg: str
months: Sequence[str]
monmap: Mapping[str, int]
months_reg: str
rfc822_date: str
rfc822_reg: Pattern
def unpack_rfc822(m: Match) -> Tuple[int, int, int, int, int, int, int, int, int]: ...
rfc850_date: str
rfc850_reg: Pattern
def unpack_rfc850(m: Match) -> Tuple[int, int, int, int, int, int, int, int, int]: ...
weekdayname: Sequence[str]
monthname: Sequence[str]
def build_http_date(when: int) -> str: ...
def parse_http_date(d: str) -> int: ...
vchar_re: str
obs_text_re: str
qdtext_re: str
quoted_pair_re: str
quoted_string_re: str
quoted_string: Pattern
quoted_pair: Pattern
def undquote(value: str) -> str: ...
def cleanup_unix_socket(path: str) -> None: ...
class Error:
code: int = ...
reason: str = ...
body: str = ...
def __init__(self, body: str) -> None: ...
def to_response(self) -> Tuple[str, Sequence[Tuple[str, str]], str]: ...
def wsgi_response(self, environ: Any, start_response: Callable[[str, Sequence[Tuple[str, str]]], None]) -> str: ...
class BadRequest(Error):
code: int = ...
reason: str = ...
class RequestHeaderFieldsTooLarge(BadRequest):
code: int = ...
reason: str = ...
class RequestEntityTooLarge(BadRequest):
code: int = ...
reason: str = ...
class InternalServerError(Error):
code: int = ...
reason: str = ...
class ServerNotImplemented(Error):
code: int = ...
reason: str = ...
| 1,875 | Python | .py | 59 | 29.40678 | 119 | 0.673708 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,857 | adjustments.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/adjustments.pyi | from socket import SocketType
from typing import Any, Dict, FrozenSet, Iterable, List, Optional, Sequence, Set, Tuple, Union
from .compat import HAS_IPV6 as HAS_IPV6, PY2 as PY2, WIN as WIN, string_types as string_types
from .proxy_headers import PROXY_HEADERS as PROXY_HEADERS
truthy: FrozenSet
KNOWN_PROXY_HEADERS: FrozenSet
def asbool(s: Optional[Union[bool, str, int]]) -> bool: ...
def asoctal(s: str) -> int: ...
def aslist_cronly(value: str) -> List[str]: ...
def aslist(value: str) -> List[str]: ...
def asset(value: Optional[str]) -> Set[str]: ...
def slash_fixed_str(s: Optional[str]) -> str: ...
def str_iftruthy(s: Optional[str]) -> Optional[str]: ...
def as_socket_list(sockets: Sequence[object]) -> List[SocketType]: ...
class _str_marker(str): ...
class _int_marker(int): ...
class _bool_marker: ...
class Adjustments:
host: _str_marker = ...
port: _int_marker = ...
listen: List[str] = ...
threads: int = ...
trusted_proxy: Optional[str] = ...
trusted_proxy_count: Optional[int] = ...
trusted_proxy_headers: Set[str] = ...
log_untrusted_proxy_headers: bool = ...
clear_untrusted_proxy_headers: Union[_bool_marker, bool] = ...
url_scheme: str = ...
url_prefix: str = ...
ident: str = ...
backlog: int = ...
recv_bytes: int = ...
send_bytes: int = ...
outbuf_overflow: int = ...
outbuf_high_watermark: int = ...
inbuf_overflow: int = ...
connection_limit: int = ...
cleanup_interval: int = ...
channel_timeout: int = ...
log_socket_errors: bool = ...
max_request_header_size: int = ...
max_request_body_size: int = ...
expose_tracebacks: bool = ...
unix_socket: Optional[str] = ...
unix_socket_perms: int = ...
socket_options: List[Tuple[int, int, int]] = ...
asyncore_loop_timeout: int = ...
asyncore_use_poll: bool = ...
ipv4: bool = ...
ipv6: bool = ...
sockets: List[SocketType] = ...
def __init__(self, **kw: Any) -> None: ...
@classmethod
def parse_args(cls, argv: str) -> Tuple[Dict[str, Any], Any]: ...
@classmethod
def check_sockets(cls, sockets: Iterable[SocketType]) -> None: ...
| 2,162 | Python | .py | 56 | 34.803571 | 94 | 0.624941 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,858 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/__init__.pyi | from typing import Any, Tuple
from waitress.server import create_server as create_server
def serve(app: Any, **kw: Any) -> None: ...
def serve_paste(app: Any, global_conf: Any, **kw: Any) -> int: ...
def profile(cmd: Any, globals: Any, locals: Any, sort_order: Tuple[str, ...], callers: bool) -> None: ...
| 308 | Python | .py | 5 | 60.2 | 105 | 0.677741 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,859 | parser.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/parser.pyi | from io import BytesIO
from typing import Mapping, Optional, Pattern, Sequence, Tuple, Union
from waitress.adjustments import Adjustments
from waitress.receiver import ChunkedReceiver, FixedStreamReceiver
from waitress.utilities import Error
from .rfc7230 import HEADER_FIELD as HEADER_FIELD
class ParsingError(Exception): ...
class TransferEncodingNotImplemented(Exception): ...
class HTTPRequestParser:
completed: bool = ...
empty: bool = ...
expect_continue: bool = ...
headers_finished: bool = ...
header_plus: bytes = ...
chunked: bool = ...
content_length: int = ...
header_bytes_received: int = ...
body_bytes_received: int = ...
body_rcv: Optional[Union[ChunkedReceiver, FixedStreamReceiver]] = ...
version: str = ...
error: Optional[Error] = ...
connection_close: bool = ...
headers: Mapping[str, str] = ...
adj: Adjustments = ...
def __init__(self, adj: Adjustments) -> None: ...
def received(self, data: bytes) -> int: ...
first_line: str = ...
command: bytes = ...
url_scheme: str = ...
def parse_header(self, header_plus: bytes) -> None: ...
def get_body_stream(self) -> BytesIO: ...
def close(self) -> None: ...
def split_uri(uri: bytes) -> Tuple[str, str, bytes, str, str]: ...
def get_header_lines(header: bytes) -> Sequence[bytes]: ...
first_line_re: Pattern
def crack_first_line(line: str) -> Tuple[bytes, bytes, bytes]: ...
| 1,442 | Python | .py | 36 | 36.305556 | 73 | 0.66762 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,860 | wasyncore.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/wasyncore.pyi | from io import BytesIO
from logging import Logger
from socket import SocketType
from typing import Any, Callable, Mapping, Optional, Tuple
from . import compat as compat, utilities as utilities
socket_map: Mapping[int, SocketType]
map: Mapping[int, SocketType]
class ExitNow(Exception): ...
def read(obj: dispatcher) -> None: ...
def write(obj: dispatcher) -> None: ...
def readwrite(obj: dispatcher, flags: int) -> None: ...
def poll(timeout: float = ..., map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
def poll2(timeout: float = ..., map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
poll3 = poll2
def loop(
timeout: float = ..., use_poll: bool = ..., map: Optional[Mapping[int, SocketType]] = ..., count: Optional[int] = ...
) -> None: ...
def compact_traceback() -> Tuple[Tuple[str, str, str], BaseException, BaseException, str]: ...
class dispatcher:
debug: bool = ...
connected: bool = ...
accepting: bool = ...
connecting: bool = ...
closing: bool = ...
addr: Optional[Tuple[str, int]] = ...
ignore_log_types: frozenset = ...
logger: Logger = ...
compact_traceback: Callable[[], Tuple[Tuple[str, str, str], BaseException, BaseException, str]] = ...
socket: Optional[SocketType] = ...
def __init__(self, sock: Optional[SocketType] = ..., map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
def add_channel(self, map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
def del_channel(self, map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
family_and_type: Tuple[int, int] = ...
def create_socket(self, family: int = ..., type: int = ...) -> None: ...
def set_socket(self, sock: SocketType, map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
def set_reuse_addr(self) -> None: ...
def readable(self) -> bool: ...
def writable(self) -> bool: ...
def listen(self, num: int) -> None: ...
def bind(self, addr: Tuple[str, int]) -> None: ...
def connect(self, address: Tuple[str, int]) -> None: ...
def accept(self) -> Optional[Tuple[SocketType, Tuple[str, int]]]: ...
def send(self, data: bytes) -> int: ...
def recv(self, buffer_size: int) -> bytes: ...
def close(self) -> None: ...
def log(self, message: str) -> None: ...
def log_info(self, message: str, type: str = ...) -> None: ...
def handle_read_event(self) -> None: ...
def handle_connect_event(self) -> None: ...
def handle_write_event(self) -> None: ...
def handle_expt_event(self) -> None: ...
def handle_error(self) -> None: ...
def handle_expt(self) -> None: ...
def handle_read(self) -> None: ...
def handle_write(self) -> None: ...
def handle_connect(self) -> None: ...
def handle_accept(self) -> None: ...
def handle_accepted(self, sock: SocketType, addr: Any) -> None: ...
def handle_close(self) -> None: ...
class dispatcher_with_send(dispatcher):
out_buffer: bytes = ...
def __init__(self, sock: Optional[SocketType] = ..., map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
def initiate_send(self) -> None: ...
handle_write: Callable[[], None] = ...
def writable(self) -> bool: ...
def send(self, data: bytes) -> None: ... # type: ignore
def close_all(map: Optional[Mapping[int, SocketType]] = ..., ignore_all: bool = ...) -> None: ...
class file_wrapper:
fd: BytesIO = ...
def __init__(self, fd: BytesIO) -> None: ...
def __del__(self) -> None: ...
def recv(self, *args: Any) -> bytes: ...
def send(self, *args: Any) -> bytes: ...
def getsockopt(self, level: int, optname: int, buflen: Optional[bool] = ...) -> int: ...
read: Callable[..., bytes] = ...
write: Callable[..., bytes] = ...
def close(self) -> None: ...
def fileno(self) -> BytesIO: ...
class file_dispatcher(dispatcher):
connected: bool = ...
def __init__(self, fd: BytesIO, map: Optional[Mapping[int, SocketType]] = ...) -> None: ...
socket: SocketType = ...
def set_file(self, fd: BytesIO) -> None: ...
| 4,059 | Python | .py | 83 | 44.831325 | 121 | 0.604288 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,861 | runner.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/runner.pyi | from io import TextIOWrapper
from typing import Any, Callable, Optional, Pattern, Sequence, Tuple
HELP: str
RUNNER_PATTERN: Pattern
def match(obj_name: str) -> Tuple[str, str]: ...
def resolve(module_name: str, object_name: str) -> Any: ...
def show_help(stream: TextIOWrapper, name: str, error: Optional[str] = ...) -> None: ...
def show_exception(stream: TextIOWrapper) -> None: ...
def run(argv: Sequence[str] = ..., _serve: Callable[..., Any] = ...) -> None: ...
| 469 | Python | .py | 9 | 50.888889 | 88 | 0.681223 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,862 | trigger.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/trigger.pyi | import sys
from socket import SocketType
from threading import Lock
from typing import Callable, Mapping, Optional
from typing_extensions import Literal
from . import wasyncore as wasyncore
class _triggerbase:
kind: Optional[str] = ...
lock: Lock = ...
thunks: Callable[[None], None] = ...
def __init__(self) -> None: ...
def readable(self) -> Literal[True]: ...
def writable(self) -> Literal[False]: ...
def handle_connect(self) -> None: ...
def handle_close(self) -> None: ...
def close(self) -> None: ...
def pull_trigger(self, thunk: Optional[Callable[[None], None]] = ...) -> None: ...
def handle_read(self) -> None: ...
if sys.platform == "linux" or sys.platform == "darwin":
class trigger(_triggerbase, wasyncore.file_dispatcher):
kind: str = ...
def __init__(self, map: Mapping[str, _triggerbase]) -> None: ...
else:
class trigger(_triggerbase, wasyncore.dispatcher):
kind: str = ...
trigger: SocketType = ...
def __init__(self, map: Mapping[str, _triggerbase]) -> None: ...
| 1,079 | Python | .py | 27 | 35.407407 | 86 | 0.630725 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,863 | buffers.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/buffers.pyi | from io import BufferedIOBase, BufferedRandom, BytesIO
from typing import Any, Callable, Optional
COPY_BYTES: int
STRBUF_LIMIT: int
class FileBasedBuffer:
remain: int = ...
file: BytesIO = ...
def __init__(self, file: BytesIO, from_buffer: Optional[BytesIO] = ...) -> None: ...
def __len__(self) -> int: ...
def __nonzero__(self) -> bool: ...
__bool__: Callable[[], bool] = ...
def append(self, s: Any) -> None: ...
def get(self, numbytes: int = ..., skip: bool = ...) -> bytes: ...
def skip(self, numbytes: int, allow_prune: int = ...) -> None: ...
def newfile(self) -> Any: ...
def prune(self) -> None: ...
def getfile(self) -> Any: ...
def close(self) -> None: ...
class TempfileBasedBuffer(FileBasedBuffer):
def __init__(self, from_buffer: Optional[BytesIO] = ...) -> None: ...
def newfile(self) -> BufferedRandom: ...
class BytesIOBasedBuffer(FileBasedBuffer):
file: BytesIO = ...
def __init__(self, from_buffer: Optional[BytesIO] = ...) -> None: ...
def newfile(self) -> BytesIO: ...
class ReadOnlyFileBasedBuffer(FileBasedBuffer):
file: BytesIO = ...
block_size: int = ...
def __init__(self, file: BytesIO, block_size: int = ...) -> None: ...
remain: int = ...
def prepare(self, size: Optional[int] = ...) -> int: ...
def get(self, numbytes: int = ..., skip: bool = ...) -> bytes: ...
def __iter__(self) -> ReadOnlyFileBasedBuffer: ...
def next(self) -> Optional[bytes]: ...
__next__: Callable[[], Optional[bytes]] = ...
def append(self, s: Any) -> None: ...
class OverflowableBuffer:
overflowed: bool = ...
buf: Optional[BufferedIOBase] = ...
strbuf: bytes = ...
overflow: int = ...
def __init__(self, overflow: int) -> None: ...
def __len__(self) -> int: ...
def __nonzero__(self) -> bool: ...
__bool__: Callable[[], bool] = ...
def append(self, s: bytes) -> None: ...
def get(self, numbytes: int = ..., skip: bool = ...) -> bytes: ...
def skip(self, numbytes: int, allow_prune: bool = ...) -> None: ...
def prune(self) -> None: ...
def getfile(self) -> BytesIO: ...
def close(self) -> None: ...
| 2,179 | Python | .py | 51 | 38.313725 | 88 | 0.571631 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,864 | compat.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/compat.pyi | import sys
from io import TextIOWrapper
from typing import Any, Optional, Tuple
PY2: bool
PY3: bool
WIN: bool
string_types: Tuple[
str,
]
integer_types: Tuple[
int,
]
class_types: Tuple[
type,
]
text_type = str
binary_type = bytes
long = int
def unquote_bytes_to_wsgi(bytestring: bytes) -> str: ...
def text_(s: str, encoding: str = ..., errors: str = ...) -> str: ...
def tostr(s: str) -> str: ...
def tobytes(s: str) -> bytes: ...
exec_: Any
def reraise(tp: Any, value: BaseException, tb: Optional[str] = ...) -> None: ...
MAXINT: int
HAS_IPV6: bool
IPPROTO_IPV6: int
IPV6_V6ONLY: int
def set_nonblocking(fd: TextIOWrapper) -> None: ...
ResourceWarning: Warning
def qualname(cls: Any) -> str: ...
| 719 | Python | .py | 31 | 21.548387 | 80 | 0.686765 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,865 | receiver.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/waitress/receiver.pyi | from io import BytesIO
from typing import Optional
from waitress.buffers import OverflowableBuffer
from waitress.utilities import BadRequest
class FixedStreamReceiver:
completed: bool = ...
error: None = ...
remain: int = ...
buf: OverflowableBuffer = ...
def __init__(self, cl: int, buf: OverflowableBuffer) -> None: ...
def __len__(self) -> int: ...
def received(self, data: bytes) -> int: ...
def getfile(self) -> BytesIO: ...
def getbuf(self) -> OverflowableBuffer: ...
class ChunkedReceiver:
chunk_remainder: int = ...
validate_chunk_end: bool = ...
control_line: bytes = ...
chunk_end: bytes = ...
all_chunks_received: bool = ...
trailer: bytes = ...
completed: bool = ...
error: Optional[BadRequest] = ...
buf: OverflowableBuffer = ...
def __init__(self, buf: OverflowableBuffer) -> None: ...
def __len__(self) -> int: ...
def received(self, s: bytes) -> int: ...
def getfile(self) -> BytesIO: ...
def getbuf(self) -> OverflowableBuffer: ...
| 1,044 | Python | .py | 29 | 31.724138 | 69 | 0.625494 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,866 | conversions.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/typed_ast/conversions.pyi | from . import ast3, ast27
def py2to3(ast: ast27.AST) -> ast3.AST: ...
| 71 | Python | .py | 2 | 34 | 43 | 0.676471 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,867 | ast27.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/typed_ast/ast27.pyi | import typing
from typing import Any, Iterator, Optional, Union
class NodeVisitor:
def visit(self, node: AST) -> Any: ...
def generic_visit(self, node: AST) -> None: ...
class NodeTransformer(NodeVisitor):
def generic_visit(self, node: AST) -> None: ...
def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ...) -> AST: ...
def copy_location(new_node: AST, old_node: AST) -> AST: ...
def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ...
def fix_missing_locations(node: AST) -> AST: ...
def get_docstring(node: AST, clean: bool = ...) -> Optional[bytes]: ...
def increment_lineno(node: AST, n: int = ...) -> AST: ...
def iter_child_nodes(node: AST) -> Iterator[AST]: ...
def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ...
def literal_eval(node_or_string: Union[str, AST]) -> Any: ...
def walk(node: AST) -> Iterator[AST]: ...
PyCF_ONLY_AST: int
# ast classes
identifier = str
class AST:
_attributes: typing.Tuple[str, ...]
_fields: typing.Tuple[str, ...]
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
class mod(AST): ...
class Module(mod):
body: typing.List[stmt]
type_ignores: typing.List[TypeIgnore]
class Interactive(mod):
body: typing.List[stmt]
class Expression(mod):
body: expr
class FunctionType(mod):
argtypes: typing.List[expr]
returns: expr
class Suite(mod):
body: typing.List[stmt]
class stmt(AST):
lineno: int
col_offset: int
class FunctionDef(stmt):
name: identifier
args: arguments
body: typing.List[stmt]
decorator_list: typing.List[expr]
type_comment: Optional[str]
class ClassDef(stmt):
name: identifier
bases: typing.List[expr]
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
type_comment: Optional[str]
class AugAssign(stmt):
target: expr
op: operator
value: expr
class Print(stmt):
dest: Optional[expr]
values: typing.List[expr]
nl: bool
class For(stmt):
target: expr
iter: expr
body: typing.List[stmt]
orelse: typing.List[stmt]
type_comment: Optional[str]
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):
context_expr: expr
optional_vars: Optional[expr]
body: typing.List[stmt]
type_comment: Optional[str]
class Raise(stmt):
type: Optional[expr]
inst: Optional[expr]
tback: Optional[expr]
class TryExcept(stmt):
body: typing.List[stmt]
handlers: typing.List[ExceptHandler]
orelse: typing.List[stmt]
class TryFinally(stmt):
body: 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: Optional[int]
class Exec(stmt):
body: expr
globals: Optional[expr]
locals: Optional[expr]
class Global(stmt):
names: typing.List[identifier]
class Expr(stmt):
value: expr
class Pass(stmt): ...
class Break(stmt): ...
class Continue(stmt): ...
class slice(AST): ...
_slice = slice # this lets us type the variable named 'slice' below
class Slice(slice):
lower: Optional[expr]
upper: Optional[expr]
step: Optional[expr]
class ExtSlice(slice):
dims: typing.List[slice]
class Index(slice):
value: expr
class Ellipsis(slice): ...
class expr(AST):
lineno: int
col_offset: int
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[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 Yield(expr):
value: Optional[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]
starargs: Optional[expr]
kwargs: Optional[expr]
class Repr(expr):
value: expr
class Num(expr):
n: Union[int, float, complex]
class Str(expr):
s: Union[str, bytes]
kind: str
class Attribute(expr):
value: expr
attr: identifier
ctx: expr_context
class Subscript(expr):
value: expr
slice: _slice
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): ...
class AugLoad(expr_context): ...
class AugStore(expr_context): ...
class Del(expr_context): ...
class Load(expr_context): ...
class Param(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 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]
class ExceptHandler(AST):
type: Optional[expr]
name: Optional[expr]
body: typing.List[stmt]
lineno: int
col_offset: int
class arguments(AST):
args: typing.List[expr]
vararg: Optional[identifier]
kwarg: Optional[identifier]
defaults: typing.List[expr]
type_comments: typing.List[Optional[str]]
class keyword(AST):
arg: identifier
value: expr
class alias(AST):
name: identifier
asname: Optional[identifier]
class TypeIgnore(AST):
lineno: int
| 6,949 | Python | .py | 265 | 22.8 | 100 | 0.688388 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,868 | ast3.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/typed_ast/ast3.pyi | import typing
from typing import Any, Iterator, Optional, Union
class NodeVisitor:
def visit(self, node: AST) -> Any: ...
def generic_visit(self, node: AST) -> None: ...
class NodeTransformer(NodeVisitor):
def generic_visit(self, node: AST) -> None: ...
def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ..., feature_version: int = ...) -> AST: ...
def copy_location(new_node: AST, old_node: AST) -> AST: ...
def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ...
def fix_missing_locations(node: AST) -> AST: ...
def get_docstring(node: AST, clean: bool = ...) -> Optional[str]: ...
def increment_lineno(node: AST, n: int = ...) -> AST: ...
def iter_child_nodes(node: AST) -> Iterator[AST]: ...
def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ...
def literal_eval(node_or_string: Union[str, AST]) -> Any: ...
def walk(node: AST) -> Iterator[AST]: ...
PyCF_ONLY_AST: int
# ast classes
identifier = str
class AST:
_attributes: typing.Tuple[str, ...]
_fields: typing.Tuple[str, ...]
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
class mod(AST): ...
class Module(mod):
body: typing.List[stmt]
type_ignores: typing.List[TypeIgnore]
class Interactive(mod):
body: typing.List[stmt]
class Expression(mod):
body: expr
class FunctionType(mod):
argtypes: typing.List[expr]
returns: expr
class Suite(mod):
body: typing.List[stmt]
class stmt(AST):
lineno: int
col_offset: int
class FunctionDef(stmt):
name: identifier
args: arguments
body: typing.List[stmt]
decorator_list: typing.List[expr]
returns: Optional[expr]
type_comment: Optional[str]
class AsyncFunctionDef(stmt):
name: identifier
args: arguments
body: typing.List[stmt]
decorator_list: typing.List[expr]
returns: Optional[expr]
type_comment: Optional[str]
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
type_comment: Optional[str]
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]
type_comment: Optional[str]
class AsyncFor(stmt):
target: expr
iter: expr
body: typing.List[stmt]
orelse: typing.List[stmt]
type_comment: Optional[str]
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]
type_comment: Optional[str]
class AsyncWith(stmt):
items: typing.List[withitem]
body: typing.List[stmt]
type_comment: Optional[str]
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: Optional[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 slice(AST): ...
_slice = slice # this lets us type the variable named 'slice' below
class Slice(slice):
lower: Optional[expr]
upper: Optional[expr]
step: Optional[expr]
class ExtSlice(slice):
dims: typing.List[slice]
class Index(slice):
value: expr
class expr(AST):
lineno: int
col_offset: int
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[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 Num(expr):
n: Union[float, int, complex]
class Str(expr):
s: str
kind: str
class FormattedValue(expr):
value: expr
conversion: typing.Optional[int]
format_spec: typing.Optional[expr]
class JoinedStr(expr):
values: typing.List[expr]
class Bytes(expr):
s: bytes
class NameConstant(expr):
value: Any
class Ellipsis(expr): ...
class Attribute(expr):
value: expr
attr: identifier
ctx: expr_context
class Subscript(expr):
value: expr
slice: _slice
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): ...
class AugLoad(expr_context): ...
class AugStore(expr_context): ...
class Del(expr_context): ...
class Load(expr_context): ...
class Param(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):
type: Optional[expr]
name: Optional[identifier]
body: typing.List[stmt]
lineno: int
col_offset: int
class arguments(AST):
args: typing.List[arg]
vararg: Optional[arg]
kwonlyargs: typing.List[arg]
kw_defaults: typing.List[expr]
kwarg: Optional[arg]
defaults: typing.List[expr]
class arg(AST):
arg: identifier
annotation: Optional[expr]
lineno: int
col_offset: int
type_comment: typing.Optional[str]
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]
class TypeIgnore(AST):
lineno: int
| 7,946 | Python | .py | 304 | 22.625 | 128 | 0.691748 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,869 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/filelock/__init__.pyi | import sys
from logging import Logger
from types import TracebackType
from typing import Optional, Type, Union
def logger() -> Logger: ...
class Timeout(TimeoutError):
def __init__(self, lock_file: str) -> None: ...
def __str__(self) -> str: ...
class _Acquire_ReturnProxy:
def __init__(self, lock: str) -> None: ...
def __enter__(self) -> str: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], traceback: Optional[TracebackType]
) -> None: ...
class BaseFileLock:
def __init__(self, lock_file: str, timeout: Union[float, int, str] = ...) -> None: ...
@property
def lock_file(self) -> str: ...
@property
def timeout(self) -> float: ...
@timeout.setter
def timeout(self, value: Union[int, str, float]) -> None: ...
@property
def is_locked(self) -> bool: ...
def acquire(self, timeout: Optional[float] = ..., poll_intervall: float = ...) -> _Acquire_ReturnProxy: ...
def release(self, force: bool = ...) -> None: ...
def __enter__(self) -> BaseFileLock: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], traceback: Optional[TracebackType]
) -> None: ...
def __del__(self) -> None: ...
class WindowsFileLock(BaseFileLock):
def _acquire(self) -> None: ...
def _release(self) -> None: ...
class UnixFileLock(BaseFileLock):
def _acquire(self) -> None: ...
def _release(self) -> None: ...
class SoftFileLock(BaseFileLock):
def _acquire(self) -> None: ...
def _release(self) -> None: ...
if sys.platform == "win32":
FileLock = WindowsFileLock
elif sys.platform == "linux" or sys.platform == "darwin":
FileLock = UnixFileLock
else:
FileLock = SoftFileLock
| 1,789 | Python | .py | 46 | 34.76087 | 123 | 0.630548 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,870 | api.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/third_party/3/freezegun/api.pyi | from datetime import date, datetime, timedelta
from numbers import Real
from typing import Any, Awaitable, Callable, Iterator, Optional, Sequence, Type, TypeVar, Union, overload
_T = TypeVar("_T")
_Freezable = Union[str, datetime, date, timedelta]
class TickingDateTimeFactory(object):
def __init__(self, time_to_freeze: datetime, start: datetime) -> None: ...
def __call__(self) -> datetime: ...
class FrozenDateTimeFactory(object):
def __init__(self, time_to_freeze: datetime) -> None: ...
def __call__(self) -> datetime: ...
def tick(self, delta: Union[float, Real, timedelta] = ...) -> None: ...
def move_to(self, target_datetime: Optional[_Freezable]) -> None: ...
class StepTickTimeFactory(object):
def __init__(self, time_to_freeze: datetime, step_width: float) -> None: ...
def __call__(self) -> datetime: ...
def tick(self, delta: Optional[timedelta] = ...) -> None: ...
def update_step_width(self, step_width: float) -> None: ...
def move_to(self, target_datetime: Optional[_Freezable]) -> None: ...
class _freeze_time:
def __init__(
self,
time_to_freeze_str: Optional[_Freezable],
tz_offset: float,
ignore: Sequence[str],
tick: bool,
as_arg: bool,
auto_tick_seconds: float,
) -> None: ...
@overload
def __call__(self, func: Type[_T]) -> Type[_T]: ...
@overload
def __call__(self, func: Callable[..., Awaitable[_T]]) -> Callable[..., Awaitable[_T]]: ...
@overload
def __call__(self, func: Callable[..., _T]) -> Callable[..., _T]: ...
def __enter__(self) -> Any: ...
def __exit__(self, *args: Any) -> None: ...
def start(self) -> Any: ...
def stop(self) -> None: ...
def decorate_class(self, klass: Type[_T]) -> _T: ...
def decorate_coroutine(self, coroutine: _T) -> _T: ...
def decorate_callable(self, func: Callable[..., _T]) -> Callable[..., _T]: ...
def freeze_time(
time_to_freeze: Optional[Union[_Freezable, Callable[..., _Freezable], Iterator[_Freezable]]] = ...,
tz_offset: Optional[float] = ...,
ignore: Optional[Sequence[str]] = ...,
tick: Optional[bool] = ...,
as_arg: Optional[bool] = ...,
auto_tick_seconds: Optional[float] = ...,
) -> _freeze_time: ...
| 2,266 | Python | .py | 50 | 40.52 | 105 | 0.601357 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,871 | stubtest_unused.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/tests/stubtest_unused.py | #!/usr/bin/env python3
# Runs stubtest and prints each unused whitelist entry with filename.
import os.path
import subprocess
import sys
from typing import List, Tuple
_UNUSED_NOTE = "note: unused allowlist entry "
_WHITELIST_PATH = os.path.join("tests", "stubtest_whitelists")
def main() -> int:
unused = run_stubtest()
with_filenames = []
for uu in unused:
with_filenames.extend(unused_files(uu))
for file, uu in with_filenames:
print(file + ":" + uu)
return 1 if with_filenames else 0
def run_stubtest() -> List[str]:
proc = subprocess.run(["./tests/stubtest_test.py"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
output = proc.stdout.decode("utf-8").splitlines()
return [line[len(_UNUSED_NOTE) :].strip() for line in output if line.startswith(_UNUSED_NOTE)]
def unused_files(unused: str) -> List[Tuple[str, str]]:
version = "py{}{}".format(sys.version_info[0], sys.version_info[1])
files = ["py3_common.txt", version + ".txt", sys.platform + ".txt", sys.platform + "-" + version + ".txt"]
found = []
for file in files:
path = os.path.join(_WHITELIST_PATH, file)
if find_unused_in_file(unused, path):
found.append((path, unused))
if not found:
raise ValueError("unused item {} not found in any whitelist file".format(unused))
return found
def find_unused_in_file(unused: str, path: str) -> bool:
try:
with open(path) as f:
return any(line.strip().split(" ")[0] == unused for line in f)
except FileNotFoundError:
return False
if __name__ == "__main__":
sys.exit(main())
| 1,639 | Python | .py | 39 | 36.897436 | 110 | 0.659105 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,872 | mypy_test_suite.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/tests/mypy_test_suite.py | #!/usr/bin/env python3
"""Script to run mypy's test suite against this version of typeshed."""
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path
if __name__ == "__main__":
with tempfile.TemporaryDirectory() as tempdir:
dirpath = Path(tempdir)
subprocess.run(["git", "clone", "--depth", "1", "git://github.com/python/mypy", dirpath / "mypy"], check=True)
subprocess.run(["python2.7", "-m", "pip", "install", "--user", "typing"], check=True)
subprocess.run(
[sys.executable, "-m", "pip", "install", "-U", "-r", dirpath / "mypy/test-requirements.txt"], check=True
)
shutil.copytree("stdlib", dirpath / "mypy/mypy/typeshed/stdlib")
shutil.copytree("third_party", dirpath / "mypy/mypy/typeshed/third_party")
try:
subprocess.run([sys.executable, "runtests.py", "typeshed-ci"], cwd=dirpath / "mypy", check=True)
except subprocess.CalledProcessError as e:
print("mypy tests failed", file=sys.stderr)
sys.exit(e.returncode)
else:
print("mypy tests succeeded", file=sys.stderr)
sys.exit(0)
| 1,173 | Python | .py | 25 | 39.56 | 118 | 0.628821 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,873 | pytype_test.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/tests/pytype_test.py | #!/usr/bin/env python3
"""Test runner for typeshed.
Depends on pytype being installed.
If pytype is installed:
1. For every pyi, do nothing if it is in pytype_exclude_list.txt.
2. Otherwise, call 'pytype.io.parse_pyi'.
Option two will load the file and all the builtins, typeshed dependencies. This
will also discover incorrect usage of imported modules.
"""
import argparse
import os
import re
import sys
import traceback
from typing import List, Match, Optional, Sequence, Tuple
from pytype import config as pytype_config, io as pytype_io
TYPESHED_SUBDIRS = ["stdlib", "third_party"]
TYPESHED_HOME = "TYPESHED_HOME"
UNSET = object() # marker for tracking the TYPESHED_HOME environment variable
def main() -> None:
args = create_parser().parse_args()
typeshed_location = args.typeshed_location or os.getcwd()
subdir_paths = [os.path.join(typeshed_location, d) for d in TYPESHED_SUBDIRS]
check_subdirs_discoverable(subdir_paths)
files_to_test = determine_files_to_test(typeshed_location=typeshed_location, paths=args.files or subdir_paths)
run_all_tests(
files_to_test=files_to_test,
typeshed_location=typeshed_location,
print_stderr=args.print_stderr,
dry_run=args.dry_run,
)
def create_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description="Pytype/typeshed tests.")
parser.add_argument("-n", "--dry-run", action="store_true", default=False, help="Don't actually run tests")
# Default to '' so that symlinking typeshed subdirs in cwd will work.
parser.add_argument("--typeshed-location", type=str, default="", help="Path to typeshed installation.")
# Set to true to print a stack trace every time an exception is thrown.
parser.add_argument(
"--print-stderr", action="store_true", default=False, help="Print stderr every time an error is encountered."
)
parser.add_argument(
"files",
metavar="FILE",
type=str,
nargs="*",
help="Files or directories to check. (Default: Check all files.)",
)
return parser
class PathMatcher:
def __init__(self, patterns: Sequence[str]) -> None:
patterns = [re.escape(os.path.join(*x.split("/"))) for x in patterns]
self.matcher = re.compile(r"({})$".format("|".join(patterns))) if patterns else None
def search(self, path: str) -> Optional[Match[str]]:
if not self.matcher:
return None
return self.matcher.search(path)
def load_exclude_list(typeshed_location: str) -> List[str]:
filename = os.path.join(typeshed_location, "tests", "pytype_exclude_list.txt")
skip_re = re.compile(r"^\s*([^\s#]+)\s*(?:#.*)?$")
skip = []
with open(filename) as f:
for line in f:
skip_match = skip_re.match(line)
if skip_match:
skip.append(skip_match.group(1))
return skip
def run_pytype(*, filename: str, python_version: str, typeshed_location: str) -> Optional[str]:
"""Runs pytype, returning the stderr if any."""
options = pytype_config.Options.create(
filename, module_name=_get_module_name(filename), parse_pyi=True, python_version=python_version
)
old_typeshed_home = os.environ.get(TYPESHED_HOME, UNSET)
os.environ[TYPESHED_HOME] = typeshed_location
try:
pytype_io.parse_pyi(options)
except Exception:
stderr = traceback.format_exc()
else:
stderr = None
if old_typeshed_home is UNSET:
del os.environ[TYPESHED_HOME]
else:
os.environ[TYPESHED_HOME] = old_typeshed_home
return stderr
def _get_relative(filename: str) -> str:
top = 0
for d in TYPESHED_SUBDIRS:
try:
top = filename.index(d)
except ValueError:
continue
else:
break
return filename[top:]
def _get_module_name(filename: str) -> str:
"""Converts a filename {subdir}/m.n/module/foo to module.foo."""
return ".".join(_get_relative(filename).split(os.path.sep)[2:]).replace(".pyi", "").replace(".__init__", "")
def _is_version(path: str, version: str) -> bool:
return any("{}{}{}".format(d, os.path.sep, version) in path for d in TYPESHED_SUBDIRS)
def check_subdirs_discoverable(subdir_paths: List[str]) -> None:
for p in subdir_paths:
if not os.path.isdir(p):
raise SystemExit("Cannot find typeshed subdir at {} (specify parent dir via --typeshed-location)".format(p))
def determine_files_to_test(*, typeshed_location: str, paths: Sequence[str]) -> List[Tuple[str, int]]:
"""Determine all files to test, checking if it's in the exclude list and which Python versions to use.
Returns a list of pairs of the file path and Python version as an int."""
skipped = PathMatcher(load_exclude_list(typeshed_location))
filenames = find_stubs_in_paths(paths)
files = []
for f in sorted(filenames):
rel = _get_relative(f)
if skipped.search(rel):
continue
if _is_version(f, "2and3"):
files.append((f, 2))
files.append((f, 3))
elif _is_version(f, "2"):
files.append((f, 2))
elif _is_version(f, "3"):
files.append((f, 3))
else:
print("Unrecognized path: {}".format(f))
return files
def find_stubs_in_paths(paths: Sequence[str]) -> List[str]:
filenames = []
for path in paths:
if os.path.isdir(path):
for root, _, fns in os.walk(path):
filenames.extend(os.path.join(root, fn) for fn in fns if fn.endswith(".pyi"))
else:
filenames.append(path)
return filenames
def run_all_tests(*, files_to_test: Sequence[Tuple[str, int]], typeshed_location: str, print_stderr: bool, dry_run: bool) -> None:
bad = []
errors = 0
total_tests = len(files_to_test)
print("Testing files with pytype...")
for i, (f, version) in enumerate(files_to_test):
stderr = (
run_pytype(
filename=f,
python_version="2.7" if version == 2 else "{0.major}.{0.minor}".format(sys.version_info),
typeshed_location=typeshed_location,
)
if not dry_run
else None
)
if stderr:
if print_stderr:
print(stderr)
errors += 1
stacktrace_final_line = stderr.rstrip().rsplit("\n", 1)[-1]
bad.append((_get_relative(f), stacktrace_final_line))
runs = i + 1
if runs % 25 == 0:
print(" {:3d}/{:d} with {:3d} errors".format(runs, total_tests, errors))
print("Ran pytype with {:d} pyis, got {:d} errors.".format(total_tests, errors))
for f, err in bad:
print("{}: {}".format(f, err))
if errors:
raise SystemExit("\nRun again with --print-stderr to get the full stacktrace.")
if __name__ == "__main__":
main()
| 6,936 | Python | .py | 163 | 35.447853 | 130 | 0.63766 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,874 | stubtest_test.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/tests/stubtest_test.py | #!/usr/bin/env python3
"""Test typeshed using stubtest
stubtest is a script in the mypy project that compares stubs to the actual objects at runtime.
Note that therefore the output of stubtest depends on which Python version it is run with.
In typeshed CI, we run stubtest with each currently supported Python minor version, except 2.7.
We pin the version of mypy / stubtest we use in .travis.yml so changes to those don't break
typeshed CI.
"""
import subprocess
import sys
from pathlib import Path
def run_stubtest(typeshed_dir: Path) -> int:
whitelist_dir = typeshed_dir / "tests" / "stubtest_whitelists"
version_whitelist = "py{}{}.txt".format(sys.version_info.major, sys.version_info.minor)
platform_whitelist = "{}.txt".format(sys.platform)
combined_whitelist = "{}-py{}{}.txt".format(sys.platform, sys.version_info.major, sys.version_info.minor)
ignore_unused_whitelist = "--ignore-unused-whitelist" in sys.argv[1:]
cmd = [
sys.executable,
"-m",
"mypy.stubtest",
# Use --ignore-missing-stub, because if someone makes a correct addition, they'll need to
# also make a whitelist change and if someone makes an incorrect addition, they'll run into
# false negatives.
"--ignore-missing-stub",
"--check-typeshed",
"--custom-typeshed-dir",
str(typeshed_dir),
"--whitelist",
str(whitelist_dir / "py3_common.txt"),
"--whitelist",
str(whitelist_dir / version_whitelist),
]
if ignore_unused_whitelist:
cmd += ["--ignore-unused-whitelist"]
if (whitelist_dir / platform_whitelist).exists():
cmd += [
"--whitelist",
str(whitelist_dir / platform_whitelist),
]
if (whitelist_dir / combined_whitelist).exists():
cmd += [
"--whitelist",
str(whitelist_dir / combined_whitelist),
]
if sys.version_info < (3, 9):
# As discussed in https://github.com/python/typeshed/issues/3693, we only aim for
# positional-only arg accuracy for the latest Python version.
cmd += ["--ignore-positional-only"]
try:
print(" ".join(cmd), file=sys.stderr)
subprocess.run(cmd, check=True)
except subprocess.CalledProcessError as e:
print(
"\nNB: stubtest output depends on the Python version (and system) it is run with. "
"See README.md for more details.\n"
"NB: We only check positional-only arg accuracy for Python 3.9.\n"
"\nCommand run was: {}\n".format(" ".join(cmd)),
file=sys.stderr,
)
print("stubtest failed", file=sys.stderr)
return e.returncode
else:
print("stubtest succeeded", file=sys.stderr)
return 0
if __name__ == "__main__":
sys.exit(run_stubtest(typeshed_dir=Path(".")))
| 2,874 | Python | .py | 67 | 35.656716 | 109 | 0.643904 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,875 | check_consistent.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/tests/check_consistent.py | #!/usr/bin/env python3
# For various reasons we need the contents of certain files to be
# duplicated in two places, for example stdlib/2/builtins.pyi and
# stdlib/2/__builtin__.pyi must be identical. In the past we used
# symlinks but that doesn't always work on Windows, so now you must
# manually update both files, and this test verifies that they are
# identical. The list below indicates which sets of files must match.
import filecmp
import os
consistent_files = [
{"stdlib/2/builtins.pyi", "stdlib/2/__builtin__.pyi"},
{"stdlib/2and3/threading.pyi", "stdlib/2and3/_dummy_threading.pyi"},
]
def main():
files = [os.path.join(root, file) for root, dir, files in os.walk(".") for file in files]
no_symlink = "You cannot use symlinks in typeshed, please copy {} to its link."
for file in files:
_, ext = os.path.splitext(file)
if ext == ".pyi" and os.path.islink(file):
raise ValueError(no_symlink.format(file))
for file1, *others in consistent_files:
f1 = os.path.join(os.getcwd(), file1)
for file2 in others:
f2 = os.path.join(os.getcwd(), file2)
if not filecmp.cmp(f1, f2):
raise ValueError(
"File {f1} does not match file {f2}. Please copy it to {f2}\n"
"Run either:\ncp {f1} {f2}\nOr:\ncp {f2} {f1}".format(f1=file1, f2=file2)
)
if __name__ == "__main__":
main()
| 1,449 | Python | .py | 31 | 40.096774 | 93 | 0.639263 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,876 | mypy_self_check.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/tests/mypy_self_check.py | #!/usr/bin/env python3
"""Script to run mypy against its own code base."""
import subprocess
import sys
import tempfile
from pathlib import Path
MYPY_VERSION = "0.790"
if __name__ == "__main__":
with tempfile.TemporaryDirectory() as tempdir:
dirpath = Path(tempdir)
subprocess.run(
["git", "clone", "--depth", "1", "git://github.com/python/mypy", dirpath],
check=True,
)
try:
subprocess.run([sys.executable, "-m", "pip", "install", f"mypy=={MYPY_VERSION}"], check=True)
subprocess.run([sys.executable, "-m", "pip", "install", "-r", dirpath / "test-requirements.txt"], check=True)
subprocess.run(
[
"mypy",
"--config-file",
dirpath / "mypy_self_check.ini",
"--custom-typeshed-dir",
".",
dirpath / "mypy",
dirpath / "mypyc",
],
check=True,
)
except subprocess.CalledProcessError as e:
print("mypy self test failed", file=sys.stderr)
sys.exit(e.returncode)
else:
print("mypy self test succeeded", file=sys.stderr)
sys.exit(0)
| 1,287 | Python | .py | 35 | 25.371429 | 121 | 0.511218 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,877 | mypy_test.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/tests/mypy_test.py | #!/usr/bin/env python3
"""Test runner for typeshed.
Depends on mypy being installed.
Approach:
1. Parse sys.argv
2. Compute appropriate arguments for mypy
3. Stuff those arguments into sys.argv
4. Run mypy.main('')
5. Repeat steps 2-4 for other mypy runs (e.g. --py2)
"""
import argparse
import os
import re
import sys
parser = argparse.ArgumentParser(description="Test runner for typeshed. " "Patterns are unanchored regexps on the full path.")
parser.add_argument("-v", "--verbose", action="count", default=0, help="More output")
parser.add_argument("-n", "--dry-run", action="store_true", help="Don't actually run mypy")
parser.add_argument("-x", "--exclude", type=str, nargs="*", help="Exclude pattern")
parser.add_argument("-p", "--python-version", type=str, nargs="*", help="These versions only (major[.minor])")
parser.add_argument("--platform", help="Run mypy for a certain OS platform (defaults to sys.platform)")
parser.add_argument(
"--warn-unused-ignores",
action="store_true",
help="Run mypy with --warn-unused-ignores "
"(hint: only get rid of warnings that are "
"unused for all platforms and Python versions)",
)
parser.add_argument("filter", type=str, nargs="*", help="Include pattern (default all)")
def log(args, *varargs):
if args.verbose >= 2:
print(*varargs)
def match(fn, args, exclude_list):
if exclude_list.match(fn):
log(args, fn, "exluded by exclude list")
return False
if not args.filter and not args.exclude:
log(args, fn, "accept by default")
return True
if args.exclude:
for f in args.exclude:
if re.search(f, fn):
log(args, fn, "excluded by pattern", f)
return False
if args.filter:
for f in args.filter:
if re.search(f, fn):
log(args, fn, "accepted by pattern", f)
return True
if args.filter:
log(args, fn, "rejected (no pattern matches)")
return False
log(args, fn, "accepted (no exclude pattern matches)")
return True
def libpath(major, minor):
versions = ["%d.%d" % (major, minor) for minor in reversed(range(minor + 1))]
versions.append(str(major))
versions.append("2and3")
paths = []
for v in versions:
for top in ["stdlib", "third_party"]:
p = os.path.join(top, v)
if os.path.isdir(p):
paths.append(p)
return paths
def main():
args = parser.parse_args()
with open(os.path.join(os.path.dirname(__file__), "mypy_exclude_list.txt")) as f:
exclude_list = re.compile("(%s)$" % "|".join(re.findall(r"^\s*([^\s#]+)\s*(?:#.*)?$", f.read(), flags=re.M)))
try:
from mypy.main import main as mypy_main
except ImportError:
print("Cannot import mypy. Did you install it?")
sys.exit(1)
versions = [(3, 9), (3, 8), (3, 7), (3, 6), (3, 5), (2, 7)]
if args.python_version:
versions = [v for v in versions if any(("%d.%d" % v).startswith(av) for av in args.python_version)]
if not versions:
print("--- no versions selected ---")
sys.exit(1)
code = 0
runs = 0
for major, minor in versions:
roots = libpath(major, minor)
files = []
seen = {"__builtin__", "builtins", "typing"} # Always ignore these.
for root in roots:
names = os.listdir(root)
for name in names:
full = os.path.join(root, name)
mod, ext = os.path.splitext(name)
if mod in seen or mod.startswith("."):
continue
if ext in [".pyi", ".py"]:
if match(full, args, exclude_list):
seen.add(mod)
files.append(full)
elif os.path.isfile(os.path.join(full, "__init__.pyi")) or os.path.isfile(os.path.join(full, "__init__.py")):
for r, ds, fs in os.walk(full):
ds.sort()
fs.sort()
for f in fs:
m, x = os.path.splitext(f)
if x in [".pyi", ".py"]:
fn = os.path.join(r, f)
if match(fn, args, exclude_list):
seen.add(mod)
files.append(fn)
if files:
runs += 1
flags = ["--python-version", "%d.%d" % (major, minor)]
flags.append("--strict-optional")
flags.append("--no-site-packages")
flags.append("--show-traceback")
flags.append("--no-implicit-optional")
flags.append("--disallow-any-generics")
flags.append("--disallow-subclassing-any")
# Setting custom typeshed dir prevents mypy from falling back to its bundled typeshed in
# case of stub deletions
flags.append("--custom-typeshed-dir")
flags.append(os.path.dirname(os.path.dirname(__file__)))
if args.warn_unused_ignores:
flags.append("--warn-unused-ignores")
if args.platform:
flags.extend(["--platform", args.platform])
sys.argv = ["mypy"] + flags + files
if args.verbose:
print("running", " ".join(sys.argv))
else:
print("running mypy", " ".join(flags), "# with", len(files), "files")
try:
if not args.dry_run:
mypy_main("", sys.stdout, sys.stderr)
except SystemExit as err:
code = max(code, err.code)
if code:
print("--- exit status", code, "---")
sys.exit(code)
if not runs:
print("--- nothing to do; exit 1 ---")
sys.exit(1)
if __name__ == "__main__":
main()
| 5,905 | Python | .py | 142 | 31.316901 | 126 | 0.548494 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,878 | win32-py36.txt | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/tests/stubtest_whitelists/win32-py36.txt | hashlib.scrypt
os.startfile
posixpath.splitunc # This doesn't exist, but our hands are tied by check_consistent
| 113 | Python | .py | 3 | 36.666667 | 84 | 0.827273 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,879 | graphlib.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3.9/graphlib.pyi | from _typeshed import SupportsItems
from typing import Generic, Iterable, Optional, Tuple, TypeVar
_T = TypeVar("_T")
class TopologicalSorter(Generic[_T]):
def __init__(self, graph: Optional[SupportsItems[_T, Iterable[_T]]] = ...) -> None: ...
def add(self, node: _T, *predecessors: _T) -> None: ...
def prepare(self) -> None: ...
def is_active(self) -> bool: ...
def __bool__(self) -> bool: ...
def done(self, *nodes: _T) -> None: ...
def get_ready(self) -> Tuple[_T, ...]: ...
def static_order(self) -> Iterable[_T]: ...
class CycleError(ValueError): ...
| 592 | Python | .py | 13 | 41.846154 | 91 | 0.607639 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,880 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3.9/zoneinfo/__init__.pyi | import os
import typing
from datetime import tzinfo
from typing import Any, AnyStr, Iterable, Optional, Protocol, Sequence, Set, Type, Union
_T = typing.TypeVar("_T", bound="ZoneInfo")
class _IOBytes(Protocol):
def read(self, __size: int) -> bytes: ...
def seek(self, __size: int, __whence: int = ...) -> Any: ...
class ZoneInfo(tzinfo):
@property
def key(self) -> str: ...
def __init__(self, key: str) -> None: ...
@classmethod
def no_cache(cls: Type[_T], key: str) -> _T: ...
@classmethod
def from_file(cls: Type[_T], __fobj: _IOBytes, key: Optional[str] = ...) -> _T: ...
@classmethod
def clear_cache(cls, *, only_keys: Iterable[str] = ...) -> None: ...
# Note: Both here and in clear_cache, the types allow the use of `str` where
# a sequence of strings is required. This should be remedied if a solution
# to this typing bug is found: https://github.com/python/typing/issues/256
def reset_tzpath(to: Optional[Sequence[Union[os.PathLike[AnyStr], str]]] = ...) -> None: ...
def available_timezones() -> Set[str]: ...
TZPATH: Sequence[str]
class ZoneInfoNotFoundError(KeyError): ...
class InvalidTZPathWarning(RuntimeWarning): ...
| 1,183 | Python | .py | 26 | 42.576923 | 92 | 0.665508 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,881 | _hotshot.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/_hotshot.pyi | from typing import Any, Dict, Generic, List, Tuple
def coverage(a: str) -> Any: ...
def logreader(a: str) -> LogReaderType: ...
def profiler(a: str, *args, **kwargs) -> Any: ...
def resolution() -> Tuple[Any, ...]: ...
class LogReaderType(object):
def close(self) -> None: ...
def fileno(self) -> int: ...
class ProfilerType(object):
def addinfo(self, a: str, b: str) -> None: ...
def close(self) -> None: ...
def fileno(self) -> int: ...
def runcall(self, *args, **kwargs) -> Any: ...
def runcode(self, a, b, *args, **kwargs) -> Any: ...
def start(self) -> None: ...
def stop(self) -> None: ...
| 635 | Python | .py | 16 | 36.25 | 56 | 0.582792 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,882 | mimetools.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/mimetools.pyi | import rfc822
from typing import Any
class Message(rfc822.Message):
encodingheader: Any
typeheader: Any
def __init__(self, fp, seekable: int = ...): ...
plisttext: Any
type: Any
maintype: Any
subtype: Any
def parsetype(self): ...
plist: Any
def parseplist(self): ...
def getplist(self): ...
def getparam(self, name): ...
def getparamnames(self): ...
def getencoding(self): ...
def gettype(self): ...
def getmaintype(self): ...
def getsubtype(self): ...
def choose_boundary(): ...
def decode(input, output, encoding): ...
def encode(input, output, encoding): ...
def copyliteral(input, output): ...
def copybinary(input, output): ...
| 703 | Python | .py | 25 | 24.32 | 52 | 0.642012 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,883 | types.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/types.pyi | from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Type, TypeVar, Union, overload
_T = TypeVar("_T")
# Note, all classes "defined" here require special handling.
class NoneType: ...
TypeType = type
ObjectType = object
IntType = int
LongType = int # Really long, but can't reference that due to a mypy import cycle
FloatType = float
BooleanType = bool
ComplexType = complex
StringType = str
UnicodeType = unicode
StringTypes: Tuple[Type[StringType], Type[UnicodeType]]
BufferType = buffer
TupleType = tuple
ListType = list
DictType = dict
DictionaryType = dict
class _Cell:
cell_contents: Any
class FunctionType:
func_closure: Optional[Tuple[_Cell, ...]] = ...
func_code: CodeType = ...
func_defaults: Optional[Tuple[Any, ...]] = ...
func_dict: Dict[str, Any] = ...
func_doc: Optional[str] = ...
func_globals: Dict[str, Any] = ...
func_name: str = ...
__closure__ = func_closure
__code__ = func_code
__defaults__ = func_defaults
__dict__ = func_dict
__globals__ = func_globals
__name__ = func_name
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]) -> UnboundMethodType: ...
LambdaType = FunctionType
class CodeType:
co_argcount: int
co_cellvars: Tuple[str, ...]
co_code: str
co_consts: Tuple[Any, ...]
co_filename: str
co_firstlineno: int
co_flags: int
co_freevars: Tuple[str, ...]
co_lnotab: str
co_name: str
co_names: Tuple[str, ...]
co_nlocals: int
co_stacksize: int
co_varnames: Tuple[str, ...]
def __init__(
self,
argcount: int,
nlocals: int,
stacksize: int,
flags: int,
codestring: str,
constants: Tuple[Any, ...],
names: Tuple[str, ...],
varnames: Tuple[str, ...],
filename: str,
name: str,
firstlineno: int,
lnotab: str,
freevars: Tuple[str, ...] = ...,
cellvars: Tuple[str, ...] = ...,
) -> None: ...
class GeneratorType:
gi_code: CodeType
gi_frame: FrameType
gi_running: int
def __iter__(self) -> GeneratorType: ...
def close(self) -> None: ...
def next(self) -> Any: ...
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 ClassType: ...
class UnboundMethodType:
im_class: type = ...
im_func: FunctionType = ...
im_self: object = ...
__name__: str
__func__ = im_func
__self__ = im_self
def __init__(self, func: Callable[..., Any], obj: object) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
class InstanceType(object): ...
MethodType = UnboundMethodType
class BuiltinFunctionType:
__self__: Optional[object]
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
BuiltinMethodType = BuiltinFunctionType
class ModuleType:
__doc__: Optional[str]
__file__: Optional[str]
__name__: str
__package__: Optional[str]
__path__: Optional[Iterable[str]]
__dict__: Dict[str, Any]
def __init__(self, name: str, doc: Optional[str] = ...) -> None: ...
FileType = file
XRangeType = xrange
class TracebackType:
tb_frame: FrameType
tb_lasti: int
tb_lineno: int
tb_next: TracebackType
class FrameType:
f_back: FrameType
f_builtins: Dict[str, Any]
f_code: CodeType
f_exc_type: None
f_exc_value: None
f_exc_traceback: None
f_globals: Dict[str, Any]
f_lasti: int
f_lineno: int
f_locals: Dict[str, Any]
f_restricted: bool
f_trace: Callable[[], None]
def clear(self) -> None: ...
SliceType = slice
class EllipsisType: ...
class DictProxyType:
# TODO is it possible to have non-string keys?
# no __init__
def copy(self) -> Dict[Any, Any]: ...
def get(self, key: str, default: _T = ...) -> Union[Any, _T]: ...
def has_key(self, key: str) -> bool: ...
def items(self) -> List[Tuple[str, Any]]: ...
def iteritems(self) -> Iterator[Tuple[str, Any]]: ...
def iterkeys(self) -> Iterator[str]: ...
def itervalues(self) -> Iterator[Any]: ...
def keys(self) -> List[str]: ...
def values(self) -> List[Any]: ...
def __contains__(self, key: str) -> bool: ...
def __getitem__(self, key: str) -> Any: ...
def __iter__(self) -> Iterator[str]: ...
def __len__(self) -> int: ...
class NotImplementedType: ...
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: ...
# Same type on Jython, different on CPython and PyPy, unknown on IronPython.
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: ...
| 5,465 | Python | .py | 169 | 27.656805 | 120 | 0.593928 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,884 | _struct.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/_struct.pyi | from typing import Any, AnyStr, Tuple
class error(Exception): ...
class Struct(object):
size: int
format: str
def __init__(self, fmt: str) -> None: ...
def pack_into(self, buffer: bytearray, offset: int, obj: Any) -> None: ...
def pack(self, *args) -> str: ...
def unpack(self, s: str) -> Tuple[Any, ...]: ...
def unpack_from(self, buffer: bytearray, offset: int = ...) -> Tuple[Any, ...]: ...
def _clearcache() -> None: ...
def calcsize(fmt: str) -> int: ...
def pack(fmt: AnyStr, obj: Any) -> str: ...
def pack_into(fmt: AnyStr, buffer: bytearray, offset: int, obj: Any) -> None: ...
def unpack(fmt: AnyStr, data: str) -> Tuple[Any, ...]: ...
def unpack_from(fmt: AnyStr, buffer: bytearray, offset: int = ...) -> Tuple[Any, ...]: ...
| 767 | Python | .py | 16 | 45 | 90 | 0.597594 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,885 | SocketServer.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/SocketServer.pyi | import sys
import types
from socket import SocketType
from typing import Any, BinaryIO, Callable, ClassVar, List, Optional, Text, 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: ...
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[Text, bytes],
RequestHandlerClass: Callable[..., BaseRequestHandler],
bind_and_activate: bool = ...,
) -> None: ...
class UnixDatagramServer(BaseServer):
def __init__(
self,
server_address: Union[Text, 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
def collect_children(self) -> None: ... # undocumented
def handle_timeout(self) -> None: ... # undocumented
def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ...
class ThreadingMixIn:
daemon_threads: 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.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
| 4,559 | Python | .py | 103 | 38.485437 | 114 | 0.668767 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,886 | urllib.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/urllib.pyi | from typing import IO, Any, AnyStr, List, Mapping, Sequence, Text, Tuple, TypeVar, Union
def url2pathname(pathname: AnyStr) -> AnyStr: ...
def pathname2url(pathname: AnyStr) -> AnyStr: ...
def urlopen(url: str, data=..., proxies: Mapping[str, str] = ..., context=...) -> IO[Any]: ...
def urlretrieve(url, filename=..., reporthook=..., data=..., context=...): ...
def urlcleanup() -> None: ...
class ContentTooShortError(IOError):
content: Any
def __init__(self, message, content) -> None: ...
class URLopener:
version: Any
proxies: Any
key_file: Any
cert_file: Any
context: Any
addheaders: Any
tempcache: Any
ftpcache: Any
def __init__(self, proxies: Mapping[str, str] = ..., context=..., **x509) -> None: ...
def __del__(self): ...
def close(self): ...
def cleanup(self): ...
def addheader(self, *args): ...
type: Any
def open(self, fullurl: str, data=...): ...
def open_unknown(self, fullurl, data=...): ...
def open_unknown_proxy(self, proxy, fullurl, data=...): ...
def retrieve(self, url, filename=..., reporthook=..., data=...): ...
def open_http(self, url, data=...): ...
def http_error(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_default(self, url, fp, errcode, errmsg, headers): ...
def open_https(self, url, data=...): ...
def open_file(self, url): ...
def open_local_file(self, url): ...
def open_ftp(self, url): ...
def open_data(self, url, data=...): ...
class FancyURLopener(URLopener):
auth_cache: Any
tries: Any
maxtries: Any
def __init__(self, *args, **kwargs) -> None: ...
def http_error_default(self, url, fp, errcode, errmsg, headers): ...
def http_error_302(self, url, fp, errcode, errmsg, headers, data=...): ...
def redirect_internal(self, url, fp, errcode, errmsg, headers, data): ...
def http_error_301(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_303(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_307(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_401(self, url, fp, errcode, errmsg, headers, data=...): ...
def http_error_407(self, url, fp, errcode, errmsg, headers, data=...): ...
def retry_proxy_http_basic_auth(self, url, realm, data=...): ...
def retry_proxy_https_basic_auth(self, url, realm, data=...): ...
def retry_http_basic_auth(self, url, realm, data=...): ...
def retry_https_basic_auth(self, url, realm, data=...): ...
def get_user_passwd(self, host, realm, clear_cache=...): ...
def prompt_user_passwd(self, host, realm): ...
class ftpwrapper:
user: Any
passwd: Any
host: Any
port: Any
dirs: Any
timeout: Any
refcount: Any
keepalive: Any
def __init__(self, user, passwd, host, port, dirs, timeout=..., persistent=...) -> None: ...
busy: Any
ftp: Any
def init(self): ...
def retrfile(self, file, type): ...
def endtransfer(self): ...
def close(self): ...
def file_close(self): ...
def real_close(self): ...
_AIUT = TypeVar("_AIUT", bound=addbase)
class addbase:
fp: Any
def read(self, n: int = ...) -> bytes: ...
def readline(self, limit: int = ...) -> bytes: ...
def readlines(self, hint: int = ...) -> List[bytes]: ...
def fileno(self) -> int: ... # Optional[int], but that is rare
def __iter__(self: _AIUT) -> _AIUT: ...
def next(self) -> bytes: ...
def __init__(self, fp) -> None: ...
def close(self) -> None: ...
class addclosehook(addbase):
closehook: Any
hookargs: Any
def __init__(self, fp, closehook, *hookargs) -> None: ...
def close(self): ...
class addinfo(addbase):
headers: Any
def __init__(self, fp, headers) -> None: ...
def info(self): ...
class addinfourl(addbase):
headers: Any
url: Any
code: Any
def __init__(self, fp, headers, url, code=...) -> None: ...
def info(self): ...
def getcode(self): ...
def geturl(self): ...
def unwrap(url): ...
def splittype(url): ...
def splithost(url): ...
def splituser(host): ...
def splitpasswd(user): ...
def splitport(host): ...
def splitnport(host, defport=...): ...
def splitquery(url): ...
def splittag(url): ...
def splitattr(url): ...
def splitvalue(attr): ...
def unquote(s: AnyStr) -> AnyStr: ...
def unquote_plus(s: AnyStr) -> AnyStr: ...
def quote(s: AnyStr, safe: Text = ...) -> AnyStr: ...
def quote_plus(s: AnyStr, safe: Text = ...) -> AnyStr: ...
def urlencode(query: Union[Sequence[Tuple[Any, Any]], Mapping[Any, Any]], doseq=...) -> str: ...
def getproxies() -> Mapping[str, str]: ...
def proxy_bypass(host: str) -> Any: ... # Undocumented
# Names in __all__ with no definition:
# basejoin
| 4,765 | Python | .py | 121 | 35.438017 | 96 | 0.601468 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,887 | md5.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/md5.pyi | from hashlib import md5 as md5
new = md5
blocksize: int
digest_size: int
| 74 | Python | .py | 4 | 17.25 | 30 | 0.811594 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,888 | fcntl.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/fcntl.pyi | from _typeshed import FileDescriptorLike
from typing import Any, Union
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_EXLCK: int
F_GETFD: int
F_GETFL: int
F_GETLEASE: int
F_GETLK: int
F_GETLK64: int
F_GETOWN: 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
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
# TODO All these return either int or bytes depending on the value of
# cmd (not on the type of arg).
def fcntl(fd: FileDescriptorLike, op: int, arg: Union[int, bytes] = ...) -> Any: ...
# TODO: arg: int or read-only buffer interface or read-write buffer interface
def ioctl(fd: FileDescriptorLike, op: int, arg: Union[int, bytes] = ..., mutate_flag: bool = ...) -> Any: ...
def flock(fd: FileDescriptorLike, op: int) -> None: ...
def lockf(fd: FileDescriptorLike, op: int, length: int = ..., start: int = ..., whence: int = ...) -> Any: ...
| 1,580 | Python | .py | 78 | 19.205128 | 110 | 0.73498 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,889 | posixpath.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/posixpath.pyi | import os
import sys
from _typeshed import AnyPath, BytesPath, StrPath
from genericpath import exists as exists
from typing import Any, AnyStr, Callable, List, Optional, Sequence, Text, Tuple, TypeVar, overload
_T = TypeVar("_T")
# ----- 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 -----
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: ...
# NOTE: Empty lists results in '' (str) regardless of contained type.
# Also, in Python 2 mixed sequences of Text and bytes results in either Text or bytes
# 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: ...
# Make sure signatures are disjunct, and allow combinations of bytes and unicode.
# (Since Python 2 allows that, too)
# Note that e.g. os.path.join("a", "b", "c", "d", u"e") will still result in
# a type error.
@overload
def join(__p1: bytes, *p: bytes) -> bytes: ...
@overload
def join(__p1: bytes, __p2: bytes, __p3: bytes, __p4: Text, *p: AnyPath) -> Text: ...
@overload
def join(__p1: bytes, __p2: bytes, __p3: Text, *p: AnyPath) -> Text: ...
@overload
def join(__p1: bytes, __p2: Text, *p: AnyPath) -> Text: ...
@overload
def join(__p1: Text, *p: AnyPath) -> Text: ...
@overload
def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ...
@overload
def relpath(path: StrPath, start: Optional[StrPath] = ...) -> Text: ...
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: ...
def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
if sys.platform == "win32":
def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated
def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ...
| 2,937 | Python | .py | 75 | 37.76 | 98 | 0.670056 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,890 | getpass.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/getpass.pyi | from typing import IO, Any
class GetPassWarning(UserWarning): ...
def getpass(prompt: str = ..., stream: IO[Any] = ...) -> str: ...
def getuser() -> str: ...
| 160 | Python | .py | 4 | 38.5 | 65 | 0.62987 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,891 | posix.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/posix.pyi | from _typeshed import FileDescriptorLike
from typing import IO, AnyStr, Dict, List, Mapping, NamedTuple, Optional, Sequence, Tuple, TypeVar, Union
error = OSError
confstr_names: Dict[str, int]
environ: Dict[str, str]
pathconf_names: Dict[str, int]
sysconf_names: Dict[str, int]
_T = TypeVar("_T")
EX_CANTCREAT: int
EX_CONFIG: int
EX_DATAERR: int
EX_IOERR: int
EX_NOHOST: int
EX_NOINPUT: int
EX_NOPERM: 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
NGROUPS_MAX: int
O_APPEND: 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
R_OK: int
TMP_MAX: int
WCONTINUED: int
WNOHANG: int
WUNTRACED: int
W_OK: int
X_OK: int
def WCOREDUMP(status: int) -> bool: ...
def WEXITSTATUS(status: int) -> bool: ...
def WIFCONTINUED(status: int) -> bool: ...
def WIFEXITED(status: int) -> bool: ...
def WIFSIGNALED(status: int) -> bool: ...
def WIFSTOPPED(status: int) -> bool: ...
def WSTOPSIG(status: int) -> bool: ...
def WTERMSIG(status: int) -> bool: ...
class stat_result(object):
n_fields: int
n_sequence_fields: int
n_unnamed_fields: int
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
class statvfs_result(NamedTuple):
f_bsize: int
f_frsize: int
f_blocks: int
f_bfree: int
f_bavail: int
f_files: int
f_ffree: int
f_favail: int
f_flag: int
f_namemax: int
def _exit(status: int) -> None: ...
def abort() -> None: ...
def access(path: unicode, mode: int) -> bool: ...
def chdir(path: unicode) -> None: ...
def chmod(path: unicode, mode: int) -> None: ...
def chown(path: unicode, uid: int, gid: int) -> None: ...
def chroot(path: unicode) -> None: ...
def close(fd: int) -> None: ...
def closerange(fd_low: int, fd_high: int) -> None: ...
def confstr(name: Union[str, int]) -> str: ...
def ctermid() -> str: ...
def dup(fd: int) -> int: ...
def dup2(fd: int, fd2: int) -> None: ...
def execv(path: str, args: Sequence[str], env: Mapping[str, str]) -> None: ...
def execve(path: str, args: Sequence[str], env: Mapping[str, str]) -> None: ...
def fchdir(fd: FileDescriptorLike) -> None: ...
def fchmod(fd: int, mode: int) -> None: ...
def fchown(fd: int, uid: int, gid: int) -> None: ...
def fdatasync(fd: FileDescriptorLike) -> None: ...
def fdopen(fd: int, mode: str = ..., bufsize: int = ...) -> IO[str]: ...
def fork() -> int: ...
def forkpty() -> Tuple[int, int]: ...
def fpathconf(fd: int, name: str) -> None: ...
def fstat(fd: int) -> stat_result: ...
def fstatvfs(fd: int) -> statvfs_result: ...
def fsync(fd: FileDescriptorLike) -> None: ...
def ftruncate(fd: int, length: int) -> None: ...
def getcwd() -> str: ...
def getcwdu() -> unicode: ...
def getegid() -> int: ...
def geteuid() -> int: ...
def getgid() -> int: ...
def getgroups() -> List[int]: ...
def getloadavg() -> Tuple[float, float, float]: ...
def getlogin() -> str: ...
def getpgid(pid: int) -> int: ...
def getpgrp() -> int: ...
def getpid() -> int: ...
def getppid() -> int: ...
def getresgid() -> Tuple[int, int, int]: ...
def getresuid() -> Tuple[int, int, int]: ...
def getsid(pid: int) -> int: ...
def getuid() -> int: ...
def initgroups(username: str, gid: int) -> None: ...
def isatty(fd: int) -> bool: ...
def kill(pid: int, sig: int) -> None: ...
def killpg(pgid: int, sig: int) -> None: ...
def lchown(path: unicode, uid: int, gid: int) -> None: ...
def link(source: unicode, link_name: str) -> None: ...
def listdir(path: AnyStr) -> List[AnyStr]: ...
def lseek(fd: int, pos: int, how: int) -> None: ...
def lstat(path: unicode) -> stat_result: ...
def major(device: int) -> int: ...
def makedev(major: int, minor: int) -> int: ...
def minor(device: int) -> int: ...
def mkdir(path: unicode, mode: int = ...) -> None: ...
def mkfifo(path: unicode, mode: int = ...) -> None: ...
def mknod(filename: unicode, mode: int = ..., device: int = ...) -> None: ...
def nice(increment: int) -> int: ...
def open(file: unicode, flags: int, mode: int = ...) -> int: ...
def openpty() -> Tuple[int, int]: ...
def pathconf(path: unicode, name: str) -> str: ...
def pipe() -> Tuple[int, int]: ...
def popen(command: str, mode: str = ..., bufsize: int = ...) -> IO[str]: ...
def putenv(varname: str, value: str) -> None: ...
def read(fd: int, n: int) -> str: ...
def readlink(path: _T) -> _T: ...
def remove(path: unicode) -> None: ...
def rename(src: unicode, dst: unicode) -> None: ...
def rmdir(path: unicode) -> None: ...
def setegid(egid: int) -> None: ...
def seteuid(euid: int) -> None: ...
def setgid(gid: int) -> None: ...
def setgroups(groups: Sequence[int]) -> None: ...
def setpgid(pid: int, pgrp: int) -> None: ...
def setpgrp() -> None: ...
def setregid(rgid: int, egid: int) -> None: ...
def setresgid(rgid: int, egid: int, sgid: int) -> None: ...
def setresuid(ruid: int, euid: int, suid: int) -> None: ...
def setreuid(ruid: int, euid: int) -> None: ...
def setsid() -> None: ...
def setuid(pid: int) -> None: ...
def stat(path: unicode) -> stat_result: ...
def statvfs(path: unicode) -> statvfs_result: ...
def stat_float_times(fd: int) -> None: ...
def strerror(code: int) -> str: ...
def symlink(source: unicode, link_name: unicode) -> None: ...
def sysconf(name: Union[str, int]) -> int: ...
def system(command: unicode) -> int: ...
def tcgetpgrp(fd: int) -> int: ...
def tcsetpgrp(fd: int, pg: int) -> None: ...
def times() -> Tuple[float, float, float, float, float]: ...
def tmpfile() -> IO[str]: ...
def ttyname(fd: int) -> str: ...
def umask(mask: int) -> int: ...
def uname() -> Tuple[str, str, str, str, str]: ...
def unlink(path: unicode) -> None: ...
def unsetenv(varname: str) -> None: ...
def urandom(n: int) -> str: ...
def utime(path: unicode, times: Optional[Tuple[int, int]]) -> None: ...
def wait() -> int: ...
_r = Tuple[float, float, int, int, int, int, int, int, int, int, int, int, int, int, int, int]
def wait3(options: int) -> Tuple[int, int, _r]: ...
def wait4(pid: int, options: int) -> Tuple[int, int, _r]: ...
def waitpid(pid: int, options: int) -> int: ...
def write(fd: int, str: str) -> int: ...
| 6,396 | Python | .py | 191 | 31.95288 | 105 | 0.627441 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,892 | htmlentitydefs.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/htmlentitydefs.pyi | from typing import Dict
name2codepoint: Dict[str, int]
codepoint2name: Dict[int, str]
entitydefs: Dict[str, str]
| 114 | Python | .py | 4 | 27.25 | 30 | 0.807339 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,893 | gzip.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/gzip.pyi | import io
from typing import IO, Any, Text
class GzipFile(io.BufferedIOBase):
myfileobj: Any
max_read_chunk: Any
mode: Any
extrabuf: Any
extrasize: Any
extrastart: Any
name: Any
min_readsize: Any
compress: Any
fileobj: Any
offset: Any
mtime: Any
def __init__(
self, filename: str = ..., mode: Text = ..., compresslevel: int = ..., fileobj: IO[str] = ..., mtime: float = ...
) -> None: ...
@property
def filename(self): ...
size: Any
crc: Any
def write(self, data): ...
def read(self, size=...): ...
@property
def closed(self): ...
def close(self): ...
def flush(self, zlib_mode=...): ...
def fileno(self): ...
def rewind(self): ...
def readable(self): ...
def writable(self): ...
def seekable(self): ...
def seek(self, offset, whence=...): ...
def readline(self, size=...): ...
def open(filename: str, mode: Text = ..., compresslevel: int = ...) -> GzipFile: ...
| 997 | Python | .py | 36 | 22.972222 | 121 | 0.569343 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,894 | robotparser.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/robotparser.pyi | class RobotFileParser:
def set_url(self, url: str): ...
def read(self): ...
def parse(self, lines: str): ...
def can_fetch(self, user_agent: str, url: str): ...
def mtime(self): ...
def modified(self): ...
| 230 | Python | .py | 7 | 28.428571 | 55 | 0.58296 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,895 | nturl2path.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/nturl2path.pyi | from typing import AnyStr
def url2pathname(url: AnyStr) -> AnyStr: ...
def pathname2url(p: AnyStr) -> AnyStr: ...
| 115 | Python | .py | 3 | 37 | 44 | 0.720721 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,896 | cookielib.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/cookielib.pyi | from typing import Any, Optional
class Cookie:
version: Any
name: Any
value: Any
port: Any
port_specified: Any
domain: Any
domain_specified: Any
domain_initial_dot: Any
path: Any
path_specified: Any
secure: Any
expires: Any
discard: Any
comment: Any
comment_url: Any
rfc2109: Any
def __init__(
self,
version,
name,
value,
port,
port_specified,
domain,
domain_specified,
domain_initial_dot,
path,
path_specified,
secure,
expires,
discard,
comment,
comment_url,
rest,
rfc2109: bool = ...,
): ...
def has_nonstandard_attr(self, name): ...
def get_nonstandard_attr(self, name, default: Optional[Any] = ...): ...
def set_nonstandard_attr(self, name, value): ...
def is_expired(self, now: Optional[Any] = ...): ...
class CookiePolicy:
def set_ok(self, cookie, request): ...
def return_ok(self, cookie, request): ...
def domain_return_ok(self, domain, request): ...
def path_return_ok(self, path, request): ...
class DefaultCookiePolicy(CookiePolicy):
DomainStrictNoDots: Any
DomainStrictNonDomain: Any
DomainRFC2965Match: Any
DomainLiberal: Any
DomainStrict: Any
netscape: Any
rfc2965: Any
rfc2109_as_netscape: Any
hide_cookie2: Any
strict_domain: Any
strict_rfc2965_unverifiable: Any
strict_ns_unverifiable: Any
strict_ns_domain: Any
strict_ns_set_initial_dollar: Any
strict_ns_set_path: Any
def __init__(
self,
blocked_domains: Optional[Any] = ...,
allowed_domains: Optional[Any] = ...,
netscape: bool = ...,
rfc2965: bool = ...,
rfc2109_as_netscape: Optional[Any] = ...,
hide_cookie2: bool = ...,
strict_domain: bool = ...,
strict_rfc2965_unverifiable: bool = ...,
strict_ns_unverifiable: bool = ...,
strict_ns_domain=...,
strict_ns_set_initial_dollar: bool = ...,
strict_ns_set_path: bool = ...,
): ...
def blocked_domains(self): ...
def set_blocked_domains(self, blocked_domains): ...
def is_blocked(self, domain): ...
def allowed_domains(self): ...
def set_allowed_domains(self, allowed_domains): ...
def is_not_allowed(self, domain): ...
def set_ok(self, cookie, request): ...
def set_ok_version(self, cookie, request): ...
def set_ok_verifiability(self, cookie, request): ...
def set_ok_name(self, cookie, request): ...
def set_ok_path(self, cookie, request): ...
def set_ok_domain(self, cookie, request): ...
def set_ok_port(self, cookie, request): ...
def return_ok(self, cookie, request): ...
def return_ok_version(self, cookie, request): ...
def return_ok_verifiability(self, cookie, request): ...
def return_ok_secure(self, cookie, request): ...
def return_ok_expires(self, cookie, request): ...
def return_ok_port(self, cookie, request): ...
def return_ok_domain(self, cookie, request): ...
def domain_return_ok(self, domain, request): ...
def path_return_ok(self, path, request): ...
class Absent: ...
class CookieJar:
non_word_re: Any
quote_re: Any
strict_domain_re: Any
domain_re: Any
dots_re: Any
magic_re: Any
def __init__(self, policy: Optional[Any] = ...): ...
def set_policy(self, policy): ...
def add_cookie_header(self, request): ...
def make_cookies(self, response, request): ...
def set_cookie_if_ok(self, cookie, request): ...
def set_cookie(self, cookie): ...
def extract_cookies(self, response, request): ...
def clear(self, domain: Optional[Any] = ..., path: Optional[Any] = ..., name: Optional[Any] = ...): ...
def clear_session_cookies(self): ...
def clear_expired_cookies(self): ...
def __iter__(self): ...
def __len__(self): ...
class LoadError(IOError): ...
class FileCookieJar(CookieJar):
filename: Any
delayload: Any
def __init__(self, filename: Optional[Any] = ..., delayload: bool = ..., policy: Optional[Any] = ...): ...
def save(self, filename: Optional[Any] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...): ...
def load(self, filename: Optional[Any] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...): ...
def revert(self, filename: Optional[Any] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...): ...
class LWPCookieJar(FileCookieJar):
def as_lwp_str(self, ignore_discard: bool = ..., ignore_expires: bool = ...) -> str: ... # undocumented
MozillaCookieJar = FileCookieJar
def lwp_cookie_str(cookie: Cookie) -> str: ...
| 4,716 | Python | .py | 132 | 30.045455 | 112 | 0.612593 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,897 | _sre.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/_sre.pyi | from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Union, overload
CODESIZE: int
MAGIC: int
MAXREPEAT: long
copyright: str
class SRE_Match(object):
def start(self, group: int = ...) -> int: ...
def end(self, group: int = ...) -> int: ...
def expand(self, s: str) -> Any: ...
@overload
def group(self) -> str: ...
@overload
def group(self, group: int = ...) -> Optional[str]: ...
def groupdict(self) -> Dict[int, Optional[str]]: ...
def groups(self) -> Tuple[Optional[str], ...]: ...
def span(self) -> Tuple[int, int]: ...
@property
def regs(self) -> Tuple[Tuple[int, int], ...]: ... # undocumented
class SRE_Scanner(object):
pattern: str
def match(self) -> SRE_Match: ...
def search(self) -> SRE_Match: ...
class SRE_Pattern(object):
pattern: str
flags: int
groups: int
groupindex: Mapping[str, int]
indexgroup: Sequence[int]
def findall(self, source: str, pos: int = ..., endpos: int = ...) -> List[Union[Tuple[Any, ...], str]]: ...
def finditer(self, source: str, pos: int = ..., endpos: int = ...) -> Iterable[Union[Tuple[Any, ...], str]]: ...
def match(self, pattern, pos: int = ..., endpos: int = ...) -> SRE_Match: ...
def scanner(self, s: str, start: int = ..., end: int = ...) -> SRE_Scanner: ...
def search(self, pattern, pos: int = ..., endpos: int = ...) -> SRE_Match: ...
def split(self, source: str, maxsplit: int = ...) -> List[Optional[str]]: ...
def sub(self, repl: str, string: str, count: int = ...) -> Tuple[Any, ...]: ...
def subn(self, repl: str, string: str, count: int = ...) -> Tuple[Any, ...]: ...
def compile(
pattern: str,
flags: int,
code: List[int],
groups: int = ...,
groupindex: Mapping[str, int] = ...,
indexgroup: Sequence[int] = ...,
) -> SRE_Pattern: ...
def getcodesize() -> int: ...
def getlower(a: int, b: int) -> int: ...
| 1,934 | Python | .py | 46 | 37.978261 | 116 | 0.574615 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
28,898 | copy_reg.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/copy_reg.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) |
28,899 | UserString.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/UserString.pyi | import collections
from typing import Any, Iterable, List, MutableSequence, Optional, Sequence, Text, Tuple, TypeVar, Union, overload
_UST = TypeVar("_UST", bound=UserString)
_MST = TypeVar("_MST", bound=MutableString)
class UserString(Sequence[UserString]):
data: unicode
def __init__(self, seq: object) -> None: ...
def __int__(self) -> int: ...
def __long__(self) -> long: ...
def __float__(self) -> float: ...
def __complex__(self) -> complex: ...
def __hash__(self) -> int: ...
def __len__(self) -> int: ...
@overload
def __getitem__(self: _UST, i: int) -> _UST: ...
@overload
def __getitem__(self: _UST, s: slice) -> _UST: ...
def __add__(self: _UST, other: Any) -> _UST: ...
def __radd__(self: _UST, other: Any) -> _UST: ...
def __mul__(self: _UST, other: int) -> _UST: ...
def __rmul__(self: _UST, other: int) -> _UST: ...
def __mod__(self: _UST, args: Any) -> _UST: ...
def capitalize(self: _UST) -> _UST: ...
def center(self: _UST, width: int, *args: Any) -> _UST: ...
def count(self, sub: int, start: int = ..., end: int = ...) -> int: ...
def decode(self: _UST, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> _UST: ...
def encode(self: _UST, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> _UST: ...
def endswith(self, suffix: Text, start: int = ..., end: int = ...) -> bool: ...
def expandtabs(self: _UST, tabsize: int = ...) -> _UST: ...
def find(self, sub: Text, start: int = ..., end: int = ...) -> int: ...
def index(self, sub: Text, start: int = ..., end: int = ...) -> int: ...
def isalpha(self) -> bool: ...
def isalnum(self) -> bool: ...
def isdecimal(self) -> bool: ...
def isdigit(self) -> bool: ...
def islower(self) -> bool: ...
def isnumeric(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, seq: Iterable[Text]) -> Text: ...
def ljust(self: _UST, width: int, *args: Any) -> _UST: ...
def lower(self: _UST) -> _UST: ...
def lstrip(self: _UST, chars: Optional[Text] = ...) -> _UST: ...
def partition(self, sep: Text) -> Tuple[Text, Text, Text]: ...
def replace(self: _UST, old: Text, new: Text, maxsplit: int = ...) -> _UST: ...
def rfind(self, sub: Text, start: int = ..., end: int = ...) -> int: ...
def rindex(self, sub: Text, start: int = ..., end: int = ...) -> int: ...
def rjust(self: _UST, width: int, *args: Any) -> _UST: ...
def rpartition(self, sep: Text) -> Tuple[Text, Text, Text]: ...
def rstrip(self: _UST, chars: Optional[Text] = ...) -> _UST: ...
def split(self, sep: Optional[Text] = ..., maxsplit: int = ...) -> List[Text]: ...
def rsplit(self, sep: Optional[Text] = ..., maxsplit: int = ...) -> List[Text]: ...
def splitlines(self, keepends: int = ...) -> List[Text]: ...
def startswith(self, suffix: Text, start: int = ..., end: int = ...) -> bool: ...
def strip(self: _UST, chars: Optional[Text] = ...) -> _UST: ...
def swapcase(self: _UST) -> _UST: ...
def title(self: _UST) -> _UST: ...
def translate(self: _UST, *args: Any) -> _UST: ...
def upper(self: _UST) -> _UST: ...
def zfill(self: _UST, width: int) -> _UST: ...
class MutableString(UserString, MutableSequence[MutableString]):
@overload
def __getitem__(self: _MST, i: int) -> _MST: ...
@overload
def __getitem__(self: _MST, s: slice) -> _MST: ...
def __setitem__(self, index: Union[int, slice], sub: Any) -> None: ...
def __delitem__(self, index: Union[int, slice]) -> None: ...
def immutable(self) -> UserString: ...
def __iadd__(self: _MST, other: Any) -> _MST: ...
def __imul__(self, n: int) -> _MST: ...
def insert(self, index: int, value: Any) -> None: ...
| 3,844 | Python | .py | 72 | 48.680556 | 114 | 0.540727 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |