id int64 0 458k | file_name stringlengths 4 119 | file_path stringlengths 14 227 | content stringlengths 24 9.96M | size int64 24 9.96M | language stringclasses 1 value | extension stringclasses 14 values | total_lines int64 1 219k | avg_line_length float64 2.52 4.63M | max_line_length int64 5 9.91M | alphanum_fraction float64 0 1 | repo_name stringlengths 7 101 | repo_stars int64 100 139k | repo_forks int64 0 26.4k | repo_open_issues int64 0 2.27k | repo_license stringclasses 12 values | repo_extraction_date stringclasses 433 values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
29,400 | client.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/http/client.pyi | import email.message
import io
import ssl
import sys
import types
from socket import socket
from typing import (
IO,
Any,
BinaryIO,
Callable,
Dict,
Iterable,
Iterator,
List,
Mapping,
Optional,
Protocol,
Tuple,
Type,
TypeVar,
Union,
overload,
)
_DataType = Union[bytes, IO[Any], Iterable[bytes], str]
_T = TypeVar("_T")
HTTP_PORT: int
HTTPS_PORT: int
CONTINUE: int
SWITCHING_PROTOCOLS: int
PROCESSING: int
OK: int
CREATED: int
ACCEPTED: int
NON_AUTHORITATIVE_INFORMATION: int
NO_CONTENT: int
RESET_CONTENT: int
PARTIAL_CONTENT: int
MULTI_STATUS: int
IM_USED: int
MULTIPLE_CHOICES: int
MOVED_PERMANENTLY: int
FOUND: int
SEE_OTHER: int
NOT_MODIFIED: int
USE_PROXY: int
TEMPORARY_REDIRECT: int
BAD_REQUEST: int
UNAUTHORIZED: int
PAYMENT_REQUIRED: int
FORBIDDEN: int
NOT_FOUND: int
METHOD_NOT_ALLOWED: int
NOT_ACCEPTABLE: int
PROXY_AUTHENTICATION_REQUIRED: int
REQUEST_TIMEOUT: int
CONFLICT: int
GONE: int
LENGTH_REQUIRED: int
PRECONDITION_FAILED: int
REQUEST_ENTITY_TOO_LARGE: int
REQUEST_URI_TOO_LONG: int
UNSUPPORTED_MEDIA_TYPE: int
REQUESTED_RANGE_NOT_SATISFIABLE: int
EXPECTATION_FAILED: int
UNPROCESSABLE_ENTITY: int
LOCKED: int
FAILED_DEPENDENCY: int
UPGRADE_REQUIRED: int
PRECONDITION_REQUIRED: int
TOO_MANY_REQUESTS: int
REQUEST_HEADER_FIELDS_TOO_LARGE: int
INTERNAL_SERVER_ERROR: int
NOT_IMPLEMENTED: int
BAD_GATEWAY: int
SERVICE_UNAVAILABLE: int
GATEWAY_TIMEOUT: int
HTTP_VERSION_NOT_SUPPORTED: int
INSUFFICIENT_STORAGE: int
NOT_EXTENDED: int
NETWORK_AUTHENTICATION_REQUIRED: int
responses: Dict[int, str]
class HTTPMessage(email.message.Message): ...
def parse_headers(fp: io.BufferedIOBase, _class: Callable[[], email.message.Message] = ...) -> HTTPMessage: ...
class HTTPResponse(io.BufferedIOBase, BinaryIO):
msg: HTTPMessage
headers: HTTPMessage
version: int
debuglevel: int
closed: bool
status: int
reason: str
def __init__(self, sock: socket, debuglevel: int = ..., method: Optional[str] = ..., url: Optional[str] = ...) -> None: ...
def read(self, amt: Optional[int] = ...) -> bytes: ...
@overload
def getheader(self, name: str) -> Optional[str]: ...
@overload
def getheader(self, name: str, default: _T) -> Union[str, _T]: ...
def getheaders(self) -> List[Tuple[str, str]]: ...
def fileno(self) -> int: ...
def isclosed(self) -> bool: ...
def __iter__(self) -> Iterator[bytes]: ...
def __enter__(self) -> HTTPResponse: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[types.TracebackType]
) -> Optional[bool]: ...
def info(self) -> email.message.Message: ...
def geturl(self) -> str: ...
def getcode(self) -> int: ...
def begin(self) -> None: ...
# This is an API stub only for the class below, not a class itself.
# urllib.request uses it for a parameter.
class _HTTPConnectionProtocol(Protocol):
if sys.version_info >= (3, 7):
def __call__(
self,
host: str,
port: Optional[int] = ...,
timeout: float = ...,
source_address: Optional[Tuple[str, int]] = ...,
blocksize: int = ...,
) -> HTTPConnection: ...
else:
def __call__(
self, host: str, port: Optional[int] = ..., timeout: float = ..., source_address: Optional[Tuple[str, int]] = ...
) -> HTTPConnection: ...
class HTTPConnection:
timeout: Optional[float]
host: str
port: int
sock: Any
if sys.version_info >= (3, 7):
def __init__(
self,
host: str,
port: Optional[int] = ...,
timeout: Optional[float] = ...,
source_address: Optional[Tuple[str, int]] = ...,
blocksize: int = ...,
) -> None: ...
else:
def __init__(
self,
host: str,
port: Optional[int] = ...,
timeout: Optional[float] = ...,
source_address: Optional[Tuple[str, int]] = ...,
) -> None: ...
def request(
self,
method: str,
url: str,
body: Optional[_DataType] = ...,
headers: Mapping[str, str] = ...,
*,
encode_chunked: bool = ...,
) -> None: ...
def getresponse(self) -> HTTPResponse: ...
def set_debuglevel(self, level: int) -> None: ...
def set_tunnel(self, host: str, port: Optional[int] = ..., headers: Optional[Mapping[str, str]] = ...) -> None: ...
def connect(self) -> None: ...
def close(self) -> None: ...
def putrequest(self, method: str, url: str, skip_host: bool = ..., skip_accept_encoding: bool = ...) -> None: ...
def putheader(self, header: str, *argument: str) -> None: ...
def endheaders(self, message_body: Optional[_DataType] = ..., *, encode_chunked: bool = ...) -> None: ...
def send(self, data: _DataType) -> None: ...
class HTTPSConnection(HTTPConnection):
def __init__(
self,
host: str,
port: Optional[int] = ...,
key_file: Optional[str] = ...,
cert_file: Optional[str] = ...,
timeout: Optional[float] = ...,
source_address: Optional[Tuple[str, int]] = ...,
*,
context: Optional[ssl.SSLContext] = ...,
check_hostname: Optional[bool] = ...,
) -> None: ...
class HTTPException(Exception): ...
error = HTTPException
class NotConnected(HTTPException): ...
class InvalidURL(HTTPException): ...
class UnknownProtocol(HTTPException): ...
class UnknownTransferEncoding(HTTPException): ...
class UnimplementedFileMode(HTTPException): ...
class IncompleteRead(HTTPException): ...
class ImproperConnectionState(HTTPException): ...
class CannotSendRequest(ImproperConnectionState): ...
class CannotSendHeader(ImproperConnectionState): ...
class ResponseNotReady(ImproperConnectionState): ...
class BadStatusLine(HTTPException): ...
class LineTooLong(HTTPException): ...
class RemoteDisconnected(ConnectionResetError, BadStatusLine): ...
| 6,034 | Python | .py | 194 | 26.572165 | 127 | 0.642624 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,401 | cookies.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/http/cookies.pyi | import sys
from typing import Any, Dict, Generic, List, Mapping, Optional, TypeVar, Union
_DataType = Union[str, Mapping[str, Union[str, Morsel[Any]]]]
_T = TypeVar("_T")
class CookieError(Exception): ...
class Morsel(Dict[str, Any], Generic[_T]):
value: str
coded_value: _T
key: str
if sys.version_info >= (3, 7):
def set(self, key: str, val: str, coded_val: _T) -> None: ...
else:
def set(self, key: str, val: str, coded_val: _T, LegalChars: str = ...) -> None: ...
def isReservedKey(self, K: str) -> bool: ...
def output(self, attrs: Optional[List[str]] = ..., header: str = ...) -> str: ...
def js_output(self, attrs: Optional[List[str]] = ...) -> str: ...
def OutputString(self, attrs: Optional[List[str]] = ...) -> str: ...
class BaseCookie(Dict[str, Morsel[_T]], Generic[_T]):
def __init__(self, input: Optional[_DataType] = ...) -> None: ...
def value_decode(self, val: str) -> _T: ...
def value_encode(self, val: _T) -> str: ...
def output(self, attrs: Optional[List[str]] = ..., header: str = ..., sep: str = ...) -> str: ...
def js_output(self, attrs: Optional[List[str]] = ...) -> str: ...
def load(self, rawdata: _DataType) -> None: ...
def __setitem__(self, key: str, value: Union[str, Morsel[_T]]) -> None: ...
class SimpleCookie(BaseCookie[_T], Generic[_T]): ...
| 1,364 | Python | .py | 26 | 48.192308 | 101 | 0.585896 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,402 | cookiejar.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/http/cookiejar.pyi | import sys
from http.client import HTTPResponse
from os import PathLike
from typing import Dict, Iterable, Iterator, Optional, Sequence, Tuple, TypeVar, Union, overload
from urllib.request import Request
_T = TypeVar("_T")
class LoadError(OSError): ...
class CookieJar(Iterable[Cookie]):
def __init__(self, policy: Optional[CookiePolicy] = ...) -> None: ...
def add_cookie_header(self, request: Request) -> None: ...
def extract_cookies(self, response: HTTPResponse, request: Request) -> None: ...
def set_policy(self, policy: CookiePolicy) -> None: ...
def make_cookies(self, response: HTTPResponse, request: Request) -> Sequence[Cookie]: ...
def set_cookie(self, cookie: Cookie) -> None: ...
def set_cookie_if_ok(self, cookie: Cookie, request: Request) -> None: ...
def clear(self, domain: str = ..., path: str = ..., name: str = ...) -> None: ...
def clear_session_cookies(self) -> None: ...
def __iter__(self) -> Iterator[Cookie]: ...
def __len__(self) -> int: ...
class FileCookieJar(CookieJar):
filename: str
delayload: bool
if sys.version_info >= (3, 8):
def __init__(
self, filename: Union[str, PathLike[str]] = ..., delayload: bool = ..., policy: Optional[CookiePolicy] = ...
) -> None: ...
else:
def __init__(self, filename: str = ..., delayload: bool = ..., policy: Optional[CookiePolicy] = ...) -> None: ...
def save(self, filename: Optional[str] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...) -> None: ...
def load(self, filename: Optional[str] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...) -> None: ...
def revert(self, filename: Optional[str] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...) -> None: ...
class MozillaCookieJar(FileCookieJar): ...
class LWPCookieJar(FileCookieJar):
def as_lwp_str(self, ignore_discard: bool = ..., ignore_expires: bool = ...) -> str: ... # undocumented
class CookiePolicy:
netscape: bool
rfc2965: bool
hide_cookie2: bool
def set_ok(self, cookie: Cookie, request: Request) -> bool: ...
def return_ok(self, cookie: Cookie, request: Request) -> bool: ...
def domain_return_ok(self, domain: str, request: Request) -> bool: ...
def path_return_ok(self, path: str, request: Request) -> bool: ...
class DefaultCookiePolicy(CookiePolicy):
rfc2109_as_netscape: bool
strict_domain: bool
strict_rfc2965_unverifiable: bool
strict_ns_unverifiable: bool
strict_ns_domain: int
strict_ns_set_initial_dollar: bool
strict_ns_set_path: bool
DomainStrictNoDots: int
DomainStrictNonDomain: int
DomainRFC2965Match: int
DomainLiberal: int
DomainStrict: int
def __init__(
self,
blocked_domains: Optional[Sequence[str]] = ...,
allowed_domains: Optional[Sequence[str]] = ...,
netscape: bool = ...,
rfc2965: bool = ...,
rfc2109_as_netscape: Optional[bool] = ...,
hide_cookie2: bool = ...,
strict_domain: bool = ...,
strict_rfc2965_unverifiable: bool = ...,
strict_ns_unverifiable: bool = ...,
strict_ns_domain: int = ...,
strict_ns_set_initial_dollar: bool = ...,
strict_ns_set_path: bool = ...,
) -> None: ...
def blocked_domains(self) -> Tuple[str, ...]: ...
def set_blocked_domains(self, blocked_domains: Sequence[str]) -> None: ...
def is_blocked(self, domain: str) -> bool: ...
def allowed_domains(self) -> Optional[Tuple[str, ...]]: ...
def set_allowed_domains(self, allowed_domains: Optional[Sequence[str]]) -> None: ...
def is_not_allowed(self, domain: str) -> bool: ...
class Cookie:
version: Optional[int]
name: str
value: Optional[str]
port: Optional[str]
path: str
path_specified: bool
secure: bool
expires: Optional[int]
discard: bool
comment: Optional[str]
comment_url: Optional[str]
rfc2109: bool
port_specified: bool
domain: str # undocumented
domain_specified: bool
domain_initial_dot: bool
def __init__(
self,
version: Optional[int],
name: str,
value: Optional[str], # undocumented
port: Optional[str],
port_specified: bool,
domain: str,
domain_specified: bool,
domain_initial_dot: bool,
path: str,
path_specified: bool,
secure: bool,
expires: Optional[int],
discard: bool,
comment: Optional[str],
comment_url: Optional[str],
rest: Dict[str, str],
rfc2109: bool = ...,
) -> None: ...
def has_nonstandard_attr(self, name: str) -> bool: ...
@overload
def get_nonstandard_attr(self, name: str) -> Optional[str]: ...
@overload
def get_nonstandard_attr(self, name: str, default: _T = ...) -> Union[str, _T]: ...
def set_nonstandard_attr(self, name: str, value: str) -> None: ...
def is_expired(self, now: int = ...) -> bool: ...
| 4,991 | Python | .py | 120 | 35.783333 | 121 | 0.617236 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,403 | server.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/http/server.pyi | import email.message
import socketserver
import sys
from typing import Any, Callable, ClassVar, Dict, List, Mapping, Optional, Sequence, Tuple, Union
if sys.version_info >= (3, 7):
from builtins import _PathLike
class HTTPServer(socketserver.TCPServer):
server_name: str
server_port: int
def __init__(self, server_address: Tuple[str, int], RequestHandlerClass: Callable[..., BaseHTTPRequestHandler]) -> None: ...
if sys.version_info >= (3, 7):
class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
daemon_threads: bool # undocumented
class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
client_address: Tuple[str, int]
server: socketserver.BaseServer
close_connection: bool
requestline: str
command: str
path: str
request_version: str
headers: email.message.Message
server_version: str
sys_version: str
error_message_format: str
error_content_type: str
protocol_version: str
MessageClass: type
responses: Mapping[int, Tuple[str, str]]
weekdayname: ClassVar[Sequence[str]] = ... # Undocumented
monthname: ClassVar[Sequence[Optional[str]]] = ... # Undocumented
def __init__(self, request: bytes, client_address: Tuple[str, int], server: socketserver.BaseServer) -> None: ...
def handle(self) -> None: ...
def handle_one_request(self) -> None: ...
def handle_expect_100(self) -> bool: ...
def send_error(self, code: int, message: Optional[str] = ..., explain: Optional[str] = ...) -> None: ...
def send_response(self, code: int, message: Optional[str] = ...) -> None: ...
def send_header(self, keyword: str, value: str) -> None: ...
def send_response_only(self, code: int, message: Optional[str] = ...) -> None: ...
def end_headers(self) -> None: ...
def flush_headers(self) -> None: ...
def log_request(self, code: Union[int, str] = ..., size: Union[int, str] = ...) -> None: ...
def log_error(self, format: str, *args: Any) -> None: ...
def log_message(self, format: str, *args: Any) -> None: ...
def version_string(self) -> str: ...
def date_time_string(self, timestamp: Optional[int] = ...) -> str: ...
def log_date_time_string(self) -> str: ...
def address_string(self) -> str: ...
def parse_request(self) -> bool: ... # Undocumented
class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
extensions_map: Dict[str, str]
if sys.version_info >= (3, 7):
def __init__(
self,
request: bytes,
client_address: Tuple[str, int],
server: socketserver.BaseServer,
directory: Optional[Union[str, _PathLike[str]]] = ...,
) -> None: ...
else:
def __init__(self, request: bytes, client_address: Tuple[str, int], server: socketserver.BaseServer) -> None: ...
def do_GET(self) -> None: ...
def do_HEAD(self) -> None: ...
class CGIHTTPRequestHandler(SimpleHTTPRequestHandler):
cgi_directories: List[str]
def do_POST(self) -> None: ...
| 3,036 | Python | .py | 66 | 40.666667 | 128 | 0.651147 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,404 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/http/__init__.pyi | import sys
from enum import IntEnum
from typing_extensions import Literal
class HTTPStatus(IntEnum):
@property
def phrase(self) -> str: ...
@property
def description(self) -> str: ...
CONTINUE: int
SWITCHING_PROTOCOLS: int
PROCESSING: int
OK: int
CREATED: int
ACCEPTED: int
NON_AUTHORITATIVE_INFORMATION: int
NO_CONTENT: int
RESET_CONTENT: int
PARTIAL_CONTENT: int
MULTI_STATUS: int
ALREADY_REPORTED: int
IM_USED: int
MULTIPLE_CHOICES: int
MOVED_PERMANENTLY: int
FOUND: int
SEE_OTHER: int
NOT_MODIFIED: int
USE_PROXY: int
TEMPORARY_REDIRECT: int
PERMANENT_REDIRECT: int
BAD_REQUEST: int
UNAUTHORIZED: int
PAYMENT_REQUIRED: int
FORBIDDEN: int
NOT_FOUND: int
METHOD_NOT_ALLOWED: int
NOT_ACCEPTABLE: int
PROXY_AUTHENTICATION_REQUIRED: int
REQUEST_TIMEOUT: int
CONFLICT: int
GONE: int
LENGTH_REQUIRED: int
PRECONDITION_FAILED: int
REQUEST_ENTITY_TOO_LARGE: int
REQUEST_URI_TOO_LONG: int
UNSUPPORTED_MEDIA_TYPE: int
REQUESTED_RANGE_NOT_SATISFIABLE: int
EXPECTATION_FAILED: int
UNPROCESSABLE_ENTITY: int
LOCKED: int
FAILED_DEPENDENCY: int
UPGRADE_REQUIRED: int
PRECONDITION_REQUIRED: int
TOO_MANY_REQUESTS: int
REQUEST_HEADER_FIELDS_TOO_LARGE: int
INTERNAL_SERVER_ERROR: int
NOT_IMPLEMENTED: int
BAD_GATEWAY: int
SERVICE_UNAVAILABLE: int
GATEWAY_TIMEOUT: int
HTTP_VERSION_NOT_SUPPORTED: int
VARIANT_ALSO_NEGOTIATES: int
INSUFFICIENT_STORAGE: int
LOOP_DETECTED: int
NOT_EXTENDED: int
NETWORK_AUTHENTICATION_REQUIRED: int
if sys.version_info >= (3, 7):
MISDIRECTED_REQUEST: int
if sys.version_info >= (3, 8):
UNAVAILABLE_FOR_LEGAL_REASONS: int
if sys.version_info >= (3, 9):
EARLY_HINTS: Literal[103]
IM_A_TEAPOT: Literal[418]
TOO_EARLY: Literal[425]
| 1,940 | Python | .py | 73 | 21.506849 | 42 | 0.692926 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,405 | util.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/importlib/util.pyi | import importlib.abc
import importlib.machinery
import os
import types
from typing import Any, Callable, List, Optional, Union
def module_for_loader(fxn: Callable[..., types.ModuleType]) -> Callable[..., types.ModuleType]: ...
def set_loader(fxn: Callable[..., types.ModuleType]) -> Callable[..., types.ModuleType]: ...
def set_package(fxn: Callable[..., types.ModuleType]) -> Callable[..., types.ModuleType]: ...
def resolve_name(name: str, package: str) -> str: ...
MAGIC_NUMBER: bytes
def cache_from_source(path: str, debug_override: Optional[bool] = ..., *, optimization: Optional[Any] = ...) -> str: ...
def source_from_cache(path: str) -> str: ...
def decode_source(source_bytes: bytes) -> str: ...
def find_spec(name: str, package: Optional[str] = ...) -> Optional[importlib.machinery.ModuleSpec]: ...
def spec_from_loader(
name: str,
loader: Optional[importlib.abc.Loader],
*,
origin: Optional[str] = ...,
loader_state: Optional[Any] = ...,
is_package: Optional[bool] = ...,
) -> importlib.machinery.ModuleSpec: ...
def spec_from_file_location(
name: str,
location: Union[str, bytes, os.PathLike[str], os.PathLike[bytes]],
*,
loader: Optional[importlib.abc.Loader] = ...,
submodule_search_locations: Optional[List[str]] = ...,
) -> importlib.machinery.ModuleSpec: ...
def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ...
class LazyLoader(importlib.abc.Loader):
def __init__(self, loader: importlib.abc.Loader) -> None: ...
@classmethod
def factory(cls, loader: importlib.abc.Loader) -> Callable[..., LazyLoader]: ...
def create_module(self, spec: importlib.machinery.ModuleSpec) -> Optional[types.ModuleType]: ...
def exec_module(self, module: types.ModuleType) -> None: ...
| 1,782 | Python | .py | 36 | 46.611111 | 120 | 0.685993 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,406 | metadata.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/importlib/metadata.pyi | import abc
import os
import pathlib
import sys
from email.message import Message
from importlib.abc import MetaPathFinder
from pathlib import Path
from typing import Any, Dict, Iterable, List, NamedTuple, Optional, Tuple, Union, overload
if sys.version_info >= (3, 8):
class PackageNotFoundError(ModuleNotFoundError): ...
class EntryPointBase(NamedTuple):
name: str
value: str
group: str
class EntryPoint(EntryPointBase):
def load(self) -> Any: ... # Callable[[], Any] or an importable module
@property
def extras(self) -> List[str]: ...
class PackagePath(pathlib.PurePosixPath):
def read_text(self, encoding: str = ...) -> str: ...
def read_binary(self) -> bytes: ...
def locate(self) -> os.PathLike[str]: ...
# The following attributes are not defined on PackagePath, but are dynamically added by Distribution.files:
hash: Optional[FileHash]
size: Optional[int]
dist: Distribution
class FileHash:
mode: str
value: str
def __init__(self, spec: str) -> None: ...
class Distribution:
@abc.abstractmethod
def read_text(self, filename: str) -> Optional[str]: ...
@abc.abstractmethod
def locate_file(self, path: Union[os.PathLike[str], str]) -> os.PathLike[str]: ...
@classmethod
def from_name(cls, name: str) -> Distribution: ...
@overload
@classmethod
def discover(cls, *, context: DistributionFinder.Context) -> Iterable[Distribution]: ...
@overload
@classmethod
def discover(
cls, *, context: None = ..., name: Optional[str] = ..., path: List[str] = ..., **kwargs: Any
) -> Iterable[Distribution]: ...
@staticmethod
def at(path: Union[str, os.PathLike[str]]) -> PathDistribution: ...
@property
def metadata(self) -> Message: ...
@property
def version(self) -> str: ...
@property
def entry_points(self) -> List[EntryPoint]: ...
@property
def files(self) -> Optional[List[PackagePath]]: ...
@property
def requires(self) -> Optional[List[str]]: ...
class DistributionFinder(MetaPathFinder):
class Context:
name: Optional[str]
def __init__(self, *, name: Optional[str] = ..., path: List[str] = ..., **kwargs: Any) -> None: ...
@property
def path(self) -> List[str]: ...
@property
def pattern(self) -> str: ...
@abc.abstractmethod
def find_distributions(self, context: Context = ...) -> Iterable[Distribution]: ...
class MetadataPathFinder(DistributionFinder):
@classmethod
def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
class PathDistribution(Distribution):
def __init__(self, path: Path) -> None: ...
def read_text(self, filename: Union[str, os.PathLike[str]]) -> str: ...
def locate_file(self, path: Union[str, os.PathLike[str]]) -> os.PathLike[str]: ...
def distribution(distribution_name: str) -> Distribution: ...
@overload
def distributions(*, context: DistributionFinder.Context) -> Iterable[Distribution]: ...
@overload
def distributions(
*, context: None = ..., name: Optional[str] = ..., path: List[str] = ..., **kwargs: Any
) -> Iterable[Distribution]: ...
def metadata(distribution_name: str) -> Message: ...
def version(distribution_name: str) -> str: ...
def entry_points() -> Dict[str, Tuple[EntryPoint, ...]]: ...
def files(distribution_name: str) -> Optional[List[PackagePath]]: ...
def requires(distribution_name: str) -> Optional[List[str]]: ...
| 3,786 | Python | .py | 86 | 36.453488 | 115 | 0.611246 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,407 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/importlib/__init__.pyi | import types
from importlib.abc import Loader
from typing import Any, Mapping, Optional, Sequence
def __import__(
name: str,
globals: Optional[Mapping[str, Any]] = ...,
locals: Optional[Mapping[str, Any]] = ...,
fromlist: Sequence[str] = ...,
level: int = ...,
) -> types.ModuleType: ...
def import_module(name: str, package: Optional[str] = ...) -> types.ModuleType: ...
def find_loader(name: str, path: Optional[str] = ...) -> Optional[Loader]: ...
def invalidate_caches() -> None: ...
def reload(module: types.ModuleType) -> types.ModuleType: ...
| 571 | Python | .py | 14 | 38.285714 | 83 | 0.658273 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,408 | machinery.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/importlib/machinery.pyi | import importlib.abc
import types
from typing import Callable, List, Optional, Sequence, Tuple, Union
# ModuleSpec is exported from this module, but for circular import
# reasons exists in its own stub file (with Loader and ModuleType).
from _importlib_modulespec import Loader, ModuleSpec as ModuleSpec # Exported
class BuiltinImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
# MetaPathFinder
@classmethod
def find_module(cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]]) -> Optional[importlib.abc.Loader]: ...
@classmethod
def find_spec(
cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]], target: Optional[types.ModuleType] = ...
) -> Optional[ModuleSpec]: ...
# InspectLoader
@classmethod
def is_package(cls, fullname: str) -> bool: ...
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
@classmethod
def get_code(cls, fullname: str) -> None: ...
@classmethod
def get_source(cls, fullname: str) -> None: ...
# Loader
@staticmethod
def module_repr(module: types.ModuleType) -> str: ...
@classmethod
def create_module(cls, spec: ModuleSpec) -> Optional[types.ModuleType]: ...
@classmethod
def exec_module(cls, module: types.ModuleType) -> None: ...
class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
# MetaPathFinder
@classmethod
def find_module(cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]]) -> Optional[importlib.abc.Loader]: ...
@classmethod
def find_spec(
cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]], target: Optional[types.ModuleType] = ...
) -> Optional[ModuleSpec]: ...
# InspectLoader
@classmethod
def is_package(cls, fullname: str) -> bool: ...
@classmethod
def load_module(cls, fullname: str) -> types.ModuleType: ...
@classmethod
def get_code(cls, fullname: str) -> None: ...
@classmethod
def get_source(cls, fullname: str) -> None: ...
# Loader
@staticmethod
def module_repr(module: types.ModuleType) -> str: ...
@classmethod
def create_module(cls, spec: ModuleSpec) -> Optional[types.ModuleType]: ...
@staticmethod
def exec_module(module: types.ModuleType) -> None: ...
class WindowsRegistryFinder(importlib.abc.MetaPathFinder):
@classmethod
def find_module(cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]]) -> Optional[importlib.abc.Loader]: ...
@classmethod
def find_spec(
cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]], target: Optional[types.ModuleType] = ...
) -> Optional[ModuleSpec]: ...
class PathFinder:
@classmethod
def invalidate_caches(cls) -> None: ...
@classmethod
def find_spec(
cls, fullname: str, path: Optional[Sequence[Union[bytes, str]]] = ..., target: Optional[types.ModuleType] = ...
) -> Optional[ModuleSpec]: ...
@classmethod
def find_module(cls, fullname: str, path: Optional[Sequence[Union[bytes, str]]] = ...) -> Optional[Loader]: ...
SOURCE_SUFFIXES: List[str]
DEBUG_BYTECODE_SUFFIXES: List[str]
OPTIMIZED_BYTECODE_SUFFIXES: List[str]
BYTECODE_SUFFIXES: List[str]
EXTENSION_SUFFIXES: List[str]
def all_suffixes() -> List[str]: ...
class FileFinder(importlib.abc.PathEntryFinder):
path: str
def __init__(self, path: str, *loader_details: Tuple[importlib.abc.Loader, List[str]]) -> None: ...
@classmethod
def path_hook(
cls, *loader_details: Tuple[importlib.abc.Loader, List[str]]
) -> Callable[[str], importlib.abc.PathEntryFinder]: ...
class SourceFileLoader(importlib.abc.FileLoader, importlib.abc.SourceLoader): ...
class SourcelessFileLoader(importlib.abc.FileLoader, importlib.abc.SourceLoader): ...
class ExtensionFileLoader(importlib.abc.ExecutionLoader):
def get_filename(self, fullname: str) -> importlib.abc._Path: ...
def get_source(self, fullname: str) -> None: ...
| 4,006 | Python | .py | 88 | 41.090909 | 125 | 0.700358 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,409 | resources.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/importlib/resources.pyi | import sys
# This is a >=3.7 module, so we conditionally include its source.
if sys.version_info >= (3, 7):
import os
from pathlib import Path
from types import ModuleType
from typing import BinaryIO, ContextManager, Iterator, TextIO, Union
Package = Union[str, ModuleType]
Resource = Union[str, os.PathLike]
def open_binary(package: Package, resource: Resource) -> BinaryIO: ...
def open_text(package: Package, resource: Resource, encoding: str = ..., errors: str = ...) -> TextIO: ...
def read_binary(package: Package, resource: Resource) -> bytes: ...
def read_text(package: Package, resource: Resource, encoding: str = ..., errors: str = ...) -> str: ...
def path(package: Package, resource: Resource) -> ContextManager[Path]: ...
def is_resource(package: Package, name: str) -> bool: ...
def contents(package: Package) -> Iterator[str]: ...
if sys.version_info >= (3, 9):
from importlib.abc import Traversable
def files(package: Package) -> Traversable: ...
| 1,026 | Python | .py | 19 | 49.684211 | 110 | 0.677291 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,410 | abc.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/importlib/abc.pyi | import os
import sys
import types
from abc import ABCMeta, abstractmethod
from typing import IO, Any, Iterator, Mapping, Optional, Sequence, Tuple, Union
from typing_extensions import Literal
# Loader is exported from this module, but for circular import reasons
# exists in its own stub file (with ModuleSpec and ModuleType).
from _importlib_modulespec import Loader as Loader, ModuleSpec # Exported
_Path = Union[bytes, str]
class Finder(metaclass=ABCMeta): ...
class ResourceLoader(Loader):
@abstractmethod
def get_data(self, path: _Path) -> bytes: ...
class InspectLoader(Loader):
def is_package(self, fullname: str) -> bool: ...
def get_code(self, fullname: str) -> Optional[types.CodeType]: ...
def load_module(self, fullname: str) -> types.ModuleType: ...
@abstractmethod
def get_source(self, fullname: str) -> Optional[str]: ...
def exec_module(self, module: types.ModuleType) -> None: ...
@staticmethod
def source_to_code(data: Union[bytes, str], path: str = ...) -> types.CodeType: ...
class ExecutionLoader(InspectLoader):
@abstractmethod
def get_filename(self, fullname: str) -> _Path: ...
def get_code(self, fullname: str) -> Optional[types.CodeType]: ...
class SourceLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta):
def path_mtime(self, path: _Path) -> float: ...
def set_data(self, path: _Path, data: bytes) -> None: ...
def get_source(self, fullname: str) -> Optional[str]: ...
def path_stats(self, path: _Path) -> Mapping[str, Any]: ...
class MetaPathFinder(Finder):
def find_module(self, fullname: str, path: Optional[Sequence[_Path]]) -> Optional[Loader]: ...
def invalidate_caches(self) -> None: ...
# Not defined on the actual class, but expected to exist.
def find_spec(
self, fullname: str, path: Optional[Sequence[_Path]], target: Optional[types.ModuleType] = ...
) -> Optional[ModuleSpec]: ...
class PathEntryFinder(Finder):
def find_module(self, fullname: str) -> Optional[Loader]: ...
def find_loader(self, fullname: str) -> Tuple[Optional[Loader], Sequence[_Path]]: ...
def invalidate_caches(self) -> None: ...
# Not defined on the actual class, but expected to exist.
def find_spec(self, fullname: str, target: Optional[types.ModuleType] = ...) -> Optional[ModuleSpec]: ...
class FileLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta):
name: str
path: _Path
def __init__(self, fullname: str, path: _Path) -> None: ...
def get_data(self, path: _Path) -> bytes: ...
def get_filename(self, fullname: str) -> _Path: ...
if sys.version_info >= (3, 7):
_PathLike = Union[bytes, str, os.PathLike[Any]]
class ResourceReader(metaclass=ABCMeta):
@abstractmethod
def open_resource(self, resource: _PathLike) -> IO[bytes]: ...
@abstractmethod
def resource_path(self, resource: _PathLike) -> str: ...
@abstractmethod
def is_resource(self, name: str) -> bool: ...
@abstractmethod
def contents(self) -> Iterator[str]: ...
if sys.version_info >= (3, 9):
from typing import Protocol, runtime_checkable
@runtime_checkable
class Traversable(Protocol):
@abstractmethod
def iterdir(self) -> Iterator[Traversable]: ...
@abstractmethod
def read_bytes(self) -> bytes: ...
@abstractmethod
def read_text(self, encoding: Optional[str] = ...) -> str: ...
@abstractmethod
def is_dir(self) -> bool: ...
@abstractmethod
def is_file(self) -> bool: ...
@abstractmethod
def joinpath(self, child: Traversable) -> Traversable: ...
@abstractmethod
def __truediv__(self, child: Traversable) -> Traversable: ...
@abstractmethod
def open(self, mode: Literal["r", "rb"] = ..., *args: Any, **kwargs: Any) -> IO: ...
@property
@abstractmethod
def name(self) -> str: ...
| 3,960 | Python | .py | 85 | 41.070588 | 109 | 0.656226 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,411 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/collections/__init__.pyi | import sys
import typing
from typing import (
AbstractSet,
Any,
AsyncGenerator as AsyncGenerator,
AsyncIterable as AsyncIterable,
AsyncIterator as AsyncIterator,
Awaitable as Awaitable,
ByteString as ByteString,
Callable as Callable,
Collection as Collection,
Container as Container,
Coroutine as Coroutine,
Dict,
Generator as Generator,
Generic,
Hashable as Hashable,
ItemsView as ItemsView,
Iterable as Iterable,
Iterator as Iterator,
KeysView as KeysView,
List,
Mapping as Mapping,
MappingView as MappingView,
MutableMapping as MutableMapping,
MutableSequence as MutableSequence,
MutableSet as MutableSet,
Optional,
Reversible as Reversible,
Sequence as Sequence,
Sized as Sized,
Tuple,
Type,
TypeVar,
Union,
ValuesView as ValuesView,
overload,
)
Set = AbstractSet
_S = TypeVar("_S")
_T = TypeVar("_T")
_KT = TypeVar("_KT")
_VT = TypeVar("_VT")
# namedtuple is special-cased in the type checker; the initializer is ignored.
if sys.version_info >= (3, 7):
def namedtuple(
typename: str,
field_names: Union[str, Iterable[str]],
*,
rename: bool = ...,
module: Optional[str] = ...,
defaults: Optional[Iterable[Any]] = ...,
) -> Type[Tuple[Any, ...]]: ...
else:
def namedtuple(
typename: str,
field_names: Union[str, Iterable[str]],
*,
verbose: bool = ...,
rename: bool = ...,
module: Optional[str] = ...,
) -> Type[Tuple[Any, ...]]: ...
class UserDict(MutableMapping[_KT, _VT]):
data: Dict[_KT, _VT]
def __init__(self, __dict: Optional[Mapping[_KT, _VT]] = ..., **kwargs: _VT) -> None: ...
def __len__(self) -> int: ...
def __getitem__(self, key: _KT) -> _VT: ...
def __setitem__(self, key: _KT, item: _VT) -> None: ...
def __delitem__(self, key: _KT) -> None: ...
def __iter__(self) -> Iterator[_KT]: ...
def __contains__(self, key: object) -> bool: ...
def copy(self: _S) -> _S: ...
@classmethod
def fromkeys(cls: Type[_S], iterable: Iterable[_KT], value: Optional[_VT] = ...) -> _S: ...
class UserList(MutableSequence[_T]):
data: List[_T]
def __init__(self, initlist: Optional[Iterable[_T]] = ...) -> None: ...
def __lt__(self, other: object) -> bool: ...
def __le__(self, other: object) -> bool: ...
def __gt__(self, other: object) -> bool: ...
def __ge__(self, other: object) -> bool: ...
def __contains__(self, item: object) -> bool: ...
def __len__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> _T: ...
@overload
def __getitem__(self, i: slice) -> MutableSequence[_T]: ...
@overload
def __setitem__(self, i: int, o: _T) -> None: ...
@overload
def __setitem__(self, i: slice, o: Iterable[_T]) -> None: ...
def __delitem__(self, i: Union[int, slice]) -> None: ...
def __add__(self: _S, other: Iterable[_T]) -> _S: ...
def __iadd__(self: _S, other: Iterable[_T]) -> _S: ...
def __mul__(self: _S, n: int) -> _S: ...
def __imul__(self: _S, n: int) -> _S: ...
def append(self, item: _T) -> None: ...
def insert(self, i: int, item: _T) -> None: ...
def pop(self, i: int = ...) -> _T: ...
def remove(self, item: _T) -> None: ...
def clear(self) -> None: ...
def copy(self: _S) -> _S: ...
def count(self, item: _T) -> int: ...
def index(self, item: _T, *args: Any) -> int: ...
def reverse(self) -> None: ...
def sort(self, *args: Any, **kwds: Any) -> None: ...
def extend(self, other: Iterable[_T]) -> None: ...
_UserStringT = TypeVar("_UserStringT", bound=UserString)
class UserString(Sequence[str]):
data: str
def __init__(self, seq: object) -> None: ...
def __int__(self) -> int: ...
def __float__(self) -> float: ...
def __complex__(self) -> complex: ...
def __getnewargs__(self) -> Tuple[str]: ...
def __lt__(self, string: Union[str, UserString]) -> bool: ...
def __le__(self, string: Union[str, UserString]) -> bool: ...
def __gt__(self, string: Union[str, UserString]) -> bool: ...
def __ge__(self, string: Union[str, UserString]) -> bool: ...
def __contains__(self, char: object) -> bool: ...
def __len__(self) -> int: ...
# It should return a str to implement Sequence correctly, but it doesn't.
def __getitem__(self: _UserStringT, i: Union[int, slice]) -> _UserStringT: ... # type: ignore
def __add__(self: _UserStringT, other: object) -> _UserStringT: ...
def __mul__(self: _UserStringT, n: int) -> _UserStringT: ...
def __mod__(self: _UserStringT, args: Any) -> _UserStringT: ...
def capitalize(self: _UserStringT) -> _UserStringT: ...
def casefold(self: _UserStringT) -> _UserStringT: ...
def center(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ...
def count(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
if sys.version_info >= (3, 8):
def encode(self: _UserStringT, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> bytes: ...
else:
def encode(self: _UserStringT, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> _UserStringT: ...
def endswith(self, suffix: Union[str, Tuple[str, ...]], start: int = ..., end: int = ...) -> bool: ...
def expandtabs(self: _UserStringT, tabsize: int = ...) -> _UserStringT: ...
def find(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
def format(self, *args: Any, **kwds: Any) -> str: ...
def format_map(self, mapping: Mapping[str, Any]) -> str: ...
def index(self, sub: str, start: int = ..., end: int = ...) -> int: ...
def isalpha(self) -> bool: ...
def isalnum(self) -> bool: ...
def isdecimal(self) -> bool: ...
def isdigit(self) -> bool: ...
def isidentifier(self) -> bool: ...
def islower(self) -> bool: ...
def isnumeric(self) -> bool: ...
def isprintable(self) -> bool: ...
def isspace(self) -> bool: ...
def istitle(self) -> bool: ...
def isupper(self) -> bool: ...
def join(self, seq: Iterable[str]) -> str: ...
def ljust(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ...
def lower(self: _UserStringT) -> _UserStringT: ...
def lstrip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ...
@staticmethod
@overload
def maketrans(x: Union[Dict[int, _T], Dict[str, _T], Dict[Union[str, int], _T]]) -> Dict[int, _T]: ...
@staticmethod
@overload
def maketrans(x: str, y: str, z: str = ...) -> Dict[int, Union[int, None]]: ...
def partition(self, sep: str) -> Tuple[str, str, str]: ...
if sys.version_info >= (3, 9):
def removeprefix(self: _UserStringT, __prefix: Union[str, UserString]) -> _UserStringT: ...
def removesuffix(self: _UserStringT, __suffix: Union[str, UserString]) -> _UserStringT: ...
def replace(
self: _UserStringT, old: Union[str, UserString], new: Union[str, UserString], maxsplit: int = ...
) -> _UserStringT: ...
def rfind(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
def rindex(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
def rjust(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ...
def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
def rstrip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ...
def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
def splitlines(self, keepends: bool = ...) -> List[str]: ...
def startswith(self, prefix: Union[str, Tuple[str, ...]], start: int = ..., end: int = ...) -> bool: ...
def strip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ...
def swapcase(self: _UserStringT) -> _UserStringT: ...
def title(self: _UserStringT) -> _UserStringT: ...
def translate(self: _UserStringT, *args: Any) -> _UserStringT: ...
def upper(self: _UserStringT) -> _UserStringT: ...
def zfill(self: _UserStringT, width: int) -> _UserStringT: ...
class deque(MutableSequence[_T], Generic[_T]):
@property
def maxlen(self) -> Optional[int]: ...
def __init__(self, iterable: Iterable[_T] = ..., maxlen: Optional[int] = ...) -> None: ...
def append(self, x: _T) -> None: ...
def appendleft(self, x: _T) -> None: ...
def clear(self) -> None: ...
def copy(self) -> deque[_T]: ...
def count(self, x: _T) -> int: ...
def extend(self, iterable: Iterable[_T]) -> None: ...
def extendleft(self, iterable: Iterable[_T]) -> None: ...
def insert(self, i: int, x: _T) -> None: ...
def index(self, x: _T, start: int = ..., stop: int = ...) -> int: ...
def pop(self) -> _T: ... # type: ignore
def popleft(self) -> _T: ...
def remove(self, value: _T) -> None: ...
def reverse(self) -> None: ...
def rotate(self, n: int = ...) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_T]: ...
def __str__(self) -> str: ...
def __hash__(self) -> int: ...
# These methods of deque don't really take slices, but we need to
# define them as taking a slice to satisfy MutableSequence.
@overload
def __getitem__(self, index: int) -> _T: ...
@overload
def __getitem__(self, s: slice) -> MutableSequence[_T]: ...
@overload
def __setitem__(self, i: int, x: _T) -> None: ...
@overload
def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
@overload
def __delitem__(self, i: int) -> None: ...
@overload
def __delitem__(self, s: slice) -> None: ...
def __contains__(self, o: object) -> bool: ...
def __reversed__(self) -> Iterator[_T]: ...
def __iadd__(self: _S, iterable: Iterable[_T]) -> _S: ...
def __add__(self, other: deque[_T]) -> deque[_T]: ...
def __mul__(self, other: int) -> deque[_T]: ...
def __imul__(self, other: int) -> None: ...
class Counter(Dict[_T, int], Generic[_T]):
@overload
def __init__(self, __iterable: None = ..., **kwargs: int) -> None: ...
@overload
def __init__(self, __mapping: Mapping[_T, int]) -> None: ...
@overload
def __init__(self, __iterable: Iterable[_T]) -> None: ...
def copy(self: _S) -> _S: ...
def elements(self) -> Iterator[_T]: ...
def most_common(self, n: Optional[int] = ...) -> List[Tuple[_T, int]]: ...
@overload
def subtract(self, __iterable: None = ...) -> None: ...
@overload
def subtract(self, __mapping: Mapping[_T, int]) -> None: ...
@overload
def subtract(self, __iterable: Iterable[_T]) -> None: ...
# The Iterable[Tuple[...]] argument type is not actually desirable
# (the tuples will be added as keys, breaking type safety) but
# it's included so that the signature is compatible with
# Dict.update. Not sure if we should use '# type: ignore' instead
# and omit the type from the union.
@overload
def update(self, __m: Mapping[_T, int], **kwargs: int) -> None: ...
@overload
def update(self, __m: Union[Iterable[_T], Iterable[Tuple[_T, int]]], **kwargs: int) -> None: ...
@overload
def update(self, __m: None = ..., **kwargs: int) -> None: ...
def __add__(self, other: Counter[_T]) -> Counter[_T]: ...
def __sub__(self, other: Counter[_T]) -> Counter[_T]: ...
def __and__(self, other: Counter[_T]) -> Counter[_T]: ...
def __or__(self, other: Counter[_T]) -> Counter[_T]: ... # type: ignore
def __pos__(self) -> Counter[_T]: ...
def __neg__(self) -> Counter[_T]: ...
def __iadd__(self, other: Counter[_T]) -> Counter[_T]: ...
def __isub__(self, other: Counter[_T]) -> Counter[_T]: ...
def __iand__(self, other: Counter[_T]) -> Counter[_T]: ...
def __ior__(self, other: Counter[_T]) -> Counter[_T]: ... # type: ignore
class _OrderedDictKeysView(KeysView[_KT], Reversible[_KT]):
def __reversed__(self) -> Iterator[_KT]: ...
class _OrderedDictItemsView(ItemsView[_KT, _VT], Reversible[Tuple[_KT, _VT]]):
def __reversed__(self) -> Iterator[Tuple[_KT, _VT]]: ...
class _OrderedDictValuesView(ValuesView[_VT], Reversible[_VT]):
def __reversed__(self) -> Iterator[_VT]: ...
class OrderedDict(Dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]):
def popitem(self, last: bool = ...) -> Tuple[_KT, _VT]: ...
def move_to_end(self, key: _KT, last: bool = ...) -> None: ...
def copy(self: _S) -> _S: ...
def __reversed__(self) -> Iterator[_KT]: ...
def keys(self) -> _OrderedDictKeysView[_KT]: ...
def items(self) -> _OrderedDictItemsView[_KT, _VT]: ...
def values(self) -> _OrderedDictValuesView[_VT]: ...
class defaultdict(Dict[_KT, _VT], Generic[_KT, _VT]):
default_factory: Optional[Callable[[], _VT]]
@overload
def __init__(self, **kwargs: _VT) -> None: ...
@overload
def __init__(self, default_factory: Optional[Callable[[], _VT]]) -> None: ...
@overload
def __init__(self, default_factory: Optional[Callable[[], _VT]], **kwargs: _VT) -> None: ...
@overload
def __init__(self, default_factory: Optional[Callable[[], _VT]], map: Mapping[_KT, _VT]) -> None: ...
@overload
def __init__(self, default_factory: Optional[Callable[[], _VT]], map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
@overload
def __init__(self, default_factory: Optional[Callable[[], _VT]], iterable: Iterable[Tuple[_KT, _VT]]) -> None: ...
@overload
def __init__(
self, default_factory: Optional[Callable[[], _VT]], iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT
) -> None: ...
def __missing__(self, key: _KT) -> _VT: ...
# TODO __reversed__
def copy(self: _S) -> _S: ...
class ChainMap(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
def __init__(self, *maps: Mapping[_KT, _VT]) -> None: ...
@property
def maps(self) -> List[Mapping[_KT, _VT]]: ...
def new_child(self, m: Mapping[_KT, _VT] = ...) -> typing.ChainMap[_KT, _VT]: ...
@property
def parents(self) -> typing.ChainMap[_KT, _VT]: ...
def __setitem__(self, k: _KT, v: _VT) -> None: ...
def __delitem__(self, v: _KT) -> None: ...
def __getitem__(self, k: _KT) -> _VT: ...
def __iter__(self) -> Iterator[_KT]: ...
def __len__(self) -> int: ...
def __missing__(self, key: _KT) -> _VT: ... # undocumented
| 14,502 | Python | .py | 311 | 41.655949 | 120 | 0.565503 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,412 | abc.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/collections/abc.pyi | from . import (
AsyncGenerator as AsyncGenerator,
AsyncIterable as AsyncIterable,
AsyncIterator as AsyncIterator,
Awaitable as Awaitable,
ByteString as ByteString,
Callable as Callable,
Collection as Collection,
Container as Container,
Coroutine as Coroutine,
Generator as Generator,
Hashable as Hashable,
ItemsView as ItemsView,
Iterable as Iterable,
Iterator as Iterator,
KeysView as KeysView,
Mapping as Mapping,
MappingView as MappingView,
MutableMapping as MutableMapping,
MutableSequence as MutableSequence,
MutableSet as MutableSet,
Reversible as Reversible,
Sequence as Sequence,
Set as Set,
Sized as Sized,
ValuesView as ValuesView,
)
| 744 | Python | .py | 27 | 22.851852 | 39 | 0.747559 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,413 | filedialog.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tkinter/filedialog.pyi | from tkinter import Button, Entry, Frame, Listbox, Scrollbar, Toplevel, commondialog
from typing import Any, Dict, Optional, Tuple
dialogstates: Dict[Any, Tuple[Any, Any]]
class FileDialog:
title: str = ...
master: Any = ...
directory: Optional[Any] = ...
top: Toplevel = ...
botframe: Frame = ...
selection: Entry = ...
filter: Entry = ...
midframe: Entry = ...
filesbar: Scrollbar = ...
files: Listbox = ...
dirsbar: Scrollbar = ...
dirs: Listbox = ...
ok_button: Button = ...
filter_button: Button = ...
cancel_button: Button = ...
def __init__(
self, master, title: Optional[Any] = ...
) -> None: ... # title is usually a str or None, but e.g. int doesn't raise en exception either
how: Optional[Any] = ...
def go(self, dir_or_file: Any = ..., pattern: str = ..., default: str = ..., key: Optional[Any] = ...): ...
def quit(self, how: Optional[Any] = ...) -> None: ...
def dirs_double_event(self, event) -> None: ...
def dirs_select_event(self, event) -> None: ...
def files_double_event(self, event) -> None: ...
def files_select_event(self, event) -> None: ...
def ok_event(self, event) -> None: ...
def ok_command(self) -> None: ...
def filter_command(self, event: Optional[Any] = ...) -> None: ...
def get_filter(self): ...
def get_selection(self): ...
def cancel_command(self, event: Optional[Any] = ...) -> None: ...
def set_filter(self, dir, pat) -> None: ...
def set_selection(self, file) -> None: ...
class LoadFileDialog(FileDialog):
title: str = ...
def ok_command(self) -> None: ...
class SaveFileDialog(FileDialog):
title: str = ...
def ok_command(self): ...
class _Dialog(commondialog.Dialog): ...
class Open(_Dialog):
command: str = ...
class SaveAs(_Dialog):
command: str = ...
class Directory(commondialog.Dialog):
command: str = ...
def askopenfilename(**options): ...
def asksaveasfilename(**options): ...
def askopenfilenames(**options): ...
def askopenfile(mode: str = ..., **options): ...
def askopenfiles(mode: str = ..., **options): ...
def asksaveasfile(mode: str = ..., **options): ...
def askdirectory(**options): ...
def test() -> None: ...
| 2,247 | Python | .py | 58 | 34.758621 | 111 | 0.604587 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,414 | ttk.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tkinter/ttk.pyi | import _tkinter
import sys
import tkinter
from tkinter.font import _FontDescription
from typing import Any, Callable, Dict, List, Optional, Tuple, Union, overload
from typing_extensions import Literal
def tclobjs_to_py(adict): ...
def setup_master(master: Optional[Any] = ...): ...
# from ttk_widget (aka ttk::widget) manual page, differs from tkinter._Compound
_TtkCompound = Literal["text", "image", tkinter._Compound]
class Style:
master: Any
tk: _tkinter.TkappType
def __init__(self, master: Optional[Any] = ...): ...
def configure(self, style, query_opt: Optional[Any] = ..., **kw): ...
def map(self, style, query_opt: Optional[Any] = ..., **kw): ...
def lookup(self, style, option, state: Optional[Any] = ..., default: Optional[Any] = ...): ...
def layout(self, style, layoutspec: Optional[Any] = ...): ...
def element_create(self, elementname, etype, *args, **kw): ...
def element_names(self): ...
def element_options(self, elementname): ...
def theme_create(self, themename, parent: Optional[Any] = ..., settings: Optional[Any] = ...): ...
def theme_settings(self, themename, settings): ...
def theme_names(self): ...
def theme_use(self, themename: Optional[Any] = ...): ...
class Widget(tkinter.Widget):
def __init__(self, master: Optional[tkinter.Misc], widgetname, kw: Optional[Any] = ...): ...
def identify(self, x, y): ...
def instate(self, statespec, callback: Optional[Any] = ..., *args, **kw): ...
def state(self, statespec: Optional[Any] = ...): ...
_ButtonOptionName = Literal[
"class",
"command",
"compound",
"cursor",
"default",
"image",
"padding",
"state",
"style",
"takefocus",
"text",
"textvariable",
"underline",
"width",
]
class Button(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
command: tkinter._ButtonCommand = ...,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
default: Literal["normal", "active", "disabled"] = ...,
image: tkinter._ImageSpec = ...,
name: str = ...,
padding: Any = ..., # undocumented
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
width: Union[int, Literal[""]] = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
command: tkinter._ButtonCommand = ...,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
default: Literal["normal", "active", "disabled"] = ...,
image: tkinter._ImageSpec = ...,
padding: Any = ...,
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
width: Union[int, Literal[""]] = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _ButtonOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _ButtonOptionName) -> Any: ...
def invoke(self): ...
_CheckbuttonOptionName = Literal[
"class",
"command",
"compound",
"cursor",
"image",
"offvalue",
"onvalue",
"padding",
"state",
"style",
"takefocus",
"text",
"textvariable",
"underline",
"variable",
"width",
]
class Checkbutton(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
command: tkinter._ButtonCommand = ...,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
image: tkinter._ImageSpec = ...,
name: str = ...,
offvalue: Any = ...,
onvalue: Any = ...,
padding: Any = ..., # undocumented
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
# Seems like variable can be empty string, but actually setting it to
# empty string segfaults before Tcl 8.6.9. Search for ttk::checkbutton
# here: https://sourceforge.net/projects/tcl/files/Tcl/8.6.9/tcltk-release-notes-8.6.9.txt/view
variable: tkinter.Variable = ...,
width: Union[int, Literal[""]] = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
command: tkinter._ButtonCommand = ...,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
image: tkinter._ImageSpec = ...,
offvalue: Any = ...,
onvalue: Any = ...,
padding: Any = ...,
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
variable: tkinter.Variable = ...,
width: Union[int, Literal[""]] = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _CheckbuttonOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _CheckbuttonOptionName) -> Any: ...
def invoke(self): ...
_EntryOptionName = Literal[
"background",
"class",
"cursor",
"exportselection",
"font",
"foreground",
"invalidcommand",
"justify",
"show",
"state",
"style",
"takefocus",
"textvariable",
"validate",
"validatecommand",
"width",
"xscrollcommand",
]
class Entry(Widget, tkinter.Entry):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
widget: Optional[str] = ...,
*,
background: tkinter._Color = ..., # undocumented
class_: str = ...,
cursor: tkinter._Cursor = ...,
exportselection: bool = ...,
font: _FontDescription = ...,
foreground: tkinter._Color = ...,
invalidcommand: tkinter._EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
show: str = ...,
state: Literal["normal", "disabled", "readonly"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
textvariable: tkinter.Variable = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: tkinter._EntryValidateCommand = ...,
width: int = ...,
xscrollcommand: tkinter._XYScrollCommand = ...,
) -> None: ...
@overload # type: ignore
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: tkinter._Color = ...,
cursor: tkinter._Cursor = ...,
exportselection: bool = ...,
font: _FontDescription = ...,
foreground: tkinter._Color = ...,
invalidcommand: tkinter._EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
show: str = ...,
state: Literal["normal", "disabled", "readonly"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
textvariable: tkinter.Variable = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: tkinter._EntryValidateCommand = ...,
width: int = ...,
xscrollcommand: tkinter._XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _EntryOptionName) -> Tuple[str, str, str, Any, Any]: ...
# config must be copy/pasted, otherwise ttk.Entry().config is mypy error (don't know why)
@overload # type: ignore
def config(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: tkinter._Color = ...,
cursor: tkinter._Cursor = ...,
exportselection: bool = ...,
font: _FontDescription = ...,
foreground: tkinter._Color = ...,
invalidcommand: tkinter._EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
show: str = ...,
state: Literal["normal", "disabled", "readonly"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
textvariable: tkinter.Variable = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: tkinter._EntryValidateCommand = ...,
width: int = ...,
xscrollcommand: tkinter._XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def config(self, cnf: _EntryOptionName) -> Tuple[str, str, str, Any, Any]: ...
def cget(self, key: _EntryOptionName) -> Any: ... # type: ignore
def bbox(self, index): ...
def identify(self, x, y): ...
def validate(self): ...
_ComboboxOptionName = Literal[
"background",
"class",
"cursor",
"exportselection",
"font",
"foreground",
"height",
"invalidcommand",
"justify",
"postcommand",
"show",
"state",
"style",
"takefocus",
"textvariable",
"validate",
"validatecommand",
"values",
"width",
"xscrollcommand",
]
class Combobox(Entry):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
background: tkinter._Color = ..., # undocumented
class_: str = ...,
cursor: tkinter._Cursor = ...,
exportselection: bool = ...,
font: _FontDescription = ..., # undocumented
foreground: tkinter._Color = ..., # undocumented
height: int = ...,
invalidcommand: tkinter._EntryValidateCommand = ..., # undocumented
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
postcommand: Union[Callable[[], Any], str] = ...,
show: Any = ..., # undocumented
state: Literal["normal", "readonly", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
textvariable: tkinter.Variable = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., # undocumented
validatecommand: tkinter._EntryValidateCommand = ..., # undocumented
values: tkinter._TkinterSequence[str] = ...,
width: int = ...,
xscrollcommand: tkinter._XYScrollCommand = ..., # undocumented
) -> None: ...
@overload # type: ignore
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: tkinter._Color = ...,
cursor: tkinter._Cursor = ...,
exportselection: bool = ...,
font: _FontDescription = ...,
foreground: tkinter._Color = ...,
height: int = ...,
invalidcommand: tkinter._EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
postcommand: Union[Callable[[], Any], str] = ...,
show: Any = ...,
state: Literal["normal", "readonly", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
textvariable: tkinter.Variable = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: tkinter._EntryValidateCommand = ...,
values: tkinter._TkinterSequence[str] = ...,
width: int = ...,
xscrollcommand: tkinter._XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _ComboboxOptionName) -> Tuple[str, str, str, Any, Any]: ...
# config must be copy/pasted, otherwise ttk.Combobox().config is mypy error (don't know why)
@overload # type: ignore
def config(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: tkinter._Color = ...,
cursor: tkinter._Cursor = ...,
exportselection: bool = ...,
font: _FontDescription = ...,
foreground: tkinter._Color = ...,
height: int = ...,
invalidcommand: tkinter._EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
postcommand: Union[Callable[[], Any], str] = ...,
show: Any = ...,
state: Literal["normal", "readonly", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
textvariable: tkinter.Variable = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: tkinter._EntryValidateCommand = ...,
values: tkinter._TkinterSequence[str] = ...,
width: int = ...,
xscrollcommand: tkinter._XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def config(self, cnf: _ComboboxOptionName) -> Tuple[str, str, str, Any, Any]: ...
def cget(self, key: _ComboboxOptionName) -> Any: ... # type: ignore
def current(self, newindex: Optional[Any] = ...): ...
def set(self, value): ...
_FrameOptionName = Literal[
"border", "borderwidth", "class", "cursor", "height", "padding", "relief", "style", "takefocus", "width"
]
class Frame(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
border: tkinter._ScreenUnits = ...,
borderwidth: tkinter._ScreenUnits = ...,
class_: str = ...,
cursor: tkinter._Cursor = ...,
height: tkinter._ScreenUnits = ...,
name: str = ...,
padding: tkinter._Padding = ...,
relief: tkinter._Relief = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
width: tkinter._ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
border: tkinter._ScreenUnits = ...,
borderwidth: tkinter._ScreenUnits = ...,
cursor: tkinter._Cursor = ...,
height: tkinter._ScreenUnits = ...,
padding: tkinter._Padding = ...,
relief: tkinter._Relief = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
width: tkinter._ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _FrameOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _FrameOptionName) -> Any: ...
_LabelOptionName = Literal[
"anchor",
"background",
"border",
"borderwidth",
"class",
"compound",
"cursor",
"font",
"foreground",
"image",
"justify",
"padding",
"relief",
"state",
"style",
"takefocus",
"text",
"textvariable",
"underline",
"width",
"wraplength",
]
class Label(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
anchor: tkinter._Anchor = ...,
background: tkinter._Color = ...,
border: tkinter._ScreenUnits = ..., # alias for borderwidth
borderwidth: tkinter._ScreenUnits = ..., # undocumented
class_: str = ...,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
font: _FontDescription = ...,
foreground: tkinter._Color = ...,
image: tkinter._ImageSpec = ...,
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
padding: tkinter._Padding = ...,
relief: tkinter._Relief = ...,
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
width: Union[int, Literal[""]] = ...,
wraplength: tkinter._ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
anchor: tkinter._Anchor = ...,
background: tkinter._Color = ...,
border: tkinter._ScreenUnits = ...,
borderwidth: tkinter._ScreenUnits = ...,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
font: _FontDescription = ...,
foreground: tkinter._Color = ...,
image: tkinter._ImageSpec = ...,
justify: Literal["left", "center", "right"] = ...,
padding: tkinter._Padding = ...,
relief: tkinter._Relief = ...,
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
width: Union[int, Literal[""]] = ...,
wraplength: tkinter._ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _LabelOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _LabelOptionName) -> Any: ...
_LabelframeOptionName = Literal[
"border",
"borderwidth",
"class",
"cursor",
"height",
"labelanchor",
"labelwidget",
"padding",
"relief",
"style",
"takefocus",
"text",
"underline",
"width",
]
class Labelframe(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
border: tkinter._ScreenUnits = ...,
borderwidth: tkinter._ScreenUnits = ..., # undocumented
class_: str = ...,
cursor: tkinter._Cursor = ...,
height: tkinter._ScreenUnits = ...,
labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ...,
labelwidget: tkinter.Misc = ...,
name: str = ...,
padding: tkinter._Padding = ...,
relief: tkinter._Relief = ..., # undocumented
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
underline: int = ...,
width: tkinter._ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
border: tkinter._ScreenUnits = ...,
borderwidth: tkinter._ScreenUnits = ...,
cursor: tkinter._Cursor = ...,
height: tkinter._ScreenUnits = ...,
labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ...,
labelwidget: tkinter.Misc = ...,
padding: tkinter._Padding = ...,
relief: tkinter._Relief = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
underline: int = ...,
width: tkinter._ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _LabelframeOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _LabelframeOptionName) -> Any: ...
LabelFrame = Labelframe
_MenubuttonOptionName = Literal[
"class",
"compound",
"cursor",
"direction",
"image",
"menu",
"padding",
"state",
"style",
"takefocus",
"text",
"textvariable",
"underline",
"width",
]
class Menubutton(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
direction: Literal["above", "below", "left", "right", "flush"] = ...,
image: tkinter._ImageSpec = ...,
menu: tkinter.Menu = ...,
name: str = ...,
padding: Any = ..., # undocumented
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
width: Union[int, Literal[""]] = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
direction: Literal["above", "below", "left", "right", "flush"] = ...,
image: tkinter._ImageSpec = ...,
menu: tkinter.Menu = ...,
padding: Any = ...,
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
width: Union[int, Literal[""]] = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _MenubuttonOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _MenubuttonOptionName) -> Any: ...
_NotebookOptionName = Literal["class", "cursor", "height", "padding", "style", "takefocus", "width"]
class Notebook(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
cursor: tkinter._Cursor = ...,
height: int = ...,
name: str = ...,
padding: tkinter._Padding = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
width: int = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
cursor: tkinter._Cursor = ...,
height: int = ...,
padding: tkinter._Padding = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
width: int = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _NotebookOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _NotebookOptionName) -> Any: ...
def add(self, child, **kw): ...
def forget(self, tab_id): ...
def hide(self, tab_id): ...
def identify(self, x, y): ...
def index(self, tab_id): ...
def insert(self, pos, child, **kw): ...
def select(self, tab_id: Optional[Any] = ...): ...
def tab(self, tab_id, option: Optional[Any] = ..., **kw): ...
def tabs(self): ...
def enable_traversal(self): ...
_PanedwindowOptionName = Literal["class", "cursor", "height", "orient", "style", "takefocus", "width"]
class Panedwindow(Widget, tkinter.PanedWindow):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
cursor: tkinter._Cursor = ...,
# width and height for tkinter.ttk.Panedwindow are int but for tkinter.PanedWindow they are screen units
height: int = ...,
name: str = ...,
orient: Literal["vertical", "horizontal"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
width: int = ...,
) -> None: ...
@overload # type: ignore
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
cursor: tkinter._Cursor = ...,
height: int = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
width: int = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _PanedwindowOptionName) -> Tuple[str, str, str, Any, Any]: ...
# config must be copy/pasted, otherwise ttk.Panedwindow().config is mypy error (don't know why)
@overload # type: ignore
def config(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
cursor: tkinter._Cursor = ...,
height: int = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
width: int = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def config(self, cnf: _PanedwindowOptionName) -> Tuple[str, str, str, Any, Any]: ...
def cget(self, key: _PanedwindowOptionName) -> Any: ... # type: ignore
forget: Any
def insert(self, pos, child, **kw): ...
def pane(self, pane, option: Optional[Any] = ..., **kw): ...
def sashpos(self, index, newpos: Optional[Any] = ...): ...
PanedWindow = Panedwindow
_ProgressbarOptionName = Literal[
"class", "cursor", "length", "maximum", "mode", "orient", "phase", "style", "takefocus", "value", "variable"
]
class Progressbar(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
cursor: tkinter._Cursor = ...,
length: tkinter._ScreenUnits = ...,
maximum: float = ...,
mode: Literal["determinate", "indeterminate"] = ...,
name: str = ...,
orient: Literal["horizontal", "vertical"] = ...,
phase: int = ..., # docs say read-only but assigning int to this works
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
value: float = ...,
variable: tkinter.DoubleVar = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
cursor: tkinter._Cursor = ...,
length: tkinter._ScreenUnits = ...,
maximum: float = ...,
mode: Literal["determinate", "indeterminate"] = ...,
orient: Literal["horizontal", "vertical"] = ...,
phase: int = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
value: float = ...,
variable: tkinter.DoubleVar = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _ProgressbarOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _ProgressbarOptionName) -> Any: ...
def start(self, interval: Optional[Any] = ...): ...
def step(self, amount: Optional[Any] = ...): ...
def stop(self): ...
_RadiobuttonOptionName = Literal[
"class",
"command",
"compound",
"cursor",
"image",
"padding",
"state",
"style",
"takefocus",
"text",
"textvariable",
"underline",
"value",
"variable",
"width",
]
class Radiobutton(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
command: tkinter._ButtonCommand = ...,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
image: tkinter._ImageSpec = ...,
name: str = ...,
padding: Any = ..., # undocumented
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
value: Any = ...,
variable: Union[tkinter.Variable, Literal[""]] = ...,
width: Union[int, Literal[""]] = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
command: tkinter._ButtonCommand = ...,
compound: _TtkCompound = ...,
cursor: tkinter._Cursor = ...,
image: tkinter._ImageSpec = ...,
padding: Any = ...,
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
text: str = ...,
textvariable: tkinter.Variable = ...,
underline: int = ...,
value: Any = ...,
variable: Union[tkinter.Variable, Literal[""]] = ...,
width: Union[int, Literal[""]] = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _RadiobuttonOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _RadiobuttonOptionName) -> Any: ...
def invoke(self): ...
_ScaleOptionName = Literal[
"class", "command", "cursor", "from", "length", "orient", "state", "style", "takefocus", "to", "value", "variable"
]
class Scale(Widget, tkinter.Scale):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
command: Union[str, Callable[[str], Any]] = ...,
cursor: tkinter._Cursor = ...,
from_: float = ...,
length: tkinter._ScreenUnits = ...,
name: str = ...,
orient: Literal["horizontal", "vertical"] = ...,
state: Any = ..., # undocumented
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
to: float = ...,
value: float = ...,
variable: tkinter.DoubleVar = ...,
) -> None: ...
@overload # type: ignore
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
command: Union[str, Callable[[str], Any]] = ...,
cursor: tkinter._Cursor = ...,
from_: float = ...,
length: tkinter._ScreenUnits = ...,
orient: Literal["horizontal", "vertical"] = ...,
state: Any = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
to: float = ...,
value: float = ...,
variable: tkinter.DoubleVar = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _ScaleOptionName) -> Tuple[str, str, str, Any, Any]: ...
# config must be copy/pasted, otherwise ttk.Scale().config is mypy error (don't know why)
@overload # type: ignore
def config(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
command: Union[str, Callable[[str], Any]] = ...,
cursor: tkinter._Cursor = ...,
from_: float = ...,
length: tkinter._ScreenUnits = ...,
orient: Literal["horizontal", "vertical"] = ...,
state: Any = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
to: float = ...,
value: float = ...,
variable: tkinter.DoubleVar = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def config(self, cnf: _ScaleOptionName) -> Tuple[str, str, str, Any, Any]: ...
def cget(self, key: _ScaleOptionName) -> Any: ... # type: ignore
def get(self, x: Optional[Any] = ..., y: Optional[Any] = ...): ...
_ScrollbarOptionName = Literal["class", "command", "cursor", "orient", "style", "takefocus"]
class Scrollbar(Widget, tkinter.Scrollbar):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ...,
cursor: tkinter._Cursor = ...,
name: str = ...,
orient: Literal["horizontal", "vertical"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
) -> None: ...
@overload # type: ignore
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ...,
cursor: tkinter._Cursor = ...,
orient: Literal["horizontal", "vertical"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _ScrollbarOptionName) -> Tuple[str, str, str, Any, Any]: ...
# config must be copy/pasted, otherwise ttk.Scrollbar().config is mypy error (don't know why)
@overload # type: ignore
def config(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ...,
cursor: tkinter._Cursor = ...,
orient: Literal["horizontal", "vertical"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def config(self, cnf: _ScrollbarOptionName) -> Tuple[str, str, str, Any, Any]: ...
def cget(self, key: _ScrollbarOptionName) -> Any: ... # type: ignore
_SeparatorOptionName = Literal["class", "cursor", "orient", "style", "takefocus"]
class Separator(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
cursor: tkinter._Cursor = ...,
name: str = ...,
orient: Literal["horizontal", "vertical"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
cursor: tkinter._Cursor = ...,
orient: Literal["horizontal", "vertical"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _SeparatorOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _SeparatorOptionName) -> Any: ...
_SizegripOptionName = Literal["class", "cursor", "style", "takefocus"]
class Sizegrip(Widget):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
cursor: tkinter._Cursor = ...,
name: str = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
cursor: tkinter._Cursor = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _SizegripOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _SizegripOptionName) -> Any: ...
if sys.version_info >= (3, 7):
_SpinboxOptionName = Literal[
"background",
"class",
"command",
"cursor",
"exportselection",
"font",
"foreground",
"format",
"from",
"increment",
"invalidcommand",
"justify",
"show",
"state",
"style",
"takefocus",
"textvariable",
"to",
"validate",
"validatecommand",
"values",
"width",
"wrap",
"xscrollcommand",
]
class Spinbox(Entry):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
background: tkinter._Color = ..., # undocumented
class_: str = ...,
command: Union[Callable[[], Any], str, tkinter._TkinterSequence[str]] = ...,
cursor: tkinter._Cursor = ...,
exportselection: bool = ..., # undocumented
font: _FontDescription = ..., # undocumented
foreground: tkinter._Color = ..., # undocumented
format: str = ...,
from_: float = ...,
increment: float = ...,
invalidcommand: tkinter._EntryValidateCommand = ..., # undocumented
justify: Literal["left", "center", "right"] = ..., # undocumented
name: str = ...,
show: Any = ..., # undocumented
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
textvariable: tkinter.Variable = ..., # undocumented
to: float = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: tkinter._EntryValidateCommand = ...,
values: tkinter._TkinterSequence[str] = ...,
width: int = ..., # undocumented
wrap: bool = ...,
xscrollcommand: tkinter._XYScrollCommand = ...,
) -> None: ...
@overload # type: ignore
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: tkinter._Color = ...,
command: Union[Callable[[], Any], str, tkinter._TkinterSequence[str]] = ...,
cursor: tkinter._Cursor = ...,
exportselection: bool = ...,
font: _FontDescription = ...,
foreground: tkinter._Color = ...,
format: str = ...,
from_: float = ...,
increment: float = ...,
invalidcommand: tkinter._EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
show: Any = ...,
state: Literal["normal", "disabled"] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
textvariable: tkinter.Variable = ...,
to: float = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: tkinter._EntryValidateCommand = ...,
values: tkinter._TkinterSequence[str] = ...,
width: int = ...,
wrap: bool = ...,
xscrollcommand: tkinter._XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _SpinboxOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure # type: ignore
def cget(self, key: _SpinboxOptionName) -> Any: ... # type: ignore
def set(self, value: Any) -> None: ...
_TreeviewOptionName = Literal[
"class",
"columns",
"cursor",
"displaycolumns",
"height",
"padding",
"selectmode",
"show",
"style",
"takefocus",
"xscrollcommand",
"yscrollcommand",
]
class Treeview(Widget, tkinter.XView, tkinter.YView):
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
*,
class_: str = ...,
columns: Union[str, tkinter._TkinterSequence[str]] = ...,
cursor: tkinter._Cursor = ...,
displaycolumns: Union[str, tkinter._TkinterSequence[str], tkinter._TkinterSequence[int], Literal["#all"]] = ...,
height: int = ...,
name: str = ...,
padding: tkinter._Padding = ...,
selectmode: Literal["extended", "browse", "none"] = ...,
# _TkinterSequences of Literal don't actually work, using str instead.
#
# 'tree headings' is same as ['tree', 'headings'], and I wouldn't be
# surprised if someone was using it.
show: Union[Literal["tree", "headings", "tree headings"], tkinter._TkinterSequence[str]] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
xscrollcommand: tkinter._XYScrollCommand = ...,
yscrollcommand: tkinter._XYScrollCommand = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
columns: Union[str, tkinter._TkinterSequence[str]] = ...,
cursor: tkinter._Cursor = ...,
displaycolumns: Union[str, tkinter._TkinterSequence[str], tkinter._TkinterSequence[int], Literal["#all"]] = ...,
height: int = ...,
padding: tkinter._Padding = ...,
selectmode: Literal["extended", "browse", "none"] = ...,
show: Union[Literal["tree", "headings", "tree headings"], tkinter._TkinterSequence[str]] = ...,
style: str = ...,
takefocus: tkinter._TakeFocusValue = ...,
xscrollcommand: tkinter._XYScrollCommand = ...,
yscrollcommand: tkinter._XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _TreeviewOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _TreeviewOptionName) -> Any: ...
def bbox(self, item, column: Optional[Any] = ...): ...
def get_children(self, item: Optional[Any] = ...): ...
def set_children(self, item, *newchildren): ...
def column(self, column, option: Optional[Any] = ..., **kw): ...
def delete(self, *items): ...
def detach(self, *items): ...
def exists(self, item): ...
def focus(self, item: Optional[Any] = ...): ...
def heading(self, column, option: Optional[Any] = ..., **kw): ...
def identify(self, component, x, y): ...
def identify_row(self, y): ...
def identify_column(self, x): ...
def identify_region(self, x, y): ...
def identify_element(self, x, y): ...
def index(self, item): ...
def insert(self, parent, index, iid: Optional[Any] = ..., **kw): ...
def item(self, item, option: Optional[Any] = ..., **kw): ...
def move(self, item, parent, index): ...
reattach: Any
def next(self, item): ...
def parent(self, item): ...
def prev(self, item): ...
def see(self, item): ...
if sys.version_info >= (3, 8):
def selection(self) -> List[Any]: ...
else:
def selection(self, selop: Optional[Any] = ..., items: Optional[Any] = ...) -> List[Any]: ...
def selection_set(self, items): ...
def selection_add(self, items): ...
def selection_remove(self, items): ...
def selection_toggle(self, items): ...
def set(self, item, column: Optional[Any] = ..., value: Optional[Any] = ...): ...
# There's no tag_unbind() or 'add' argument for whatever reason.
# Also, it's 'callback' instead of 'func' here.
@overload
def tag_bind(
self,
tagname: str,
sequence: Optional[str] = ...,
callback: Optional[Callable[[tkinter.Event[Treeview]], Optional[Literal["break"]]]] = ...,
) -> str: ...
@overload
def tag_bind(self, tagname: str, sequence: Optional[str], callback: str) -> None: ...
@overload
def tag_bind(self, tagname: str, *, callback: str) -> None: ...
def tag_configure(self, tagname, option: Optional[Any] = ..., **kw): ...
def tag_has(self, tagname, item: Optional[Any] = ...): ...
class LabeledScale(Frame):
label: Any
scale: Any
# TODO: don't any-type **kw. That goes to Frame.__init__.
def __init__(
self,
master: Optional[tkinter.Misc] = ...,
variable: Optional[Union[tkinter.IntVar, tkinter.DoubleVar]] = ...,
from_: float = ...,
to: float = ...,
*,
compound: Union[Literal["top"], Literal["bottom"]] = ...,
**kw: Any,
) -> None: ...
# destroy is overrided, signature does not change
value: Any
class OptionMenu(Menubutton):
def __init__(
self,
master,
variable,
default: Optional[str] = ...,
*values: str,
# rest of these are keyword-only because *args syntax used above
style: str = ...,
direction: Union[Literal["above"], Literal["below"], Literal["left"], Literal["right"], Literal["flush"]] = ...,
command: Optional[Callable[[tkinter.StringVar], Any]] = ...,
) -> None: ...
# configure, config, cget, destroy are inherited from Menubutton
# destroy and __setitem__ are overrided, signature does not change
def set_menu(self, default: Optional[Any] = ..., *values): ...
| 43,748 | Python | .py | 1,189 | 29.426409 | 120 | 0.539232 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,415 | messagebox.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tkinter/messagebox.pyi | from tkinter.commondialog import Dialog
from typing import Any, Optional
ERROR: str
INFO: str
QUESTION: str
WARNING: str
ABORTRETRYIGNORE: str
OK: str
OKCANCEL: str
RETRYCANCEL: str
YESNO: str
YESNOCANCEL: str
ABORT: str
RETRY: str
IGNORE: str
CANCEL: str
YES: str
NO: str
class Message(Dialog):
command: str = ...
def showinfo(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ...
def showwarning(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ...
def showerror(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ...
def askquestion(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ...
def askokcancel(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> bool: ...
def askyesno(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> bool: ...
def askyesnocancel(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> Optional[bool]: ...
def askretrycancel(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> bool: ...
| 1,150 | Python | .py | 28 | 39.821429 | 115 | 0.661305 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,416 | dialog.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tkinter/dialog.pyi | from tkinter import Widget
from typing import Any, Mapping, Optional
DIALOG_ICON: str
class Dialog(Widget):
widgetName: str = ...
num: int = ...
def __init__(self, master: Optional[Any] = ..., cnf: Mapping[str, Any] = ..., **kw) -> None: ...
def destroy(self) -> None: ...
| 291 | Python | .py | 8 | 33.125 | 100 | 0.619217 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,417 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tkinter/__init__.pyi | import _tkinter
import sys
from enum import Enum
from tkinter.constants import * # comment this out to find undefined identifier names with flake8
from tkinter.font import _FontDescription
from types import TracebackType
from typing import Any, Callable, Dict, Generic, List, Mapping, Optional, Protocol, Tuple, Type, TypeVar, Union, overload
from typing_extensions import Literal, TypedDict
# Using anything from tkinter.font in this file means that 'import tkinter'
# seems to also load tkinter.font. That's not how it actually works, but
# unfortunately not much can be done about it. https://github.com/python/typeshed/pull/4346
TclError = _tkinter.TclError
wantobjects: Any
TkVersion: Any
TclVersion: Any
READABLE = _tkinter.READABLE
WRITABLE = _tkinter.WRITABLE
EXCEPTION = _tkinter.EXCEPTION
# Quick guide for figuring out which widget class to choose:
# - Misc: any widget (don't use BaseWidget because Tk doesn't inherit from BaseWidget)
# - Widget: anything that is meant to be put into another widget with e.g. pack or grid
# - Wm: a toplevel window, Tk or Toplevel
#
# Instructions for figuring out the correct type of each widget option:
# - See discussion on #4363.
#
# - Find the option from the manual page of the widget. Usually the manual
# page of a non-ttk widget has the same name as the tkinter class, in the
# 3tk section:
#
# $ sudo apt install tk-doc
# $ man 3tk label
#
# Ttk manual pages tend to have ttk_ prefixed names:
#
# $ man 3tk ttk_label
#
# Non-GUI things like the .after() method are often in the 3tcl section:
#
# $ sudo apt install tcl-doc
# $ man 3tcl after
#
# If you don't have man or apt, you can read these manual pages online:
#
# https://www.tcl.tk/doc/
#
# Every option has '-' in front of its name in the manual page (and in Tcl).
# For example, there's an option named '-text' in the label manual page.
#
# - Tkinter has some options documented in docstrings, but don't rely on them.
# They aren't updated when a new version of Tk comes out, so the latest Tk
# manual pages (see above) are much more likely to actually contain all
# possible options.
#
# Also, reading tkinter's source code typically won't help much because it
# uses a lot of **kwargs and duck typing. Typically every argument goes into
# self.tk.call, which is _tkinter.TkappType.call, and the return value is
# whatever that returns. The type of that depends on how the Tcl interpreter
# represents the return value of the executed Tcl code.
#
# - If you think that int is an appropriate type for something, then you may
# actually want _ScreenUnits instead.
#
# - If you think that Callable[something] is an appropriate type for
# something, then you may actually want Union[Callable[something], str],
# because it's often possible to specify a string of Tcl code.
#
# - Some options can be set only in __init__, but all options are available
# when getting their values with configure's return value or cget.
#
# - Asks other tkinter users if you haven't worked much with tkinter.
# _TkinterSequence[T] represents a sequence that tkinter understands. It
# differs from typing.Sequence[T]. For example, collections.deque a valid
# Sequence but not a valid _TkinterSequence:
#
# >>> tkinter.Label(font=('Helvetica', 12, collections.deque(['bold'])))
# Traceback (most recent call last):
# ...
# _tkinter.TclError: unknown font style "deque(['bold'])"
_T = TypeVar("_T")
_TkinterSequence = Union[List[_T], Tuple[_T, ...]]
# Some widgets have an option named -compound that accepts different values
# than the _Compound defined here. Many other options have similar things.
_Anchor = Literal["nw", "n", "ne", "w", "center", "e", "sw", "s", "se"] # manual page: Tk_GetAnchor
_Bitmap = str # manual page: Tk_GetBitmap
_ButtonCommand = Union[str, Callable[[], Any]] # return value is returned from Button.invoke()
_Color = str # typically '#rrggbb', '#rgb' or color names.
_Compound = Literal["top", "left", "center", "right", "bottom", "none"] # -compound in manual page named 'options'
_Cursor = Union[str, Tuple[str], Tuple[str, str], Tuple[str, str, str], Tuple[str, str, str, str]] # manual page: Tk_GetCursor
_EntryValidateCommand = Union[
Callable[[], bool], str, _TkinterSequence[str]
] # example when it's sequence: entry['invalidcommand'] = [entry.register(print), '%P']
_ImageSpec = Union[_Image, str] # str can be from e.g. tkinter.image_names()
_Padding = Union[
_ScreenUnits,
Tuple[_ScreenUnits],
Tuple[_ScreenUnits, _ScreenUnits],
Tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits],
Tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits, _ScreenUnits],
]
_Relief = Literal["raised", "sunken", "flat", "ridge", "solid", "groove"] # manual page: Tk_GetRelief
_ScreenUnits = Union[str, float] # manual page: Tk_GetPixels
_XYScrollCommand = Union[str, Callable[[float, float], Any]] # -xscrollcommand and -yscrollcommand in 'options' manual page
_TakeFocusValue = Union[int, Literal[""], Callable[[str], Optional[bool]]] # -takefocus in manual page named 'options'
class EventType(str, Enum):
Activate: str = ...
ButtonPress: str = ...
ButtonRelease: str = ...
Circulate: str = ...
CirculateRequest: str = ...
ClientMessage: str = ...
Colormap: str = ...
Configure: str = ...
ConfigureRequest: str = ...
Create: str = ...
Deactivate: str = ...
Destroy: str = ...
Enter: str = ...
Expose: str = ...
FocusIn: str = ...
FocusOut: str = ...
GraphicsExpose: str = ...
Gravity: str = ...
KeyPress: str = ...
KeyRelease: str = ...
Keymap: str = ...
Leave: str = ...
Map: str = ...
MapRequest: str = ...
Mapping: str = ...
Motion: str = ...
MouseWheel: str = ...
NoExpose: str = ...
Property: str = ...
Reparent: str = ...
ResizeRequest: str = ...
Selection: str = ...
SelectionClear: str = ...
SelectionRequest: str = ...
Unmap: str = ...
VirtualEvent: str = ...
Visibility: str = ...
# Events considered covariant because you should never assign to event.widget.
_W = TypeVar("_W", covariant=True, bound="Misc")
class Event(Generic[_W]):
serial: int
num: int
focus: bool
height: int
width: int
keycode: int
state: Union[int, str]
time: int
x: int
y: int
x_root: int
y_root: int
char: str
send_event: bool
keysym: str
keysym_num: int
type: EventType
widget: _W
delta: int
def NoDefaultRoot(): ...
_TraceMode = Literal["array", "read", "write", "unset"]
class Variable:
def __init__(self, master: Optional[Misc] = ..., value: Optional[Any] = ..., name: Optional[str] = ...) -> None: ...
def set(self, value: Any) -> None: ...
initialize = set
def get(self) -> Any: ...
def trace_add(self, mode: _TraceMode, callback: Callable[[str, str, str], Any]) -> str: ...
def trace_remove(self, mode: _TraceMode, cbname: str) -> None: ...
def trace_info(self) -> List[Tuple[Tuple[_TraceMode, ...], str]]: ...
def trace_variable(self, mode, callback): ... # deprecated
def trace_vdelete(self, mode, cbname): ... # deprecated
def trace_vinfo(self): ... # deprecated
trace = trace_variable # deprecated
class StringVar(Variable):
def __init__(self, master: Optional[Misc] = ..., value: Optional[str] = ..., name: Optional[str] = ...) -> None: ...
def set(self, value: str) -> None: ...
initialize = set
def get(self) -> str: ...
class IntVar(Variable):
def __init__(self, master: Optional[Misc] = ..., value: Optional[int] = ..., name: Optional[str] = ...) -> None: ...
def set(self, value: int) -> None: ...
initialize = set
def get(self) -> int: ...
class DoubleVar(Variable):
def __init__(self, master: Optional[Misc] = ..., value: Optional[float] = ..., name: Optional[str] = ...) -> None: ...
def set(self, value: float) -> None: ...
initialize = set
def get(self) -> float: ...
class BooleanVar(Variable):
def __init__(self, master: Optional[Misc] = ..., value: Optional[bool] = ..., name: Optional[str] = ...) -> None: ...
def set(self, value: bool) -> None: ...
initialize = set
def get(self) -> bool: ...
def mainloop(n: int = ...): ...
getint: Any
getdouble: Any
def getboolean(s): ...
class Misc:
master: Optional[Misc]
tk: _tkinter.TkappType
def destroy(self): ...
def deletecommand(self, name): ...
def tk_strictMotif(self, boolean: Optional[Any] = ...): ...
def tk_bisque(self): ...
def tk_setPalette(self, *args, **kw): ...
def wait_variable(self, name: Union[str, Variable] = ...): ...
waitvar: Any
def wait_window(self, window: Optional[Any] = ...): ...
def wait_visibility(self, window: Optional[Any] = ...): ...
def setvar(self, name: str = ..., value: str = ...): ...
def getvar(self, name: str = ...): ...
def getint(self, s): ...
def getdouble(self, s): ...
def getboolean(self, s): ...
def focus_set(self): ...
focus: Any
def focus_force(self): ...
def focus_get(self): ...
def focus_displayof(self): ...
def focus_lastfor(self): ...
def tk_focusFollowsMouse(self): ...
def tk_focusNext(self): ...
def tk_focusPrev(self): ...
@overload
def after(self, ms: int, func: None = ...) -> None: ...
@overload
def after(self, ms: Union[int, Literal["idle"]], func: Callable[..., Any], *args: Any) -> str: ...
# after_idle is essentially partialmethod(after, "idle")
def after_idle(self, func: Callable[..., Any], *args: Any) -> str: ...
def after_cancel(self, id: str) -> None: ...
def bell(self, displayof: int = ...): ...
def clipboard_get(self, **kw): ...
def clipboard_clear(self, **kw): ...
def clipboard_append(self, string, **kw): ...
def grab_current(self): ...
def grab_release(self): ...
def grab_set(self): ...
def grab_set_global(self): ...
def grab_status(self): ...
def option_add(self, pattern, value, priority: Optional[Any] = ...): ...
def option_clear(self): ...
def option_get(self, name, className): ...
def option_readfile(self, fileName, priority: Optional[Any] = ...): ...
def selection_clear(self, **kw): ...
def selection_get(self, **kw): ...
def selection_handle(self, command, **kw): ...
def selection_own(self, **kw): ...
def selection_own_get(self, **kw): ...
def send(self, interp, cmd, *args): ...
def lower(self, belowThis: Optional[Any] = ...): ...
def tkraise(self, aboveThis: Optional[Any] = ...): ...
lift: Any
def winfo_atom(self, name, displayof: int = ...): ...
def winfo_atomname(self, id, displayof: int = ...): ...
def winfo_cells(self): ...
def winfo_children(self): ...
def winfo_class(self): ...
def winfo_colormapfull(self): ...
def winfo_containing(self, rootX, rootY, displayof: int = ...): ...
def winfo_depth(self): ...
def winfo_exists(self): ...
def winfo_fpixels(self, number): ...
def winfo_geometry(self): ...
def winfo_height(self): ...
def winfo_id(self): ...
def winfo_interps(self, displayof: int = ...): ...
def winfo_ismapped(self): ...
def winfo_manager(self): ...
def winfo_name(self): ...
def winfo_parent(self): ...
def winfo_pathname(self, id, displayof: int = ...): ...
def winfo_pixels(self, number): ...
def winfo_pointerx(self): ...
def winfo_pointerxy(self): ...
def winfo_pointery(self): ...
def winfo_reqheight(self): ...
def winfo_reqwidth(self): ...
def winfo_rgb(self, color): ...
def winfo_rootx(self): ...
def winfo_rooty(self): ...
def winfo_screen(self): ...
def winfo_screencells(self): ...
def winfo_screendepth(self): ...
def winfo_screenheight(self): ...
def winfo_screenmmheight(self): ...
def winfo_screenmmwidth(self): ...
def winfo_screenvisual(self): ...
def winfo_screenwidth(self): ...
def winfo_server(self): ...
def winfo_toplevel(self): ...
def winfo_viewable(self): ...
def winfo_visual(self): ...
def winfo_visualid(self): ...
def winfo_visualsavailable(self, includeids: int = ...): ...
def winfo_vrootheight(self): ...
def winfo_vrootwidth(self): ...
def winfo_vrootx(self): ...
def winfo_vrooty(self): ...
def winfo_width(self): ...
def winfo_x(self): ...
def winfo_y(self): ...
def update(self): ...
def update_idletasks(self): ...
def bindtags(self, tagList: Optional[Any] = ...): ...
# bind with isinstance(func, str) doesn't return anything, but all other
# binds do. The default value of func is not str.
@overload
def bind(
self,
sequence: Optional[str] = ...,
func: Optional[Callable[[Event[Misc]], Optional[Literal["break"]]]] = ...,
add: Optional[bool] = ...,
) -> str: ...
@overload
def bind(self, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ...
@overload
def bind(self, *, func: str, add: Optional[bool] = ...) -> None: ...
# There's no way to know what type of widget bind_all and bind_class
# callbacks will get, so those are Misc.
@overload
def bind_all(
self,
sequence: Optional[str] = ...,
func: Optional[Callable[[Event[Misc]], Optional[Literal["break"]]]] = ...,
add: Optional[bool] = ...,
) -> str: ...
@overload
def bind_all(self, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ...
@overload
def bind_all(self, *, func: str, add: Optional[bool] = ...) -> None: ...
@overload
def bind_class(
self,
className: str,
sequence: Optional[str] = ...,
func: Optional[Callable[[Event[Misc]], Optional[Literal["break"]]]] = ...,
add: Optional[bool] = ...,
) -> str: ...
@overload
def bind_class(self, className: str, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ...
@overload
def bind_class(self, className: str, *, func: str, add: Optional[bool] = ...) -> None: ...
def unbind(self, sequence: str, funcid: Optional[str] = ...) -> None: ...
def unbind_all(self, sequence: str) -> None: ...
def unbind_class(self, className: str, sequence: str) -> None: ...
def mainloop(self, n: int = ...): ...
def quit(self): ...
def nametowidget(self, name): ...
register: Any
def keys(self) -> List[str]: ...
@overload
def pack_propagate(self, flag: bool) -> Optional[bool]: ...
@overload
def pack_propagate(self) -> None: ...
propagate = pack_propagate
def grid_anchor(self, anchor: Optional[_Anchor] = ...) -> None: ...
anchor = grid_anchor
@overload
def grid_bbox(
self, column: None = ..., row: None = ..., col2: None = ..., row2: None = ...
) -> Optional[Tuple[int, int, int, int]]: ...
@overload
def grid_bbox(self, column: int, row: int, col2: None = ..., row2: None = ...) -> Optional[Tuple[int, int, int, int]]: ...
@overload
def grid_bbox(self, column: int, row: int, col2: int, row2: int) -> Optional[Tuple[int, int, int, int]]: ...
# commented out to avoid conflicting with other bbox methods
# bbox = grid_bbox
def grid_columnconfigure(self, index, cnf=..., **kw): ... # TODO
def grid_rowconfigure(self, index, cnf=..., **kw): ... # TODO
columnconfigure = grid_columnconfigure
rowconfigure = grid_rowconfigure
def grid_location(self, x: _ScreenUnits, y: _ScreenUnits) -> Tuple[int, int]: ...
@overload
def grid_propagate(self, flag: bool) -> None: ...
@overload
def grid_propagate(self) -> bool: ...
def grid_size(self) -> Tuple[int, int]: ...
size = grid_size
# Widget because Toplevel or Tk is never a slave
def pack_slaves(self) -> List[Widget]: ...
def grid_slaves(self, row: Optional[int] = ..., column: Optional[int] = ...) -> List[Widget]: ...
def place_slaves(self) -> List[Widget]: ...
slaves = pack_slaves
def event_add(self, virtual, *sequences): ...
def event_delete(self, virtual, *sequences): ...
def event_generate(self, sequence, **kw): ...
def event_info(self, virtual: Optional[Any] = ...): ...
def image_names(self): ...
def image_types(self): ...
# See #4363
def __setitem__(self, key: str, value: Any) -> None: ...
def __getitem__(self, key: str) -> Any: ...
class CallWrapper:
func: Any
subst: Any
widget: Any
def __init__(self, func, subst, widget): ...
def __call__(self, *args): ...
class XView:
def xview(self, *args): ...
def xview_moveto(self, fraction): ...
def xview_scroll(self, number, what): ...
class YView:
def yview(self, *args): ...
def yview_moveto(self, fraction): ...
def yview_scroll(self, number, what): ...
class Wm:
def wm_aspect(
self,
minNumer: Optional[Any] = ...,
minDenom: Optional[Any] = ...,
maxNumer: Optional[Any] = ...,
maxDenom: Optional[Any] = ...,
): ...
aspect: Any
def wm_attributes(self, *args): ...
attributes: Any
def wm_client(self, name: Optional[Any] = ...): ...
client: Any
def wm_colormapwindows(self, *wlist): ...
colormapwindows: Any
def wm_command(self, value: Optional[Any] = ...): ...
command: Any
def wm_deiconify(self): ...
deiconify: Any
def wm_focusmodel(self, model: Optional[Any] = ...): ...
focusmodel: Any
def wm_forget(self, window): ...
forget: Any
def wm_frame(self): ...
frame: Any
def wm_geometry(self, newGeometry: Optional[Any] = ...): ...
geometry: Any
def wm_grid(
self,
baseWidth: Optional[Any] = ...,
baseHeight: Optional[Any] = ...,
widthInc: Optional[Any] = ...,
heightInc: Optional[Any] = ...,
): ...
grid: Any
def wm_group(self, pathName: Optional[Any] = ...): ...
group: Any
def wm_iconbitmap(self, bitmap: Optional[Any] = ..., default: Optional[Any] = ...): ...
iconbitmap: Any
def wm_iconify(self): ...
iconify: Any
def wm_iconmask(self, bitmap: Optional[Any] = ...): ...
iconmask: Any
def wm_iconname(self, newName: Optional[Any] = ...): ...
iconname: Any
def wm_iconphoto(self, default: bool = ..., *args): ...
iconphoto: Any
def wm_iconposition(self, x: Optional[Any] = ..., y: Optional[Any] = ...): ...
iconposition: Any
def wm_iconwindow(self, pathName: Optional[Any] = ...): ...
iconwindow: Any
def wm_manage(self, widget): ...
manage: Any
def wm_maxsize(self, width: Optional[Any] = ..., height: Optional[Any] = ...): ...
maxsize: Any
def wm_minsize(self, width: Optional[Any] = ..., height: Optional[Any] = ...): ...
minsize: Any
def wm_overrideredirect(self, boolean: Optional[Any] = ...): ...
overrideredirect: Any
def wm_positionfrom(self, who: Optional[Any] = ...): ...
positionfrom: Any
def wm_protocol(self, name: Optional[Any] = ..., func: Optional[Any] = ...): ...
protocol: Any
def wm_resizable(self, width: Optional[Any] = ..., height: Optional[Any] = ...): ...
resizable: Any
def wm_sizefrom(self, who: Optional[Any] = ...): ...
sizefrom: Any
def wm_state(self, newstate: Optional[Any] = ...): ...
state: Any
def wm_title(self, string: Optional[Any] = ...): ...
title: Any
def wm_transient(self, master: Optional[Any] = ...): ...
transient: Any
def wm_withdraw(self): ...
withdraw: Any
_TkOptionName = Literal[
"background",
"bd",
"bg",
"border",
"borderwidth",
"class",
"colormap",
"container",
"cursor",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"menu",
"padx",
"pady",
"relief",
"screen", # can't be changed after creating widget
"takefocus",
"use",
"visual",
"width",
]
class _ExceptionReportingCallback(Protocol):
def __call__(self, __exc: Type[BaseException], __val: BaseException, __tb: TracebackType) -> Any: ...
class Tk(Misc, Wm):
master: None
children: Dict[str, Any]
def __init__(
self,
screenName: Optional[str] = ...,
baseName: Optional[str] = ...,
className: str = ...,
useTk: bool = ...,
sync: bool = ...,
use: Optional[str] = ...,
) -> None: ...
@overload
def configure(
self: Union[Tk, Toplevel],
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
menu: Menu = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
takefocus: _TakeFocusValue = ...,
width: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _TkOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _TkOptionName) -> Any: ...
def loadtk(self) -> None: ... # differs from _tkinter.TkappType.loadtk
def destroy(self) -> None: ...
def readprofile(self, baseName: str, className: str) -> None: ...
report_callback_exception: _ExceptionReportingCallback
# Tk has __getattr__ so that tk_instance.foo falls back to tk_instance.tk.foo
# Please keep in sync with _tkinter.TkappType
call: Callable[..., Any]
eval: Callable[[str], str]
adderrorinfo: Any
createcommand: Any
createfilehandler: Any
createtimerhandler: Any
deletecommand: Any
deletefilehandler: Any
dooneevent: Any
evalfile: Any
exprboolean: Any
exprdouble: Any
exprlong: Any
exprstring: Any
getboolean: Any
getdouble: Any
getint: Any
getvar: Any
globalgetvar: Any
globalsetvar: Any
globalunsetvar: Any
interpaddr: Any
mainloop: Any
quit: Any
record: Any
setvar: Any
split: Any
splitlist: Any
unsetvar: Any
wantobjects: Any
willdispatch: Any
def Tcl(screenName: Optional[Any] = ..., baseName: Optional[Any] = ..., className: str = ..., useTk: bool = ...): ...
_InMiscTotal = TypedDict("_InMiscTotal", {"in": Misc})
_InMiscNonTotal = TypedDict("_InMiscNonTotal", {"in": Misc}, total=False)
class _PackInfo(_InMiscTotal):
# 'before' and 'after' never appear in _PackInfo
anchor: _Anchor
expand: Literal[0, 1]
fill: Literal["none", "x", "y", "both"]
side: Literal["left", "right", "top", "bottom"]
# Paddings come out as int or tuple of int, even though any _ScreenUnits
# can be specified in pack().
ipadx: int
ipady: int
padx: Union[int, Tuple[int, int]]
pady: Union[int, Tuple[int, int]]
class Pack:
# _PackInfo is not the valid type for cnf because pad stuff accepts any
# _ScreenUnits instead of int only. I didn't bother to create another
# TypedDict for cnf because it appears to be a legacy thing that was
# replaced by **kwargs.
def pack_configure(
self,
cnf: Optional[Mapping[str, Any]] = ...,
*,
after: Misc = ...,
anchor: _Anchor = ...,
before: Misc = ...,
expand: int = ...,
fill: Literal["none", "x", "y", "both"] = ...,
side: Literal["left", "right", "top", "bottom"] = ...,
ipadx: _ScreenUnits = ...,
ipady: _ScreenUnits = ...,
padx: Union[_ScreenUnits, Tuple[_ScreenUnits, _ScreenUnits]] = ...,
pady: Union[_ScreenUnits, Tuple[_ScreenUnits, _ScreenUnits]] = ...,
in_: Misc = ...,
) -> None: ...
def pack_forget(self) -> None: ...
def pack_info(self) -> _PackInfo: ... # errors if widget hasn't been packed
pack = pack_configure
forget = pack_forget
propagate = Misc.pack_propagate
# commented out to avoid mypy getting confused with multiple
# inheritance and how things get overrided with different things
# info = pack_info
# pack_propagate = Misc.pack_propagate
# configure = pack_configure
# config = pack_configure
# slaves = Misc.pack_slaves
# pack_slaves = Misc.pack_slaves
class _PlaceInfo(_InMiscNonTotal): # empty dict if widget hasn't been placed
anchor: _Anchor
bordermode: Literal["inside", "outside", "ignore"]
width: str # can be int()ed (even after e.g. widget.place(height='2.3c') or similar)
height: str # can be int()ed
x: str # can be int()ed
y: str # can be int()ed
relheight: str # can be float()ed if not empty string
relwidth: str # can be float()ed if not empty string
relx: float # can be float()ed if not empty string
rely: float # can be float()ed if not empty string
class Place:
def place_configure(
self,
cnf: Optional[Mapping[str, Any]] = ...,
*,
anchor: _Anchor = ...,
bordermode: Literal["inside", "outside", "ignore"] = ...,
width: _ScreenUnits = ...,
height: _ScreenUnits = ...,
x: _ScreenUnits = ...,
y: _ScreenUnits = ...,
relheight: float = ...,
relwidth: float = ...,
relx: float = ...,
rely: float = ...,
in_: Misc = ...,
) -> None: ...
def place_forget(self) -> None: ...
def place_info(self) -> _PlaceInfo: ...
place = place_configure
info = place_info
# commented out to avoid mypy getting confused with multiple
# inheritance and how things get overrided with different things
# config = place_configure
# configure = place_configure
# forget = place_forget
# slaves = Misc.place_slaves
# place_slaves = Misc.place_slaves
class _GridInfo(_InMiscNonTotal): # empty dict if widget hasn't been gridded
column: int
columnspan: int
row: int
rowspan: int
ipadx: int
ipady: int
padx: Union[int, Tuple[int, int]]
pady: Union[int, Tuple[int, int]]
sticky: str # consists of letters 'n', 's', 'w', 'e', no repeats, may be empty
class Grid:
def grid_configure(
self,
cnf: Optional[Mapping[str, Any]] = ...,
*,
column: int = ...,
columnspan: int = ...,
row: int = ...,
rowspan: int = ...,
ipadx: _ScreenUnits = ...,
ipady: _ScreenUnits = ...,
padx: Union[_ScreenUnits, Tuple[_ScreenUnits, _ScreenUnits]] = ...,
pady: Union[_ScreenUnits, Tuple[_ScreenUnits, _ScreenUnits]] = ...,
sticky: str = ..., # consists of letters 'n', 's', 'w', 'e', may contain repeats, may be empty
in_: Misc = ...,
) -> None: ...
def grid_forget(self) -> None: ...
def grid_remove(self) -> None: ...
def grid_info(self) -> _GridInfo: ...
grid = grid_configure
location = Misc.grid_location
size = Misc.grid_size
# commented out to avoid mypy getting confused with multiple
# inheritance and how things get overrided with different things
# bbox = Misc.grid_bbox
# grid_bbox = Misc.grid_bbox
# forget = grid_forget
# info = grid_info
# grid_location = Misc.grid_location
# grid_propagate = Misc.grid_propagate
# grid_size = Misc.grid_size
# rowconfigure = Misc.grid_rowconfigure
# grid_rowconfigure = Misc.grid_rowconfigure
# grid_columnconfigure = Misc.grid_columnconfigure
# columnconfigure = Misc.grid_columnconfigure
# config = grid_configure
# configure = grid_configure
# propagate = Misc.grid_propagate
# slaves = Misc.grid_slaves
# grid_slaves = Misc.grid_slaves
class BaseWidget(Misc):
master: Misc
widgetName: Any
def __init__(self, master, widgetName, cnf=..., kw=..., extra=...): ...
def destroy(self): ...
# This class represents any widget except Toplevel or Tk.
class Widget(BaseWidget, Pack, Place, Grid):
# Allow bind callbacks to take e.g. Event[Label] instead of Event[Misc].
# Tk and Toplevel get notified for their child widgets' events, but other
# widgets don't.
@overload
def bind(
self: _W,
sequence: Optional[str] = ...,
func: Optional[Callable[[Event[_W]], Optional[Literal["break"]]]] = ...,
add: Optional[bool] = ...,
) -> str: ...
@overload
def bind(self, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ...
@overload
def bind(self, *, func: str, add: Optional[bool] = ...) -> None: ...
class Toplevel(BaseWidget, Wm):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
class_: str = ...,
colormap: Union[Literal["new", ""], Misc] = ...,
container: bool = ...,
cursor: _Cursor = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
menu: Menu = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
screen: str = ...,
takefocus: _TakeFocusValue = ...,
use: int = ...,
visual: Union[str, Tuple[str, int]] = ...,
width: _ScreenUnits = ...,
) -> None: ...
# Toplevel and Tk have the same options because they correspond to the same
# Tcl/Tk toplevel widget.
configure = Tk.configure
config = Tk.config
cget = Tk.cget
_ButtonOptionName = Literal[
"activebackground",
"activeforeground",
"anchor",
"background",
"bd", # same as borderwidth
"bg", # same as background
"bitmap",
"border", # same as borderwidth
"borderwidth",
"command",
"compound",
"cursor",
"default",
"disabledforeground",
"fg", # same as foreground
"font",
"foreground",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"image",
"justify",
"overrelief",
"padx",
"pady",
"relief",
"repeatdelay",
"repeatinterval",
"state",
"takefocus",
"text",
"textvariable",
"underline",
"width",
"wraplength",
]
class Button(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
command: _ButtonCommand = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
default: Literal["normal", "active", "disabled"] = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
# width and height must be int for buttons containing just text, but
# ints are also valid _ScreenUnits
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
overrelief: _Relief = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
repeatdelay: int = ...,
repeatinterval: int = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
# We allow the textvariable to be any Variable, not necessarly
# StringVar. This is useful for e.g. a button that displays the value
# of an IntVar.
textvariable: Variable = ...,
underline: int = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
command: _ButtonCommand = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
default: Literal["normal", "active", "disabled"] = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
justify: Literal["left", "center", "right"] = ...,
overrelief: _Relief = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
repeatdelay: int = ...,
repeatinterval: int = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
underline: int = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _ButtonOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _ButtonOptionName) -> Any: ...
def flash(self): ...
def invoke(self): ...
_CanvasOptionName = Literal[
"background",
"bd",
"bg",
"border",
"borderwidth",
"closeenough",
"confine",
"cursor",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"insertbackground",
"insertborderwidth",
"insertofftime",
"insertontime",
"insertwidth",
"offset",
"relief",
"scrollregion",
"selectbackground",
"selectborderwidth",
"selectforeground",
"state",
"takefocus",
"width",
"xscrollcommand",
"xscrollincrement",
"yscrollcommand",
"yscrollincrement",
]
class Canvas(Widget, XView, YView):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
closeenough: float = ...,
confine: bool = ...,
cursor: _Cursor = ...,
# canvas manual page has a section named COORDINATES, and the first
# part of it describes _ScreenUnits.
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
insertbackground: _Color = ...,
insertborderwidth: _ScreenUnits = ...,
insertofftime: int = ...,
insertontime: int = ...,
insertwidth: _ScreenUnits = ...,
name: str = ...,
offset: Any = ..., # undocumented
relief: _Relief = ...,
# Setting scrollregion to None doesn't reset it back to empty,
# but setting it to () does.
scrollregion: Union[Tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits, _ScreenUnits], Tuple[()]] = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
# man page says that state can be 'hidden', but it can't
state: Literal["normal", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
width: _ScreenUnits = ...,
xscrollcommand: _XYScrollCommand = ...,
xscrollincrement: _ScreenUnits = ...,
yscrollcommand: _XYScrollCommand = ...,
yscrollincrement: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
closeenough: float = ...,
confine: bool = ...,
cursor: _Cursor = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
insertbackground: _Color = ...,
insertborderwidth: _ScreenUnits = ...,
insertofftime: int = ...,
insertontime: int = ...,
insertwidth: _ScreenUnits = ...,
offset: Any = ..., # undocumented
relief: _Relief = ...,
scrollregion: Union[Tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits, _ScreenUnits], Tuple[()]] = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
state: Literal["normal", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
width: _ScreenUnits = ...,
xscrollcommand: _XYScrollCommand = ...,
xscrollincrement: _ScreenUnits = ...,
yscrollcommand: _XYScrollCommand = ...,
yscrollincrement: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _CanvasOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _CanvasOptionName) -> Any: ...
def addtag(self, *args): ...
def addtag_above(self, newtag, tagOrId): ...
def addtag_all(self, newtag): ...
def addtag_below(self, newtag, tagOrId): ...
def addtag_closest(self, newtag, x, y, halo: Optional[Any] = ..., start: Optional[Any] = ...): ...
def addtag_enclosed(self, newtag, x1, y1, x2, y2): ...
def addtag_overlapping(self, newtag, x1, y1, x2, y2): ...
def addtag_withtag(self, newtag, tagOrId): ...
def bbox(self, *args): ...
@overload
def tag_bind(
self,
tagOrId: Union[str, int],
sequence: Optional[str] = ...,
func: Optional[Callable[[Event[Canvas]], Optional[Literal["break"]]]] = ...,
add: Optional[bool] = ...,
) -> str: ...
@overload
def tag_bind(self, tagOrId: Union[str, int], sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ...
@overload
def tag_bind(self, tagOrId: Union[str, int], *, func: str, add: Optional[bool] = ...) -> None: ...
def tag_unbind(self, tagOrId: Union[str, int], sequence: str, funcid: Optional[str] = ...) -> None: ...
def canvasx(self, screenx, gridspacing: Optional[Any] = ...): ...
def canvasy(self, screeny, gridspacing: Optional[Any] = ...): ...
def coords(self, *args): ...
def create_arc(self, *args, **kw): ...
def create_bitmap(self, *args, **kw): ...
def create_image(self, *args, **kw): ...
def create_line(self, *args, **kw): ...
def create_oval(self, *args, **kw): ...
def create_polygon(self, *args, **kw): ...
def create_rectangle(self, *args, **kw): ...
def create_text(self, *args, **kw): ...
def create_window(self, *args, **kw): ...
def dchars(self, *args): ...
def delete(self, *args): ...
def dtag(self, *args): ...
def find(self, *args): ...
def find_above(self, tagOrId): ...
def find_all(self): ...
def find_below(self, tagOrId): ...
def find_closest(self, x, y, halo: Optional[Any] = ..., start: Optional[Any] = ...): ...
def find_enclosed(self, x1, y1, x2, y2): ...
def find_overlapping(self, x1, y1, x2, y2): ...
def find_withtag(self, tagOrId): ...
def focus(self, *args): ...
def gettags(self, *args): ...
def icursor(self, *args): ...
def index(self, *args): ...
def insert(self, *args): ...
def itemcget(self, tagOrId, option): ...
def itemconfigure(self, tagOrId, cnf: Optional[Any] = ..., **kw): ...
itemconfig: Any
def tag_lower(self, *args): ...
lower: Any
def move(self, *args): ...
if sys.version_info >= (3, 8):
def moveto(self, tagOrId: Union[int, str], x: str = ..., y: str = ...) -> None: ...
def postscript(self, cnf=..., **kw): ...
def tag_raise(self, *args): ...
lift: Any
def scale(self, *args): ...
def scan_mark(self, x, y): ...
def scan_dragto(self, x, y, gain: int = ...): ...
def select_adjust(self, tagOrId, index): ...
def select_clear(self): ...
def select_from(self, tagOrId, index): ...
def select_item(self): ...
def select_to(self, tagOrId, index): ...
def type(self, tagOrId): ...
_CheckbuttonOptionName = Literal[
"activebackground",
"activeforeground",
"anchor",
"background",
"bd",
"bg",
"bitmap",
"border",
"borderwidth",
"command",
"compound",
"cursor",
"disabledforeground",
"fg",
"font",
"foreground",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"image",
"indicatoron",
"justify",
"offrelief",
"offvalue",
"onvalue",
"overrelief",
"padx",
"pady",
"relief",
"selectcolor",
"selectimage",
"state",
"takefocus",
"text",
"textvariable",
"tristateimage",
"tristatevalue",
"underline",
"variable",
"width",
"wraplength",
]
class Checkbutton(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
command: _ButtonCommand = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
indicatoron: bool = ...,
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
offrelief: _Relief = ...,
# The checkbutton puts a value to its variable when it's checked or
# unchecked. We don't restrict the type of that value here, so
# Any-typing is fine.
#
# I think Checkbutton shouldn't be generic, because then specifying
# "any checkbutton regardless of what variable it uses" would be
# difficult, and we might run into issues just like how List[float]
# and List[int] are incompatible. Also, we would need a way to
# specify "Checkbutton not associated with any variable", which is
# done by setting variable to empty string (the default).
offvalue: Any = ...,
onvalue: Any = ...,
overrelief: _Relief = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
selectcolor: _Color = ...,
selectimage: _ImageSpec = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
tristateimage: _ImageSpec = ...,
tristatevalue: Any = ...,
underline: int = ...,
variable: Union[Variable, Literal[""]] = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
command: _ButtonCommand = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
indicatoron: bool = ...,
justify: Literal["left", "center", "right"] = ...,
offrelief: _Relief = ...,
offvalue: Any = ...,
onvalue: Any = ...,
overrelief: _Relief = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
selectcolor: _Color = ...,
selectimage: _ImageSpec = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
tristateimage: _ImageSpec = ...,
tristatevalue: Any = ...,
underline: int = ...,
variable: Union[Variable, Literal[""]] = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _CheckbuttonOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _CheckbuttonOptionName) -> Any: ...
def deselect(self): ...
def flash(self): ...
def invoke(self): ...
def select(self): ...
def toggle(self): ...
_EntryOptionName = Literal[
"background",
"bd",
"bg",
"border",
"borderwidth",
"cursor",
"disabledbackground",
"disabledforeground",
"exportselection",
"fg",
"font",
"foreground",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"insertbackground",
"insertborderwidth",
"insertofftime",
"insertontime",
"insertwidth",
"invalidcommand",
"invcmd", # same as invalidcommand
"justify",
"readonlybackground",
"relief",
"selectbackground",
"selectborderwidth",
"selectforeground",
"show",
"state",
"takefocus",
"textvariable",
"validate",
"validatecommand",
"vcmd", # same as validatecommand
"width",
"xscrollcommand",
]
class Entry(Widget, XView):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
disabledbackground: _Color = ...,
disabledforeground: _Color = ...,
exportselection: bool = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
insertbackground: _Color = ...,
insertborderwidth: _ScreenUnits = ...,
insertofftime: int = ...,
insertontime: int = ...,
insertwidth: _ScreenUnits = ...,
invalidcommand: _EntryValidateCommand = ...,
invcmd: _EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
readonlybackground: _Color = ...,
relief: _Relief = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
show: str = ...,
state: Literal["normal", "disabled", "readonly"] = ...,
takefocus: _TakeFocusValue = ...,
textvariable: Variable = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: _EntryValidateCommand = ...,
vcmd: _EntryValidateCommand = ...,
width: int = ...,
xscrollcommand: _XYScrollCommand = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
disabledbackground: _Color = ...,
disabledforeground: _Color = ...,
exportselection: bool = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
insertbackground: _Color = ...,
insertborderwidth: _ScreenUnits = ...,
insertofftime: int = ...,
insertontime: int = ...,
insertwidth: _ScreenUnits = ...,
invalidcommand: _EntryValidateCommand = ...,
invcmd: _EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
readonlybackground: _Color = ...,
relief: _Relief = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
show: str = ...,
state: Literal["normal", "disabled", "readonly"] = ...,
takefocus: _TakeFocusValue = ...,
textvariable: Variable = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: _EntryValidateCommand = ...,
vcmd: _EntryValidateCommand = ...,
width: int = ...,
xscrollcommand: _XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _EntryOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _EntryOptionName) -> Any: ...
def delete(self, first, last: Optional[Any] = ...): ...
def get(self): ...
def icursor(self, index): ...
def index(self, index): ...
def insert(self, index, string): ...
def scan_mark(self, x): ...
def scan_dragto(self, x): ...
def selection_adjust(self, index): ...
select_adjust: Any
def selection_clear(self): ...
select_clear: Any
def selection_from(self, index): ...
select_from: Any
def selection_present(self): ...
select_present: Any
def selection_range(self, start, end): ...
select_range: Any
def selection_to(self, index): ...
select_to: Any
_FrameOptionName = Literal[
"background",
"bd",
"bg",
"border",
"borderwidth",
"class",
"colormap",
"container",
"cursor",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"padx",
"pady",
"relief",
"takefocus",
"visual",
"width",
]
class Frame(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
class_: str = ...,
colormap: Union[Literal["new", ""], Misc] = ...,
container: bool = ...,
cursor: _Cursor = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
name: str = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
takefocus: _TakeFocusValue = ...,
visual: Union[str, Tuple[str, int]] = ...,
width: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
takefocus: _TakeFocusValue = ...,
width: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _FrameOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _FrameOptionName) -> Any: ...
_LabelOptionName = Literal[
"activebackground",
"activeforeground",
"anchor",
"background",
"bd",
"bg",
"bitmap",
"border",
"borderwidth",
"compound",
"cursor",
"disabledforeground",
"fg",
"font",
"foreground",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"image",
"justify",
"padx",
"pady",
"relief",
"state",
"takefocus",
"text",
"textvariable",
"underline",
"width",
"wraplength",
]
class Label(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
underline: int = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
justify: Literal["left", "center", "right"] = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
underline: int = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _LabelOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _LabelOptionName) -> Any: ...
_ListboxOptionName = Literal[
"activestyle",
"background",
"bd",
"bg",
"border",
"borderwidth",
"cursor",
"disabledforeground",
"exportselection",
"fg",
"font",
"foreground",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"justify",
"listvariable",
"relief",
"selectbackground",
"selectborderwidth",
"selectforeground",
"selectmode",
"setgrid",
"state",
"takefocus",
"width",
"xscrollcommand",
"yscrollcommand",
]
class Listbox(Widget, XView, YView):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activestyle: Literal["dotbox", "none", "underline"] = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
exportselection: int = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: int = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
justify: Literal["left", "center", "right"] = ...,
# There's no tkinter.ListVar, but seems like bare tkinter.Variable
# actually works for this:
#
# >>> import tkinter
# >>> lb = tkinter.Listbox()
# >>> var = lb['listvariable'] = tkinter.Variable()
# >>> var.set(['foo', 'bar', 'baz'])
# >>> lb.get(0, 'end')
# ('foo', 'bar', 'baz')
listvariable: Variable = ...,
name: str = ...,
relief: _Relief = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
# from listbox man page: "The value of the [selectmode] option may be
# arbitrary, but the default bindings expect it to be ..."
#
# I have never seen anyone setting this to something else than what
# "the default bindings expect", but let's support it anyway.
selectmode: str = ...,
setgrid: bool = ...,
state: Literal["normal", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
width: int = ...,
xscrollcommand: _XYScrollCommand = ...,
yscrollcommand: _XYScrollCommand = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activestyle: Literal["dotbox", "none", "underline"] = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
exportselection: bool = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: int = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
justify: Literal["left", "center", "right"] = ...,
listvariable: Variable = ...,
relief: _Relief = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
selectmode: str = ...,
setgrid: bool = ...,
state: Literal["normal", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
width: int = ...,
xscrollcommand: _XYScrollCommand = ...,
yscrollcommand: _XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _ListboxOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _ListboxOptionName) -> Any: ...
def activate(self, index): ...
def bbox(self, index): ...
def curselection(self): ...
def delete(self, first, last: Optional[Any] = ...): ...
def get(self, first, last: Optional[Any] = ...): ...
def index(self, index): ...
def insert(self, index, *elements): ...
def nearest(self, y): ...
def scan_mark(self, x, y): ...
def scan_dragto(self, x, y): ...
def see(self, index): ...
def selection_anchor(self, index): ...
select_anchor: Any
def selection_clear(self, first, last: Optional[Any] = ...): ... # type: ignore
select_clear: Any
def selection_includes(self, index): ...
select_includes: Any
def selection_set(self, first, last: Optional[Any] = ...): ...
select_set: Any
def size(self): ...
def itemcget(self, index, option): ...
def itemconfigure(self, index, cnf: Optional[Any] = ..., **kw): ...
itemconfig: Any
_MenuOptionName = Literal[
"activebackground",
"activeborderwidth",
"activeforeground",
"background",
"bd",
"bg",
"border",
"borderwidth",
"cursor",
"disabledforeground",
"fg",
"font",
"foreground",
"postcommand",
"relief",
"selectcolor",
"takefocus",
"tearoff",
"tearoffcommand",
"title",
"type",
]
class Menu(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeborderwidth: _ScreenUnits = ...,
activeforeground: _Color = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
name: str = ...,
postcommand: Union[Callable[[], Any], str] = ...,
relief: _Relief = ...,
selectcolor: _Color = ...,
takefocus: _TakeFocusValue = ...,
tearoff: int = ...,
# I guess tearoffcommand arguments are supposed to be widget objects,
# but they are widget name strings. Use nametowidget() to handle the
# arguments of tearoffcommand.
tearoffcommand: Union[Callable[[str, str], Any], str] = ...,
title: str = ...,
type: Literal["menubar", "tearoff", "normal"] = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeborderwidth: _ScreenUnits = ...,
activeforeground: _Color = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
postcommand: Union[Callable[[], Any], str] = ...,
relief: _Relief = ...,
selectcolor: _Color = ...,
takefocus: _TakeFocusValue = ...,
tearoff: bool = ...,
tearoffcommand: Union[Callable[[str, str], Any], str] = ...,
title: str = ...,
type: Literal["menubar", "tearoff", "normal"] = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _MenuOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _MenuOptionName) -> Any: ...
def tk_popup(self, x, y, entry: str = ...): ...
def activate(self, index): ...
def add(self, itemType, cnf=..., **kw): ...
def add_cascade(self, cnf=..., **kw): ...
def add_checkbutton(self, cnf=..., **kw): ...
def add_command(self, cnf=..., **kw): ...
def add_radiobutton(self, cnf=..., **kw): ...
def add_separator(self, cnf=..., **kw): ...
def insert(self, index, itemType, cnf=..., **kw): ...
def insert_cascade(self, index, cnf=..., **kw): ...
def insert_checkbutton(self, index, cnf=..., **kw): ...
def insert_command(self, index, cnf=..., **kw): ...
def insert_radiobutton(self, index, cnf=..., **kw): ...
def insert_separator(self, index, cnf=..., **kw): ...
def delete(self, index1, index2: Optional[Any] = ...): ...
def entrycget(self, index, option): ...
def entryconfigure(self, index, cnf: Optional[Any] = ..., **kw): ...
entryconfig: Any
def index(self, index): ...
def invoke(self, index): ...
def post(self, x, y): ...
def type(self, index): ...
def unpost(self): ...
def xposition(self, index): ...
def yposition(self, index): ...
_MenubuttonOptionName = Literal[
"activebackground",
"activeforeground",
"anchor",
"background",
"bd",
"bg",
"bitmap",
"border",
"borderwidth",
"compound",
"cursor",
"direction",
"disabledforeground",
"fg",
"font",
"foreground",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"image",
"indicatoron",
"justify",
"menu",
"padx",
"pady",
"relief",
"state",
"takefocus",
"text",
"textvariable",
"underline",
"width",
"wraplength",
]
class Menubutton(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
direction: Literal["above", "below", "left", "right", "flush"] = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
indicatoron: bool = ...,
justify: Literal["left", "center", "right"] = ...,
menu: Menu = ...,
name: str = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
underline: int = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
direction: Literal["above", "below", "left", "right", "flush"] = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
indicatoron: bool = ...,
justify: Literal["left", "center", "right"] = ...,
menu: Menu = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
underline: int = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _MenubuttonOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _MenubuttonOptionName) -> Any: ...
_MessageOptionName = Literal[
"anchor",
"aspect",
"background",
"bd",
"bg",
"border",
"borderwidth",
"cursor",
"fg",
"font",
"foreground",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"justify",
"padx",
"pady",
"relief",
"takefocus",
"text",
"textvariable",
"width",
]
class Message(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
anchor: _Anchor = ...,
aspect: int = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
# there's width but no height
width: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
anchor: _Anchor = ...,
aspect: int = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
justify: Literal["left", "center", "right"] = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
width: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _MessageOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _MessageOptionName) -> Any: ...
_RadiobuttonOptionName = Literal[
"activebackground",
"activeforeground",
"anchor",
"background",
"bd",
"bg",
"bitmap",
"border",
"borderwidth",
"command",
"compound",
"cursor",
"disabledforeground",
"fg",
"font",
"foreground",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"image",
"indicatoron",
"justify",
"offrelief",
"overrelief",
"padx",
"pady",
"relief",
"selectcolor",
"selectimage",
"state",
"takefocus",
"text",
"textvariable",
"tristateimage",
"tristatevalue",
"underline",
"value",
"variable",
"width",
"wraplength",
]
class Radiobutton(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
command: _ButtonCommand = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
indicatoron: bool = ...,
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
offrelief: _Relief = ...,
overrelief: _Relief = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
selectcolor: _Color = ...,
selectimage: _ImageSpec = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
tristateimage: _ImageSpec = ...,
tristatevalue: Any = ...,
underline: int = ...,
value: Any = ...,
variable: Union[Variable, Literal[""]] = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activeforeground: _Color = ...,
anchor: _Anchor = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bitmap: _Bitmap = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
command: _ButtonCommand = ...,
compound: _Compound = ...,
cursor: _Cursor = ...,
disabledforeground: _Color = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
image: _ImageSpec = ...,
indicatoron: bool = ...,
justify: Literal["left", "center", "right"] = ...,
offrelief: _Relief = ...,
overrelief: _Relief = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
selectcolor: _Color = ...,
selectimage: _ImageSpec = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
textvariable: Variable = ...,
tristateimage: _ImageSpec = ...,
tristatevalue: Any = ...,
underline: int = ...,
value: Any = ...,
variable: Union[Variable, Literal[""]] = ...,
width: _ScreenUnits = ...,
wraplength: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _RadiobuttonOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _RadiobuttonOptionName) -> Any: ...
def deselect(self): ...
def flash(self): ...
def invoke(self): ...
def select(self): ...
_ScaleOptionName = Literal[
"activebackground",
"background",
"bd",
"bg",
"bigincrement",
"border",
"borderwidth",
"command",
"cursor",
"digits",
"fg",
"font",
"foreground",
"from",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"label",
"length",
"orient",
"relief",
"repeatdelay",
"repeatinterval",
"resolution",
"showvalue",
"sliderlength",
"sliderrelief",
"state",
"takefocus",
"tickinterval",
"to",
"troughcolor",
"variable",
"width",
]
class Scale(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bigincrement: float = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
# don't know why the callback gets string instead of float
command: Union[str, Callable[[str], Any]] = ...,
cursor: _Cursor = ...,
digits: int = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
from_: float = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
label: str = ...,
length: _ScreenUnits = ...,
name: str = ...,
orient: Literal["horizontal", "vertical"] = ...,
relief: _Relief = ...,
repeatdelay: int = ...,
repeatinterval: int = ...,
resolution: float = ...,
showvalue: bool = ...,
sliderlength: _ScreenUnits = ...,
sliderrelief: _Relief = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
tickinterval: float = ...,
to: float = ...,
troughcolor: _Color = ...,
variable: DoubleVar = ...,
width: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
bigincrement: float = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
command: Union[str, Callable[[str], Any]] = ...,
cursor: _Cursor = ...,
digits: int = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
from_: float = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
label: str = ...,
length: _ScreenUnits = ...,
orient: Literal["horizontal", "vertical"] = ...,
relief: _Relief = ...,
repeatdelay: int = ...,
repeatinterval: int = ...,
resolution: float = ...,
showvalue: bool = ...,
sliderlength: _ScreenUnits = ...,
sliderrelief: _Relief = ...,
state: Literal["normal", "active", "disabled"] = ...,
takefocus: _TakeFocusValue = ...,
tickinterval: float = ...,
to: float = ...,
troughcolor: _Color = ...,
variable: DoubleVar = ...,
width: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _ScaleOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _ScaleOptionName) -> Any: ...
def get(self): ...
def set(self, value): ...
def coords(self, value: Optional[Any] = ...): ...
def identify(self, x, y): ...
_ScrollbarOptionName = Literal[
"activebackground",
"activerelief",
"background",
"bd",
"bg",
"border",
"borderwidth",
"command",
"cursor",
"elementborderwidth",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"jump",
"orient",
"relief",
"repeatdelay",
"repeatinterval",
"takefocus",
"troughcolor",
"width",
]
class Scrollbar(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activerelief: _Relief = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
# There are many ways how the command may get called. Search for
# 'SCROLLING COMMANDS' in scrollbar man page. There doesn't seem to
# be any way to specify an overloaded callback function, so we say
# that it can take any args while it can't in reality.
command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ...,
cursor: _Cursor = ...,
elementborderwidth: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
jump: bool = ...,
name: str = ...,
orient: Literal["horizontal", "vertical"] = ...,
relief: _Relief = ...,
repeatdelay: int = ...,
repeatinterval: int = ...,
takefocus: _TakeFocusValue = ...,
troughcolor: _Color = ...,
width: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
activerelief: _Relief = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ...,
cursor: _Cursor = ...,
elementborderwidth: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
jump: bool = ...,
orient: Literal["horizontal", "vertical"] = ...,
relief: _Relief = ...,
repeatdelay: int = ...,
repeatinterval: int = ...,
takefocus: _TakeFocusValue = ...,
troughcolor: _Color = ...,
width: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _ScrollbarOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _ScrollbarOptionName) -> Any: ...
def activate(self, index: Optional[Any] = ...): ...
def delta(self, deltax, deltay): ...
def fraction(self, x, y): ...
def identify(self, x, y): ...
def get(self): ...
def set(self, first, last): ...
_TextIndex = Union[_tkinter.Tcl_Obj, str, float]
_TextOptionName = Literal[
"autoseparators",
"background",
"bd",
"bg",
"blockcursor",
"border",
"borderwidth",
"cursor",
"endline",
"exportselection",
"fg",
"font",
"foreground",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"inactiveselectbackground",
"insertbackground",
"insertborderwidth",
"insertofftime",
"insertontime",
"insertunfocussed",
"insertwidth",
"maxundo",
"padx",
"pady",
"relief",
"selectbackground",
"selectborderwidth",
"selectforeground",
"setgrid",
"spacing1",
"spacing2",
"spacing3",
"startline",
"state",
"tabs",
"tabstyle",
"takefocus",
"undo",
"width",
"wrap",
"xscrollcommand",
"yscrollcommand",
]
class Text(Widget, XView, YView):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
autoseparators: bool = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
blockcursor: bool = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
endline: Union[int, Literal[""]] = ...,
exportselection: bool = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
# width is always int, but height is allowed to be ScreenUnits.
# This doesn't make any sense to me, and this isn't documented.
# The docs seem to say that both should be integers.
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
inactiveselectbackground: _Color = ...,
insertbackground: _Color = ...,
insertborderwidth: _ScreenUnits = ...,
insertofftime: int = ...,
insertontime: int = ...,
insertunfocussed: Literal["none", "hollow", "solid"] = ...,
insertwidth: _ScreenUnits = ...,
maxundo: int = ...,
name: str = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
setgrid: bool = ...,
spacing1: _ScreenUnits = ...,
spacing2: _ScreenUnits = ...,
spacing3: _ScreenUnits = ...,
startline: Union[int, Literal[""]] = ...,
state: Literal["normal", "disabled"] = ...,
# Literal inside Tuple doesn't actually work
tabs: Union[_ScreenUnits, str, Tuple[Union[_ScreenUnits, str], ...]] = ...,
tabstyle: Literal["tabular", "wordprocessor"] = ...,
takefocus: _TakeFocusValue = ...,
undo: bool = ...,
width: int = ...,
wrap: Literal["none", "char", "word"] = ...,
xscrollcommand: _XYScrollCommand = ...,
yscrollcommand: _XYScrollCommand = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
autoseparators: bool = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
blockcursor: bool = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
endline: Union[int, Literal[""]] = ...,
exportselection: bool = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
inactiveselectbackground: _Color = ...,
insertbackground: _Color = ...,
insertborderwidth: _ScreenUnits = ...,
insertofftime: int = ...,
insertontime: int = ...,
insertunfocussed: Literal["none", "hollow", "solid"] = ...,
insertwidth: _ScreenUnits = ...,
maxundo: int = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
setgrid: bool = ...,
spacing1: _ScreenUnits = ...,
spacing2: _ScreenUnits = ...,
spacing3: _ScreenUnits = ...,
startline: Union[int, Literal[""]] = ...,
state: Literal["normal", "disabled"] = ...,
tabs: Union[_ScreenUnits, str, Tuple[Union[_ScreenUnits, str], ...]] = ...,
tabstyle: Literal["tabular", "wordprocessor"] = ...,
takefocus: _TakeFocusValue = ...,
undo: bool = ...,
width: int = ...,
wrap: Literal["none", "char", "word"] = ...,
xscrollcommand: _XYScrollCommand = ...,
yscrollcommand: _XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _TextOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _TextOptionName) -> Any: ...
def bbox(self, index: _TextIndex) -> Optional[Tuple[int, int, int, int]]: ...
def compare(self, index1: _TextIndex, op: Literal["<", "<=", "==", ">=", ">", "!="], index2: _TextIndex) -> bool: ...
def count(self, index1, index2, *args): ... # TODO
@overload
def debug(self, boolean: None = ...) -> bool: ...
@overload
def debug(self, boolean: bool) -> None: ...
def delete(self, index1: _TextIndex, index2: Optional[_TextIndex] = ...) -> None: ...
def dlineinfo(self, index: _TextIndex) -> Optional[Tuple[int, int, int, int, int]]: ...
@overload
def dump(
self,
index1: _TextIndex,
index2: Optional[_TextIndex] = ...,
command: None = ...,
*,
all: bool = ...,
image: bool = ...,
mark: bool = ...,
tag: bool = ...,
text: bool = ...,
window: bool = ...,
) -> List[Tuple[str, str, str]]: ...
@overload
def dump(
self,
index1: _TextIndex,
index2: Optional[_TextIndex],
command: Union[Callable[[str, str, str], Any], str],
*,
all: bool = ...,
image: bool = ...,
mark: bool = ...,
tag: bool = ...,
text: bool = ...,
window: bool = ...,
) -> None: ...
@overload
def dump(
self,
index1: _TextIndex,
index2: Optional[_TextIndex] = ...,
*,
command: Union[Callable[[str, str, str], Any], str],
all: bool = ...,
image: bool = ...,
mark: bool = ...,
tag: bool = ...,
text: bool = ...,
window: bool = ...,
) -> None: ...
def edit(self, *args): ... # docstring says "Internal method"
@overload
def edit_modified(self, arg: None = ...) -> bool: ... # actually returns Literal[0, 1]
@overload
def edit_modified(self, arg: bool) -> None: ... # actually returns empty string
def edit_redo(self) -> None: ... # actually returns empty string
def edit_reset(self) -> None: ... # actually returns empty string
def edit_separator(self) -> None: ... # actually returns empty string
def edit_undo(self) -> None: ... # actually returns empty string
def get(self, index1: _TextIndex, index2: Optional[_TextIndex] = ...) -> str: ...
# TODO: image_* methods
def image_cget(self, index, option): ...
def image_configure(self, index, cnf: Optional[Any] = ..., **kw): ...
def image_create(self, index, cnf=..., **kw): ...
def image_names(self): ...
def index(self, index: _TextIndex) -> str: ...
def insert(self, index: _TextIndex, chars: str, *args: Union[_TextIndex, str, _TkinterSequence[str]]) -> None: ...
@overload
def mark_gravity(self, markName: str, direction: None = ...) -> Literal["left", "right"]: ...
@overload
def mark_gravity(self, markName: str, direction: Literal["left", "right"]) -> None: ... # actually returns empty string
def mark_names(self) -> Tuple[str, ...]: ...
def mark_set(self, markName: str, index: _TextIndex) -> None: ...
def mark_unset(self, *markNames: str) -> None: ...
def mark_next(self, index: _TextIndex) -> Optional[str]: ...
def mark_previous(self, index: _TextIndex): ...
# **kw of peer_create is same as the kwargs of Text.__init__
def peer_create(self, newPathName: Union[str, Text], cnf: Dict[str, Any] = ..., **kw: Any) -> None: ...
def peer_names(self) -> Tuple[_tkinter.Tcl_Obj, ...]: ...
def replace(
self, index1: _TextIndex, index2: _TextIndex, chars: str, *args: Union[_TextIndex, str, _TkinterSequence[str]]
) -> None: ...
def scan_mark(self, x: int, y: int) -> None: ...
def scan_dragto(self, x: int, y: int) -> None: ...
def search(
self,
pattern: str,
index: _TextIndex,
stopindex: Optional[_TextIndex] = ...,
forwards: Optional[bool] = ...,
backwards: Optional[bool] = ...,
exact: Optional[bool] = ...,
regexp: Optional[bool] = ...,
nocase: Optional[bool] = ...,
count: Optional[Variable] = ...,
elide: Optional[bool] = ...,
) -> str: ... # returns empty string for not found
def see(self, index: _TextIndex) -> None: ...
def tag_add(self, tagName: str, index1: _TextIndex, *args: _TextIndex) -> None: ...
# tag_bind stuff is very similar to Canvas
@overload
def tag_bind(
self,
tagName: str,
sequence: Optional[str],
func: Optional[Callable[[Event[Text]], Optional[Literal["break"]]]],
add: Optional[bool] = ...,
) -> str: ...
@overload
def tag_bind(self, tagName: str, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ...
def tag_unbind(self, tagName: str, sequence: str, funcid: Optional[str] = ...) -> None: ...
# allowing any string for cget instead of just Literals because there's no other way to look up tag options
def tag_cget(self, tagName: str, option: str) -> Any: ...
@overload
def tag_configure(
self,
tagName: str,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bgstipple: _Bitmap = ...,
borderwidth: _ScreenUnits = ...,
border: _ScreenUnits = ..., # alias for borderwidth
elide: bool = ...,
fgstipple: _Bitmap = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
justify: Literal["left", "right", "center"] = ...,
lmargin1: _ScreenUnits = ...,
lmargin2: _ScreenUnits = ...,
lmargincolor: _Color = ...,
offset: _ScreenUnits = ...,
overstrike: bool = ...,
overstrikefg: _Color = ...,
relief: _Relief = ...,
rmargin: _ScreenUnits = ...,
rmargincolor: _Color = ...,
selectbackground: _Color = ...,
selectforeground: _Color = ...,
spacing1: _ScreenUnits = ...,
spacing2: _ScreenUnits = ...,
spacing3: _ScreenUnits = ...,
tabs: Any = ..., # the exact type is kind of complicated, see manual page
tabstyle: Literal["tabular", "wordprocessor"] = ...,
underline: bool = ...,
underlinefg: _Color = ...,
wrap: Literal["none", "char", "word"] = ..., # be careful with "none" vs None
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def tag_configure(self, tagName: str, cnf: str) -> Tuple[str, str, str, Any, Any]: ...
tag_config = tag_configure
def tag_delete(self, __first_tag_name: str, *tagNames: str) -> None: ... # error if no tag names given
def tag_lower(self, tagName: str, belowThis: Optional[str] = ...) -> None: ...
def tag_names(self, index: Optional[_TextIndex] = ...) -> Tuple[str, ...]: ...
def tag_nextrange(
self, tagName: str, index1: _TextIndex, index2: Optional[_TextIndex] = ...
) -> Union[Tuple[str, str], Tuple[()]]: ...
def tag_prevrange(
self, tagName: str, index1: _TextIndex, index2: Optional[_TextIndex] = ...
) -> Union[Tuple[str, str], Tuple[()]]: ...
def tag_raise(self, tagName: str, aboveThis: Optional[str] = ...) -> None: ...
def tag_ranges(self, tagName: str) -> Tuple[_tkinter.Tcl_Obj, ...]: ...
# tag_remove and tag_delete are different
def tag_remove(self, tagName: str, index1: _TextIndex, index2: Optional[_TextIndex] = ...) -> None: ...
# TODO: window_* methods
def window_cget(self, index, option): ...
def window_configure(self, index, cnf: Optional[Any] = ..., **kw): ...
window_config = window_configure
def window_create(self, index, cnf=..., **kw): ...
def window_names(self): ...
def yview_pickplace(self, *what): ... # deprecated
class _setit:
def __init__(self, var, value, callback: Optional[Any] = ...): ...
def __call__(self, *args): ...
# manual page: tk_optionMenu
class OptionMenu(Menubutton):
widgetName: Any
menuname: Any
def __init__(
# differs from other widgets
self,
master: Optional[Misc],
variable: StringVar,
value: str,
*values: str,
# kwarg only from now on
command: Optional[Callable[[StringVar], Any]] = ...,
) -> None: ...
# configure, config, cget are inherited from Menubutton
# destroy and __getitem__ are overrided, signature does not change
class _Image(Protocol):
tk: _tkinter.TkappType
def __del__(self) -> None: ...
def height(self) -> int: ...
def width(self) -> int: ...
class Image:
name: Any
tk: _tkinter.TkappType
def __init__(
self, imgtype, name: Optional[Any] = ..., cnf=..., master: Optional[Union[Misc, _tkinter.TkappType]] = ..., **kw
): ...
def __del__(self): ...
def __setitem__(self, key, value): ...
def __getitem__(self, key): ...
def configure(self, **kw): ...
config: Any
def height(self): ...
def type(self): ...
def width(self): ...
class PhotoImage(Image):
def __init__(self, name: Optional[Any] = ..., cnf=..., master: Optional[Any] = ..., **kw): ...
def blank(self): ...
def cget(self, option): ...
def __getitem__(self, key): ...
def copy(self): ...
def zoom(self, x, y: str = ...): ...
def subsample(self, x, y: str = ...): ...
def get(self, x, y): ...
def put(self, data, to: Optional[Any] = ...): ...
def write(self, filename, format: Optional[Any] = ..., from_coords: Optional[Any] = ...): ...
if sys.version_info >= (3, 8):
def transparency_get(self, x: int, y: int) -> bool: ...
def transparency_set(self, x: int, y: int, boolean: bool) -> None: ...
class BitmapImage(Image):
def __init__(self, name: Optional[Any] = ..., cnf=..., master: Optional[Any] = ..., **kw): ...
def image_names(): ...
def image_types(): ...
_SpinboxOptionName = Literal[
"activebackground",
"background",
"bd",
"bg",
"border",
"borderwidth",
"buttonbackground",
"buttoncursor",
"buttondownrelief",
"buttonuprelief",
"command",
"cursor",
"disabledbackground",
"disabledforeground",
"exportselection",
"fg",
"font",
"foreground",
"format",
"from",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"increment",
"insertbackground",
"insertborderwidth",
"insertofftime",
"insertontime",
"insertwidth",
"invalidcommand",
"invcmd",
"justify",
"readonlybackground",
"relief",
"repeatdelay",
"repeatinterval",
"selectbackground",
"selectborderwidth",
"selectforeground",
"state",
"takefocus",
"textvariable",
"to",
"validate",
"validatecommand",
"vcmd",
"values",
"width",
"wrap",
"xscrollcommand",
]
class Spinbox(Widget, XView):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
buttonbackground: _Color = ...,
buttoncursor: _Cursor = ...,
buttondownrelief: _Relief = ...,
buttonuprelief: _Relief = ...,
# percent substitutions don't seem to be supported, it's similar to Entry's validion stuff
command: Union[Callable[[], Any], str, _TkinterSequence[str]] = ...,
cursor: _Cursor = ...,
disabledbackground: _Color = ...,
disabledforeground: _Color = ...,
exportselection: bool = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
format: str = ...,
from_: float = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
increment: float = ...,
insertbackground: _Color = ...,
insertborderwidth: _ScreenUnits = ...,
insertofftime: int = ...,
insertontime: int = ...,
insertwidth: _ScreenUnits = ...,
invalidcommand: _EntryValidateCommand = ...,
invcmd: _EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
name: str = ...,
readonlybackground: _Color = ...,
relief: _Relief = ...,
repeatdelay: int = ...,
repeatinterval: int = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
state: Literal["normal", "disabled", "readonly"] = ...,
takefocus: _TakeFocusValue = ...,
textvariable: Variable = ...,
to: float = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: _EntryValidateCommand = ...,
vcmd: _EntryValidateCommand = ...,
values: _TkinterSequence[str] = ...,
width: int = ...,
wrap: bool = ...,
xscrollcommand: _XYScrollCommand = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
activebackground: _Color = ...,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
buttonbackground: _Color = ...,
buttoncursor: _Cursor = ...,
buttondownrelief: _Relief = ...,
buttonuprelief: _Relief = ...,
command: Union[Callable[[], Any], str, _TkinterSequence[str]] = ...,
cursor: _Cursor = ...,
disabledbackground: _Color = ...,
disabledforeground: _Color = ...,
exportselection: bool = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
format: str = ...,
from_: float = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
increment: float = ...,
insertbackground: _Color = ...,
insertborderwidth: _ScreenUnits = ...,
insertofftime: int = ...,
insertontime: int = ...,
insertwidth: _ScreenUnits = ...,
invalidcommand: _EntryValidateCommand = ...,
invcmd: _EntryValidateCommand = ...,
justify: Literal["left", "center", "right"] = ...,
readonlybackground: _Color = ...,
relief: _Relief = ...,
repeatdelay: int = ...,
repeatinterval: int = ...,
selectbackground: _Color = ...,
selectborderwidth: _ScreenUnits = ...,
selectforeground: _Color = ...,
state: Literal["normal", "disabled", "readonly"] = ...,
takefocus: _TakeFocusValue = ...,
textvariable: Variable = ...,
to: float = ...,
validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
validatecommand: _EntryValidateCommand = ...,
vcmd: _EntryValidateCommand = ...,
values: _TkinterSequence[str] = ...,
width: int = ...,
wrap: bool = ...,
xscrollcommand: _XYScrollCommand = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _SpinboxOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _SpinboxOptionName) -> Any: ...
def bbox(self, index): ...
def delete(self, first, last: Optional[Any] = ...): ...
def get(self): ...
def icursor(self, index): ...
def identify(self, x, y): ...
def index(self, index): ...
def insert(self, index, s): ...
def invoke(self, element): ...
def scan(self, *args): ...
def scan_mark(self, x): ...
def scan_dragto(self, x): ...
def selection(self, *args: Any) -> Tuple[int, ...]: ...
def selection_adjust(self, index): ...
def selection_clear(self): ...
def selection_element(self, element: Optional[Any] = ...): ...
if sys.version_info >= (3, 8):
def selection_from(self, index: int) -> None: ...
def selection_present(self) -> None: ...
def selection_range(self, start: int, end: int) -> None: ...
def selection_to(self, index: int) -> None: ...
_LabelFrameOptionName = Literal[
"background",
"bd",
"bg",
"border",
"borderwidth",
"class",
"colormap",
"container",
"cursor",
"fg",
"font",
"foreground",
"height",
"highlightbackground",
"highlightcolor",
"highlightthickness",
"labelanchor",
"labelwidget",
"padx",
"pady",
"relief",
"takefocus",
"text",
"visual",
"width",
]
class LabelFrame(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
class_: str = ...,
colormap: Union[Literal["new", ""], Misc] = ...,
container: bool = ..., # undocumented
cursor: _Cursor = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
# 'ne' and 'en' are valid labelanchors, but only 'ne' is a valid _Anchor.
labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ...,
labelwidget: Misc = ...,
name: str = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
visual: Union[str, Tuple[str, int]] = ...,
width: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
fg: _Color = ...,
font: _FontDescription = ...,
foreground: _Color = ...,
height: _ScreenUnits = ...,
highlightbackground: _Color = ...,
highlightcolor: _Color = ...,
highlightthickness: _ScreenUnits = ...,
labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ...,
labelwidget: Misc = ...,
padx: _ScreenUnits = ...,
pady: _ScreenUnits = ...,
relief: _Relief = ...,
takefocus: _TakeFocusValue = ...,
text: str = ...,
width: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _LabelFrameOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _LabelFrameOptionName) -> Any: ...
_PanedWindowOptionName = Literal[
"background",
"bd",
"bg",
"border",
"borderwidth",
"cursor",
"handlepad",
"handlesize",
"height",
"opaqueresize",
"orient",
"proxybackground",
"proxyborderwidth",
"proxyrelief",
"relief",
"sashcursor",
"sashpad",
"sashrelief",
"sashwidth",
"showhandle",
"width",
]
class PanedWindow(Widget):
def __init__(
self,
master: Optional[Misc] = ...,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
handlepad: _ScreenUnits = ...,
handlesize: _ScreenUnits = ...,
height: _ScreenUnits = ...,
name: str = ...,
opaqueresize: bool = ...,
orient: Literal["horizontal", "vertical"] = ...,
proxybackground: _Color = ...,
proxyborderwidth: _ScreenUnits = ...,
proxyrelief: _Relief = ...,
relief: _Relief = ...,
sashcursor: _Cursor = ...,
sashpad: _ScreenUnits = ...,
sashrelief: _Relief = ...,
sashwidth: _ScreenUnits = ...,
showhandle: bool = ...,
width: _ScreenUnits = ...,
) -> None: ...
@overload
def configure(
self,
cnf: Optional[Dict[str, Any]] = ...,
*,
background: _Color = ...,
bd: _ScreenUnits = ...,
bg: _Color = ...,
border: _ScreenUnits = ...,
borderwidth: _ScreenUnits = ...,
cursor: _Cursor = ...,
handlepad: _ScreenUnits = ...,
handlesize: _ScreenUnits = ...,
height: _ScreenUnits = ...,
opaqueresize: bool = ...,
orient: Literal["horizontal", "vertical"] = ...,
proxybackground: _Color = ...,
proxyborderwidth: _ScreenUnits = ...,
proxyrelief: _Relief = ...,
relief: _Relief = ...,
sashcursor: _Cursor = ...,
sashpad: _ScreenUnits = ...,
sashrelief: _Relief = ...,
sashwidth: _ScreenUnits = ...,
showhandle: bool = ...,
width: _ScreenUnits = ...,
) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ...
@overload
def configure(self, cnf: _PanedWindowOptionName) -> Tuple[str, str, str, Any, Any]: ...
config = configure
def cget(self, key: _PanedWindowOptionName) -> Any: ...
def add(self, child, **kw): ...
def remove(self, child): ...
forget: Any
def identify(self, x, y): ...
def proxy(self, *args): ...
def proxy_coord(self): ...
def proxy_forget(self): ...
def proxy_place(self, x, y): ...
def sash(self, *args): ...
def sash_coord(self, index): ...
def sash_mark(self, index): ...
def sash_place(self, index, x, y): ...
def panecget(self, child, option): ...
def paneconfigure(self, tagOrId, cnf: Optional[Any] = ..., **kw): ...
paneconfig: Any
def panes(self): ...
| 110,919 | Python | .py | 3,198 | 28.054722 | 127 | 0.551267 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,418 | constants.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tkinter/constants.pyi | from typing_extensions import Literal
# These are not actually bools. See #4669
NO: bool
YES: bool
TRUE: bool
FALSE: bool
ON: bool
OFF: bool
N: Literal["n"]
S: Literal["s"]
W: Literal["w"]
E: Literal["e"]
NW: Literal["nw"]
SW: Literal["sw"]
NE: Literal["ne"]
SE: Literal["se"]
NS: Literal["ns"]
EW: Literal["ew"]
NSEW: Literal["nsew"]
CENTER: Literal["center"]
NONE: Literal["none"]
X: Literal["x"]
Y: Literal["y"]
BOTH: Literal["both"]
LEFT: Literal["left"]
TOP: Literal["top"]
RIGHT: Literal["right"]
BOTTOM: Literal["bottom"]
RAISED: Literal["raised"]
SUNKEN: Literal["sunken"]
FLAT: Literal["flat"]
RIDGE: Literal["ridge"]
GROOVE: Literal["groove"]
SOLID: Literal["solid"]
HORIZONTAL: Literal["horizontal"]
VERTICAL: Literal["vertical"]
NUMERIC: Literal["numeric"]
CHAR: Literal["char"]
WORD: Literal["word"]
BASELINE: Literal["baseline"]
INSIDE: Literal["inside"]
OUTSIDE: Literal["outside"]
SEL: Literal["sel"]
SEL_FIRST: Literal["sel.first"]
SEL_LAST: Literal["sel.last"]
END: Literal["end"]
INSERT: Literal["insert"]
CURRENT: Literal["current"]
ANCHOR: Literal["anchor"]
ALL: Literal["all"]
NORMAL: Literal["normal"]
DISABLED: Literal["disabled"]
ACTIVE: Literal["active"]
HIDDEN: Literal["hidden"]
CASCADE: Literal["cascade"]
CHECKBUTTON: Literal["checkbutton"]
COMMAND: Literal["command"]
RADIOBUTTON: Literal["radiobutton"]
SEPARATOR: Literal["separator"]
SINGLE: Literal["single"]
BROWSE: Literal["browse"]
MULTIPLE: Literal["multiple"]
EXTENDED: Literal["extended"]
DOTBOX: Literal["dotbox"]
UNDERLINE: Literal["underline"]
PIESLICE: Literal["pieslice"]
CHORD: Literal["chord"]
ARC: Literal["arc"]
FIRST: Literal["first"]
LAST: Literal["last"]
BUTT: Literal["butt"]
PROJECTING: Literal["projecting"]
ROUND: Literal["round"]
BEVEL: Literal["bevel"]
MITER: Literal["miter"]
MOVETO: Literal["moveto"]
SCROLL: Literal["scroll"]
UNITS: Literal["units"]
PAGES: Literal["pages"]
| 1,886 | Python | .py | 79 | 22.860759 | 41 | 0.747508 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,419 | commondialog.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tkinter/commondialog.pyi | from typing import Any, Mapping, Optional
class Dialog:
command: Optional[Any] = ...
master: Optional[Any] = ...
options: Mapping[str, Any] = ...
def __init__(self, master: Optional[Any] = ..., **options) -> None: ...
def show(self, **options) -> Any: ...
| 277 | Python | .py | 7 | 35.571429 | 75 | 0.594796 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,420 | font.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/tkinter/font.pyi | import tkinter
from typing import Any, List, Optional, Tuple, TypeVar, Union, overload
from typing_extensions import Literal, TypedDict
NORMAL: Literal["normal"]
ROMAN: Literal["roman"]
BOLD: Literal["bold"]
ITALIC: Literal["italic"]
def nametofont(name: str) -> Font: ...
# See 'FONT DESCRIPTIONS' in font man page. This uses str because Literal
# inside Tuple doesn't work.
_FontDescription = Union[str, Font, Tuple[str, int], Tuple[str, int, str], Tuple[str, int, tkinter._TkinterSequence[str]]]
class _FontDict(TypedDict):
family: str
size: int
weight: Literal["normal", "bold"]
slant: Literal["roman", "italic"]
underline: Literal[0, 1]
overstrike: Literal[0, 1]
class _MetricsDict(TypedDict):
ascent: int
descent: int
linespace: int
fixed: Literal[0, 1]
class Font:
name: str
delete_font: bool
def __init__(
self,
# In tkinter, 'root' refers to tkinter.Tk by convention, but the code
# actually works with any tkinter widget so we use tkinter.Misc.
root: Optional[tkinter.Misc] = ...,
font: Optional[_FontDescription] = ...,
name: Optional[str] = ...,
exists: bool = ...,
*,
family: str = ...,
size: int = ...,
weight: Literal["normal", "bold"] = ...,
slant: Literal["roman", "italic"] = ...,
underline: bool = ...,
overstrike: bool = ...,
) -> None: ...
def __getitem__(self, key: str) -> Any: ...
def __setitem__(self, key: str, value: Any) -> None: ...
@overload
def cget(self, option: Literal["family"]) -> str: ...
@overload
def cget(self, option: Literal["size"]) -> int: ...
@overload
def cget(self, option: Literal["weight"]) -> Literal["normal", "bold"]: ...
@overload
def cget(self, option: Literal["slant"]) -> Literal["roman", "italic"]: ...
@overload
def cget(self, option: Literal["underline", "overstrike"]) -> Literal[0, 1]: ...
@overload
def actual(self, option: Literal["family"], displayof: Optional[tkinter.Misc] = ...) -> str: ...
@overload
def actual(self, option: Literal["size"], displayof: Optional[tkinter.Misc] = ...) -> int: ...
@overload
def actual(self, option: Literal["weight"], displayof: Optional[tkinter.Misc] = ...) -> Literal["normal", "bold"]: ...
@overload
def actual(self, option: Literal["slant"], displayof: Optional[tkinter.Misc] = ...) -> Literal["roman", "italic"]: ...
@overload
def actual(self, option: Literal["underline", "overstrike"], displayof: Optional[tkinter.Misc] = ...) -> Literal[0, 1]: ...
@overload
def actual(self, option: None, displayof: Optional[tkinter.Misc] = ...) -> _FontDict: ...
@overload
def actual(self, *, displayof: Optional[tkinter.Misc] = ...) -> _FontDict: ...
def config(
self,
*,
family: str = ...,
size: int = ...,
weight: Literal["normal", "bold"] = ...,
slant: Literal["roman", "italic"] = ...,
underline: bool = ...,
overstrike: bool = ...,
) -> Optional[_FontDict]: ...
configure = config
def copy(self) -> Font: ...
@overload
def metrics(self, __option: Literal["ascent", "descent", "linespace"], *, displayof: Optional[tkinter.Misc] = ...) -> int: ...
@overload
def metrics(self, __option: Literal["fixed"], *, displayof: Optional[tkinter.Misc] = ...) -> Literal[0, 1]: ...
@overload
def metrics(self, *, displayof: Optional[tkinter.Misc] = ...) -> _MetricsDict: ...
def measure(self, text: str, displayof: Optional[tkinter.Misc] = ...) -> int: ...
def families(root: Optional[tkinter.Misc] = ..., displayof: Optional[tkinter.Misc] = ...) -> Tuple[str, ...]: ...
def names(root: Optional[tkinter.Misc] = ...) -> Tuple[str, ...]: ...
| 3,812 | Python | .py | 89 | 37.483146 | 130 | 0.60226 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,421 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/dbm/__init__.pyi | from types import TracebackType
from typing import Iterator, MutableMapping, Optional, Type, Union
from typing_extensions import Literal
_KeyType = Union[str, bytes]
_ValueType = Union[str, bytes]
class _Database(MutableMapping[_KeyType, bytes]):
def close(self) -> None: ...
def __getitem__(self, key: _KeyType) -> bytes: ...
def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
def __delitem__(self, key: _KeyType) -> None: ...
def __iter__(self) -> Iterator[bytes]: ...
def __len__(self) -> int: ...
def __del__(self) -> None: ...
def __enter__(self) -> _Database: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> None: ...
class error(Exception): ...
def whichdb(filename: str) -> str: ...
def open(file: str, flag: Literal["r", "w", "c", "n"] = ..., mode: int = ...) -> _Database: ...
| 945 | Python | .py | 20 | 43.65 | 120 | 0.618893 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,422 | ndbm.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/dbm/ndbm.pyi | from types import TracebackType
from typing import List, Optional, Type, TypeVar, Union, overload
_T = TypeVar("_T")
_KeyType = Union[str, bytes]
_ValueType = Union[str, bytes]
class error(OSError): ...
library: str = ...
# Actual typename dbm, not exposed by the implementation
class _dbm:
def close(self) -> None: ...
def __getitem__(self, item: _KeyType) -> bytes: ...
def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
def __delitem__(self, key: _KeyType) -> None: ...
def __len__(self) -> int: ...
def __del__(self) -> None: ...
def __enter__(self) -> _dbm: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> None: ...
@overload
def get(self, k: _KeyType) -> Optional[bytes]: ...
@overload
def get(self, k: _KeyType, default: Union[bytes, _T]) -> Union[bytes, _T]: ...
def keys(self) -> List[bytes]: ...
def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
# Don't exist at runtime
__new__: None # type: ignore
__init__: None # type: ignore
def open(__filename: str, __flags: str = ..., __mode: int = ...) -> _dbm: ...
| 1,236 | Python | .py | 29 | 38.689655 | 120 | 0.59817 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,423 | gnu.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/dbm/gnu.pyi | from types import TracebackType
from typing import List, Optional, Type, TypeVar, Union, overload
_T = TypeVar("_T")
_KeyType = Union[str, bytes]
_ValueType = Union[str, bytes]
class error(OSError): ...
# Actual typename gdbm, not exposed by the implementation
class _gdbm:
def firstkey(self) -> Optional[bytes]: ...
def nextkey(self, key: _KeyType) -> Optional[bytes]: ...
def reorganize(self) -> None: ...
def sync(self) -> None: ...
def close(self) -> None: ...
def __getitem__(self, item: _KeyType) -> bytes: ...
def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
def __delitem__(self, key: _KeyType) -> None: ...
def __len__(self) -> int: ...
def __enter__(self) -> _gdbm: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> None: ...
@overload
def get(self, k: _KeyType) -> Optional[bytes]: ...
@overload
def get(self, k: _KeyType, default: Union[bytes, _T]) -> Union[bytes, _T]: ...
def keys(self) -> List[bytes]: ...
def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
# Don't exist at runtime
__new__: None # type: ignore
__init__: None # type: ignore
def open(__filename: str, __flags: str = ..., __mode: int = ...) -> _gdbm: ...
| 1,363 | Python | .py | 31 | 39.870968 | 120 | 0.60241 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,424 | dumb.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/dbm/dumb.pyi | from types import TracebackType
from typing import Iterator, MutableMapping, Optional, Type, Union
_KeyType = Union[str, bytes]
_ValueType = Union[str, bytes]
error = OSError
class _Database(MutableMapping[_KeyType, bytes]):
def __init__(self, filebasename: str, mode: str, flag: str = ...) -> None: ...
def sync(self) -> None: ...
def iterkeys(self) -> Iterator[bytes]: ... # undocumented
def close(self) -> None: ...
def __getitem__(self, key: _KeyType) -> bytes: ...
def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
def __delitem__(self, key: _KeyType) -> None: ...
def __iter__(self) -> Iterator[bytes]: ...
def __len__(self) -> int: ...
def __del__(self) -> None: ...
def __enter__(self) -> _Database: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> None: ...
def open(file: str, flag: str = ..., mode: int = ...) -> _Database: ...
| 1,010 | Python | .py | 21 | 44.047619 | 120 | 0.606091 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,425 | process.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/concurrent/futures/process.pyi | import sys
from typing import Any, Callable, Optional, Tuple
from ._base import Executor
EXTRA_QUEUED_CALLS: Any
if sys.version_info >= (3, 7):
from ._base import BrokenExecutor
class BrokenProcessPool(BrokenExecutor): ...
else:
class BrokenProcessPool(RuntimeError): ...
if sys.version_info >= (3, 7):
from multiprocessing.context import BaseContext
class ProcessPoolExecutor(Executor):
def __init__(
self,
max_workers: Optional[int] = ...,
mp_context: Optional[BaseContext] = ...,
initializer: Optional[Callable[..., None]] = ...,
initargs: Tuple[Any, ...] = ...,
) -> None: ...
else:
class ProcessPoolExecutor(Executor):
def __init__(self, max_workers: Optional[int] = ...) -> None: ...
| 804 | Python | .py | 22 | 30.363636 | 73 | 0.626289 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,426 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/concurrent/futures/__init__.pyi | import sys
from ._base import (
ALL_COMPLETED as ALL_COMPLETED,
FIRST_COMPLETED as FIRST_COMPLETED,
FIRST_EXCEPTION as FIRST_EXCEPTION,
CancelledError as CancelledError,
Executor as Executor,
Future as Future,
TimeoutError as TimeoutError,
as_completed as as_completed,
wait as wait,
)
from .process import ProcessPoolExecutor as ProcessPoolExecutor
from .thread import ThreadPoolExecutor as ThreadPoolExecutor
if sys.version_info >= (3, 8):
from ._base import InvalidStateError as InvalidStateError
if sys.version_info >= (3, 7):
from ._base import BrokenExecutor as BrokenExecutor
| 629 | Python | .py | 18 | 31.388889 | 63 | 0.775041 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,427 | thread.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/concurrent/futures/thread.pyi | import queue
import sys
from typing import Any, Callable, Generic, Iterable, Mapping, Optional, Tuple, TypeVar
from ._base import Executor, Future
if sys.version_info >= (3, 7):
from ._base import BrokenExecutor
class BrokenThreadPool(BrokenExecutor): ...
if sys.version_info >= (3, 9):
from types import GenericAlias
_S = TypeVar("_S")
class ThreadPoolExecutor(Executor):
if sys.version_info >= (3, 7):
_work_queue: queue.SimpleQueue
else:
_work_queue: queue.Queue
if sys.version_info >= (3, 7):
def __init__(
self,
max_workers: Optional[int] = ...,
thread_name_prefix: str = ...,
initializer: Optional[Callable[..., None]] = ...,
initargs: Tuple[Any, ...] = ...,
) -> None: ...
elif sys.version_info >= (3, 6):
def __init__(self, max_workers: Optional[int] = ..., thread_name_prefix: str = ...) -> None: ...
else:
def __init__(self, max_workers: Optional[int] = ...) -> None: ...
class _WorkItem(Generic[_S]):
future: Future[_S]
fn: Callable[..., _S]
args: Iterable[Any]
kwargs: Mapping[str, Any]
def __init__(self, future: Future[_S], fn: Callable[..., _S], args: Iterable[Any], kwargs: Mapping[str, Any]) -> None: ...
def run(self) -> None: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
| 1,421 | Python | .py | 36 | 33.416667 | 126 | 0.583756 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,428 | _base.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/concurrent/futures/_base.pyi | import sys
import threading
from abc import abstractmethod
from logging import Logger
from typing import (
Any,
Callable,
Container,
Generic,
Iterable,
Iterator,
List,
Optional,
Protocol,
Sequence,
Set,
TypeVar,
overload,
)
if sys.version_info >= (3, 9):
from types import GenericAlias
FIRST_COMPLETED: str
FIRST_EXCEPTION: str
ALL_COMPLETED: str
PENDING: str
RUNNING: str
CANCELLED: str
CANCELLED_AND_NOTIFIED: str
FINISHED: str
LOGGER: Logger
class Error(Exception): ...
class CancelledError(Error): ...
class TimeoutError(Error): ...
if sys.version_info >= (3, 8):
class InvalidStateError(Error): ...
if sys.version_info >= (3, 7):
class BrokenExecutor(RuntimeError): ...
_T = TypeVar("_T")
_T_co = TypeVar("_T_co", covariant=True)
# Copied over Collection implementation as it does not exist in Python 2 and <3.6.
# Also to solve pytype issues with _Collection.
class _Collection(Iterable[_T_co], Container[_T_co], Protocol[_T_co]):
# Implement Sized (but don't have it as a base class).
@abstractmethod
def __len__(self) -> int: ...
class Future(Generic[_T]):
def __init__(self) -> None: ...
def cancel(self) -> bool: ...
def cancelled(self) -> bool: ...
def running(self) -> bool: ...
def done(self) -> bool: ...
def add_done_callback(self, fn: Callable[[Future[_T]], Any]) -> None: ...
def result(self, timeout: Optional[float] = ...) -> _T: ...
def set_running_or_notify_cancel(self) -> bool: ...
def set_result(self, result: _T) -> None: ...
def exception(self, timeout: Optional[float] = ...) -> Optional[BaseException]: ...
def set_exception(self, exception: Optional[BaseException]) -> None: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class Executor:
if sys.version_info >= (3, 9):
def submit(self, __fn: Callable[..., _T], *args: Any, **kwargs: Any) -> Future[_T]: ...
else:
def submit(self, fn: Callable[..., _T], *args: Any, **kwargs: Any) -> Future[_T]: ...
def map(
self, fn: Callable[..., _T], *iterables: Iterable[Any], timeout: Optional[float] = ..., chunksize: int = ...
) -> Iterator[_T]: ...
if sys.version_info >= (3, 9):
def shutdown(self, wait: bool = ..., *, cancel_futures: bool = ...) -> None: ...
else:
def shutdown(self, wait: bool = ...) -> None: ...
def __enter__(self: _T) -> _T: ...
def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Optional[bool]: ...
def as_completed(fs: Iterable[Future[_T]], timeout: Optional[float] = ...) -> Iterator[Future[_T]]: ...
# Ideally this would be a namedtuple, but mypy doesn't support generic tuple types. See #1976
class DoneAndNotDoneFutures(Sequence[_T]):
done: Set[Future[_T]]
not_done: Set[Future[_T]]
def __new__(_cls, done: Set[Future[_T]], not_done: Set[Future[_T]]) -> DoneAndNotDoneFutures[_T]: ...
def __len__(self) -> int: ...
@overload
def __getitem__(self, i: int) -> _T: ...
@overload
def __getitem__(self, s: slice) -> DoneAndNotDoneFutures[_T]: ...
def wait(fs: Iterable[Future[_T]], timeout: Optional[float] = ..., return_when: str = ...) -> DoneAndNotDoneFutures[_T]: ...
class _Waiter:
event: threading.Event
finished_futures: List[Future[Any]]
def __init__(self) -> None: ...
def add_result(self, future: Future[Any]) -> None: ...
def add_exception(self, future: Future[Any]) -> None: ...
def add_cancelled(self, future: Future[Any]) -> None: ...
class _AsCompletedWaiter(_Waiter):
lock: threading.Lock
def __init__(self) -> None: ...
def add_result(self, future: Future[Any]) -> None: ...
def add_exception(self, future: Future[Any]) -> None: ...
def add_cancelled(self, future: Future[Any]) -> None: ...
class _FirstCompletedWaiter(_Waiter):
def add_result(self, future: Future[Any]) -> None: ...
def add_exception(self, future: Future[Any]) -> None: ...
def add_cancelled(self, future: Future[Any]) -> None: ...
class _AllCompletedWaiter(_Waiter):
num_pending_calls: int
stop_on_exception: bool
lock: threading.Lock
def __init__(self, num_pending_calls: int, stop_on_exception: bool) -> None: ...
def add_result(self, future: Future[Any]) -> None: ...
def add_exception(self, future: Future[Any]) -> None: ...
def add_cancelled(self, future: Future[Any]) -> None: ...
class _AcquireFutures:
futures: Iterable[Future[Any]]
def __init__(self, futures: Iterable[Future[Any]]) -> None: ...
def __enter__(self) -> None: ...
def __exit__(self, *args: Any) -> None: ...
| 4,676 | Python | .py | 115 | 36.582609 | 124 | 0.624917 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,429 | contentmanager.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/contentmanager.pyi | from email.message import Message
from typing import Any, Callable
class ContentManager:
def __init__(self) -> None: ...
def get_content(self, msg: Message, *args: Any, **kw: Any) -> Any: ...
def set_content(self, msg: Message, obj: Any, *args: Any, **kw: Any) -> Any: ...
def add_get_handler(self, key: str, handler: Callable[..., Any]) -> None: ...
def add_set_handler(self, typekey: type, handler: Callable[..., Any]) -> None: ...
raw_data_manager: ContentManager
| 489 | Python | .py | 9 | 50.888889 | 86 | 0.646444 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,430 | utils.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/utils.pyi | import datetime
import sys
from email.charset import Charset
from typing import List, Optional, Tuple, Union, overload
_ParamType = Union[str, Tuple[Optional[str], Optional[str], str]]
_PDTZ = Tuple[int, int, int, int, int, int, int, int, int, Optional[int]]
def quote(str: str) -> str: ...
def unquote(str: str) -> str: ...
def parseaddr(address: Optional[str]) -> Tuple[str, str]: ...
def formataddr(pair: Tuple[Optional[str], str], charset: Union[str, Charset] = ...) -> str: ...
def getaddresses(fieldvalues: List[str]) -> List[Tuple[str, str]]: ...
@overload
def parsedate(date: None) -> None: ...
@overload
def parsedate(date: str) -> Optional[Tuple[int, int, int, int, int, int, int, int, int]]: ...
@overload
def parsedate_tz(date: None) -> None: ...
@overload
def parsedate_tz(date: str) -> Optional[_PDTZ]: ...
if sys.version_info >= (3, 10):
@overload
def parsedate_to_datetime(date: None) -> None: ...
@overload
def parsedate_to_datetime(date: str) -> datetime.datetime: ...
else:
def parsedate_to_datetime(date: str) -> datetime.datetime: ...
def mktime_tz(tuple: _PDTZ) -> int: ...
def formatdate(timeval: Optional[float] = ..., localtime: bool = ..., usegmt: bool = ...) -> str: ...
def format_datetime(dt: datetime.datetime, usegmt: bool = ...) -> str: ...
def localtime(dt: Optional[datetime.datetime] = ...) -> datetime.datetime: ...
def make_msgid(idstring: Optional[str] = ..., domain: Optional[str] = ...) -> str: ...
def decode_rfc2231(s: str) -> Tuple[Optional[str], Optional[str], str]: ...
def encode_rfc2231(s: str, charset: Optional[str] = ..., language: Optional[str] = ...) -> str: ...
def collapse_rfc2231_value(value: _ParamType, errors: str = ..., fallback_charset: str = ...) -> str: ...
def decode_params(params: List[Tuple[str, str]]) -> List[Tuple[str, _ParamType]]: ...
| 1,832 | Python | .py | 35 | 50.628571 | 105 | 0.660714 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,431 | headerregistry.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/headerregistry.pyi | from datetime import datetime as _datetime
from email.errors import MessageDefect
from email.policy import Policy
from typing import Any, Dict, Mapping, Optional, Tuple, Union
class BaseHeader(str):
@property
def name(self) -> str: ...
@property
def defects(self) -> Tuple[MessageDefect, ...]: ...
@property
def max_count(self) -> Optional[int]: ...
def __new__(cls, name: str, value: Any) -> BaseHeader: ...
def init(self, *args: Any, **kw: Any) -> None: ...
def fold(self, *, policy: Policy) -> str: ...
class UnstructuredHeader:
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class UniqueUnstructuredHeader(UnstructuredHeader): ...
class DateHeader:
datetime: _datetime
@classmethod
def parse(cls, string: Union[str, _datetime], kwds: Dict[str, Any]) -> None: ...
class UniqueDateHeader(DateHeader): ...
class AddressHeader:
groups: Tuple[Group, ...]
addresses: Tuple[Address, ...]
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class UniqueAddressHeader(AddressHeader): ...
class SingleAddressHeader(AddressHeader):
@property
def address(self) -> Address: ...
class UniqueSingleAddressHeader(SingleAddressHeader): ...
class MIMEVersionHeader:
version: Optional[str]
major: Optional[int]
minor: Optional[int]
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class ParameterizedMIMEHeader:
params: Mapping[str, Any]
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class ContentTypeHeader(ParameterizedMIMEHeader):
content_type: str
maintype: str
subtype: str
class ContentDispositionHeader(ParameterizedMIMEHeader):
content_disposition: str
class ContentTransferEncodingHeader:
cte: str
@classmethod
def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
class HeaderRegistry:
def __init__(self, base_class: BaseHeader = ..., default_class: BaseHeader = ..., use_default_map: bool = ...) -> None: ...
def map_to_type(self, name: str, cls: BaseHeader) -> None: ...
def __getitem__(self, name: str) -> BaseHeader: ...
def __call__(self, name: str, value: Any) -> BaseHeader: ...
class Address:
display_name: str
username: str
domain: str
@property
def addr_spec(self) -> str: ...
def __init__(
self, display_name: str = ..., username: Optional[str] = ..., domain: Optional[str] = ..., addr_spec: Optional[str] = ...
) -> None: ...
def __str__(self) -> str: ...
class Group:
display_name: Optional[str]
addresses: Tuple[Address, ...]
def __init__(self, display_name: Optional[str] = ..., addresses: Optional[Tuple[Address, ...]] = ...) -> None: ...
def __str__(self) -> str: ...
| 2,828 | Python | .py | 73 | 34.60274 | 129 | 0.658875 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,432 | feedparser.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/feedparser.pyi | from email.message import Message
from email.policy import Policy
from typing import Callable, Generic, TypeVar, overload
_M = TypeVar("_M", bound=Message)
class FeedParser(Generic[_M]):
@overload
def __init__(self: FeedParser[Message], _factory: None = ..., *, policy: Policy = ...) -> None: ...
@overload
def __init__(self, _factory: Callable[[], _M], *, policy: Policy = ...) -> None: ...
def feed(self, data: str) -> None: ...
def close(self) -> _M: ...
class BytesFeedParser(Generic[_M]):
@overload
def __init__(self: BytesFeedParser[Message], _factory: None = ..., *, policy: Policy = ...) -> None: ...
@overload
def __init__(self, _factory: Callable[[], _M], *, policy: Policy = ...) -> None: ...
def feed(self, data: bytes) -> None: ...
def close(self) -> _M: ...
| 823 | Python | .py | 18 | 41.888889 | 108 | 0.597257 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,433 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/__init__.pyi | from email.message import Message
from email.policy import Policy
from typing import IO, Callable
def message_from_string(s: str, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
def message_from_bytes(s: bytes, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
def message_from_file(fp: IO[str], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
def message_from_binary_file(fp: IO[bytes], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
# Names in __all__ with no definition:
# base64mime
# charset
# encoders
# errors
# feedparser
# generator
# header
# iterators
# message
# mime
# parser
# quoprimime
# utils
| 757 | Python | .py | 21 | 34.952381 | 121 | 0.637602 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,434 | iterators.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/iterators.pyi | from email.message import Message
from typing import Iterator, Optional
def body_line_iterator(msg: Message, decode: bool = ...) -> Iterator[str]: ...
def typed_subpart_iterator(msg: Message, maintype: str = ..., subtype: Optional[str] = ...) -> Iterator[str]: ...
| 266 | Python | .py | 4 | 65.25 | 113 | 0.704981 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,435 | parser.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/parser.pyi | import email.feedparser
from email.message import Message
from email.policy import Policy
from typing import BinaryIO, Callable, TextIO
FeedParser = email.feedparser.FeedParser
BytesFeedParser = email.feedparser.BytesFeedParser
class Parser:
def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ...
def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
class HeaderParser(Parser):
def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ...
def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
class BytesHeaderParser(BytesParser):
def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ...
def parsebytes(self, text: bytes, headersonly: bool = ...) -> Message: ...
class BytesParser:
def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ...
def parsebytes(self, text: bytes, headersonly: bool = ...) -> Message: ...
| 1,328 | Python | .py | 22 | 56.954545 | 97 | 0.631822 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,436 | encoders.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/encoders.pyi | from email.message import Message
def encode_base64(msg: Message) -> None: ...
def encode_quopri(msg: Message) -> None: ...
def encode_7or8bit(msg: Message) -> None: ...
def encode_noop(msg: Message) -> None: ...
| 214 | Python | .py | 5 | 41.6 | 45 | 0.692308 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,437 | errors.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/errors.pyi | class MessageError(Exception): ...
class MessageParseError(MessageError): ...
class HeaderParseError(MessageParseError): ...
class BoundaryError(MessageParseError): ...
class MultipartConversionError(MessageError, TypeError): ...
class MessageDefect(ValueError): ...
class NoBoundaryInMultipartDefect(MessageDefect): ...
class StartBoundaryNotFoundDefect(MessageDefect): ...
class FirstHeaderLineIsContinuationDefect(MessageDefect): ...
class MisplacedEnvelopeHeaderDefect(MessageDefect): ...
class MultipartInvariantViolationDefect(MessageDefect): ...
class InvalidBase64PaddingDefect(MessageDefect): ...
class InvalidBase64CharactersDefect(MessageDefect): ...
class CloseBoundaryNotFoundDefect(MessageDefect): ...
class MissingHeaderBodySeparatorDefect(MessageDefect): ...
MalformedHeaderDefect = MissingHeaderBodySeparatorDefect
| 833 | Python | .py | 16 | 51 | 61 | 0.846814 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,438 | generator.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/generator.pyi | from email.message import Message
from email.policy import Policy
from typing import BinaryIO, Optional, TextIO
class Generator:
def clone(self, fp: TextIO) -> Generator: ...
def write(self, s: str) -> None: ...
def __init__(self, outfp: TextIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, policy: Policy = ...) -> None: ...
def flatten(self, msg: Message, unixfrom: bool = ..., linesep: Optional[str] = ...) -> None: ...
class BytesGenerator:
def clone(self, fp: BinaryIO) -> BytesGenerator: ...
def write(self, s: str) -> None: ...
def __init__(self, outfp: BinaryIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, policy: Policy = ...) -> None: ...
def flatten(self, msg: Message, unixfrom: bool = ..., linesep: Optional[str] = ...) -> None: ...
class DecodedGenerator(Generator):
def __init__(self, outfp: TextIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, fmt: Optional[str] = ...) -> None: ...
| 967 | Python | .py | 15 | 60.866667 | 130 | 0.614331 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,439 | policy.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/policy.pyi | from abc import abstractmethod
from email.contentmanager import ContentManager
from email.errors import MessageDefect
from email.header import Header
from email.message import Message
from typing import Any, Callable, List, Optional, Tuple, Union
class Policy:
max_line_length: Optional[int]
linesep: str
cte_type: str
raise_on_defect: bool
mange_from: bool
def __init__(self, **kw: Any) -> None: ...
def clone(self, **kw: Any) -> Policy: ...
def handle_defect(self, obj: Message, defect: MessageDefect) -> None: ...
def register_defect(self, obj: Message, defect: MessageDefect) -> None: ...
def header_max_count(self, name: str) -> Optional[int]: ...
@abstractmethod
def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ...
@abstractmethod
def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ...
@abstractmethod
def header_fetch_parse(self, name: str, value: str) -> str: ...
@abstractmethod
def fold(self, name: str, value: str) -> str: ...
@abstractmethod
def fold_binary(self, name: str, value: str) -> bytes: ...
class Compat32(Policy):
def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ...
def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ...
def header_fetch_parse(self, name: str, value: str) -> Union[str, Header]: ... # type: ignore
def fold(self, name: str, value: str) -> str: ...
def fold_binary(self, name: str, value: str) -> bytes: ...
compat32: Compat32
class EmailPolicy(Policy):
utf8: bool
refold_source: str
header_factory: Callable[[str, str], str]
content_manager: ContentManager
def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ...
def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ...
def header_fetch_parse(self, name: str, value: str) -> str: ...
def fold(self, name: str, value: str) -> str: ...
def fold_binary(self, name: str, value: str) -> bytes: ...
default: EmailPolicy
SMTP: EmailPolicy
SMTPUTF8: EmailPolicy
HTTP: EmailPolicy
strict: EmailPolicy
| 2,159 | Python | .py | 49 | 40.183673 | 98 | 0.675534 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,440 | charset.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/charset.pyi | from typing import Any, Iterator, List, Optional
QP: int # undocumented
BASE64: int # undocumented
SHORTEST: int # undocumented
class Charset:
input_charset: str
header_encoding: int
body_encoding: int
output_charset: Optional[str]
input_codec: Optional[str]
output_codec: Optional[str]
def __init__(self, input_charset: str = ...) -> None: ...
def get_body_encoding(self) -> str: ...
def get_output_charset(self) -> Optional[str]: ...
def header_encode(self, string: str) -> str: ...
def header_encode_lines(self, string: str, maxlengths: Iterator[int]) -> List[str]: ...
def body_encode(self, string: str) -> str: ...
def __str__(self) -> str: ...
def __eq__(self, other: Any) -> bool: ...
def __ne__(self, other: Any) -> bool: ...
def add_charset(
charset: str, header_enc: Optional[int] = ..., body_enc: Optional[int] = ..., output_charset: Optional[str] = ...
) -> None: ...
def add_alias(alias: str, canonical: str) -> None: ...
def add_codec(charset: str, codecname: str) -> None: ...
| 1,062 | Python | .py | 25 | 38.8 | 117 | 0.630561 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,441 | header.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/header.pyi | from email.charset import Charset
from typing import Any, List, Optional, Tuple, Union
class Header:
def __init__(
self,
s: Union[bytes, str, None] = ...,
charset: Union[Charset, str, None] = ...,
maxlinelen: Optional[int] = ...,
header_name: Optional[str] = ...,
continuation_ws: str = ...,
errors: str = ...,
) -> None: ...
def append(self, s: Union[bytes, str], charset: Union[Charset, str, None] = ..., errors: str = ...) -> None: ...
def encode(self, splitchars: str = ..., maxlinelen: Optional[int] = ..., linesep: str = ...) -> str: ...
def __str__(self) -> str: ...
def __eq__(self, other: Any) -> bool: ...
def __ne__(self, other: Any) -> bool: ...
def decode_header(header: Union[Header, str]) -> List[Tuple[bytes, Optional[str]]]: ...
def make_header(
decoded_seq: List[Tuple[bytes, Optional[str]]],
maxlinelen: Optional[int] = ...,
header_name: Optional[str] = ...,
continuation_ws: str = ...,
) -> Header: ...
| 1,025 | Python | .py | 24 | 37.458333 | 116 | 0.562563 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,442 | message.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/message.pyi | from email.charset import Charset
from email.contentmanager import ContentManager
from email.errors import MessageDefect
from email.policy import Policy
from typing import Any, Generator, Iterator, List, Optional, Sequence, Tuple, TypeVar, Union
_T = TypeVar("_T")
_PayloadType = Union[List[Message], str, bytes]
_CharsetType = Union[Charset, str, None]
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
_ParamType = Union[str, Tuple[Optional[str], Optional[str], str]]
_HeaderType = Any
class Message:
preamble: Optional[str]
epilogue: Optional[str]
defects: List[MessageDefect]
def __str__(self) -> str: ...
def is_multipart(self) -> bool: ...
def set_unixfrom(self, unixfrom: str) -> None: ...
def get_unixfrom(self) -> Optional[str]: ...
def attach(self, payload: Message) -> None: ...
def get_payload(self, i: int = ..., decode: bool = ...) -> Any: ... # returns Optional[_PayloadType]
def set_payload(self, payload: _PayloadType, charset: _CharsetType = ...) -> None: ...
def set_charset(self, charset: _CharsetType) -> None: ...
def get_charset(self) -> _CharsetType: ...
def __len__(self) -> int: ...
def __contains__(self, name: str) -> bool: ...
def __getitem__(self, name: str) -> _HeaderType: ...
def __setitem__(self, name: str, val: _HeaderType) -> None: ...
def __delitem__(self, name: str) -> None: ...
def keys(self) -> List[str]: ...
def values(self) -> List[_HeaderType]: ...
def items(self) -> List[Tuple[str, _HeaderType]]: ...
def get(self, name: str, failobj: _T = ...) -> Union[_HeaderType, _T]: ...
def get_all(self, name: str, failobj: _T = ...) -> Union[List[_HeaderType], _T]: ...
def add_header(self, _name: str, _value: str, **_params: _ParamsType) -> None: ...
def replace_header(self, _name: str, _value: _HeaderType) -> None: ...
def get_content_type(self) -> str: ...
def get_content_maintype(self) -> str: ...
def get_content_subtype(self) -> str: ...
def get_default_type(self) -> str: ...
def set_default_type(self, ctype: str) -> None: ...
def get_params(self, failobj: _T = ..., header: str = ..., unquote: bool = ...) -> Union[List[Tuple[str, str]], _T]: ...
def get_param(self, param: str, failobj: _T = ..., header: str = ..., unquote: bool = ...) -> Union[_T, _ParamType]: ...
def del_param(self, param: str, header: str = ..., requote: bool = ...) -> None: ...
def set_type(self, type: str, header: str = ..., requote: bool = ...) -> None: ...
def get_filename(self, failobj: _T = ...) -> Union[_T, str]: ...
def get_boundary(self, failobj: _T = ...) -> Union[_T, str]: ...
def set_boundary(self, boundary: str) -> None: ...
def get_content_charset(self, failobj: _T = ...) -> Union[_T, str]: ...
def get_charsets(self, failobj: _T = ...) -> Union[_T, List[str]]: ...
def walk(self) -> Generator[Message, None, None]: ...
def get_content_disposition(self) -> Optional[str]: ...
def as_string(self, unixfrom: bool = ..., maxheaderlen: int = ..., policy: Optional[Policy] = ...) -> str: ...
def as_bytes(self, unixfrom: bool = ..., policy: Optional[Policy] = ...) -> bytes: ...
def __bytes__(self) -> bytes: ...
def set_param(
self,
param: str,
value: str,
header: str = ...,
requote: bool = ...,
charset: str = ...,
language: str = ...,
replace: bool = ...,
) -> None: ...
def __init__(self, policy: Policy = ...) -> None: ...
class MIMEPart(Message):
def get_body(self, preferencelist: Sequence[str] = ...) -> Optional[Message]: ...
def iter_attachments(self) -> Iterator[Message]: ...
def iter_parts(self) -> Iterator[Message]: ...
def get_content(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> Any: ...
def set_content(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
def make_related(self, boundary: Optional[str] = ...) -> None: ...
def make_alternative(self, boundary: Optional[str] = ...) -> None: ...
def make_mixed(self, boundary: Optional[str] = ...) -> None: ...
def add_related(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
def add_alternative(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
def add_attachment(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
def clear(self) -> None: ...
def clear_content(self) -> None: ...
def is_attachment(self) -> bool: ...
class EmailMessage(MIMEPart): ...
| 4,681 | Python | .py | 82 | 52.317073 | 124 | 0.595559 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,443 | application.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/mime/application.pyi | from email.mime.nonmultipart import MIMENonMultipart
from email.policy import Policy
from typing import Callable, Optional, Tuple, Union
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEApplication(MIMENonMultipart):
def __init__(
self,
_data: Union[str, bytes],
_subtype: str = ...,
_encoder: Callable[[MIMEApplication], None] = ...,
*,
policy: Optional[Policy] = ...,
**_params: _ParamsType,
) -> None: ...
| 499 | Python | .py | 14 | 29.928571 | 62 | 0.637681 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,444 | base.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/mime/base.pyi | import email.message
from email.policy import Policy
from typing import Optional, Tuple, Union
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEBase(email.message.Message):
def __init__(self, _maintype: str, _subtype: str, *, policy: Optional[Policy] = ..., **_params: _ParamsType) -> None: ...
| 325 | Python | .py | 6 | 52.166667 | 125 | 0.716088 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,445 | multipart.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/mime/multipart.pyi | from email.message import Message
from email.mime.base import MIMEBase
from email.policy import Policy
from typing import Optional, Sequence, Tuple, Union
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEMultipart(MIMEBase):
def __init__(
self,
_subtype: str = ...,
boundary: Optional[str] = ...,
_subparts: Optional[Sequence[Message]] = ...,
*,
policy: Optional[Policy] = ...,
**_params: _ParamsType,
) -> None: ...
| 507 | Python | .py | 15 | 28.4 | 62 | 0.632653 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,446 | message.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/mime/message.pyi | from email.message import Message
from email.mime.nonmultipart import MIMENonMultipart
from email.policy import Policy
from typing import Optional
class MIMEMessage(MIMENonMultipart):
def __init__(self, _msg: Message, _subtype: str = ..., *, policy: Optional[Policy] = ...) -> None: ...
| 292 | Python | .py | 6 | 46.833333 | 106 | 0.750877 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,447 | audio.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/mime/audio.pyi | from email.mime.nonmultipart import MIMENonMultipart
from email.policy import Policy
from typing import Callable, Optional, Tuple, Union
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEAudio(MIMENonMultipart):
def __init__(
self,
_audiodata: Union[str, bytes],
_subtype: Optional[str] = ...,
_encoder: Callable[[MIMEAudio], None] = ...,
*,
policy: Optional[Policy] = ...,
**_params: _ParamsType,
) -> None: ...
| 502 | Python | .py | 14 | 30.142857 | 62 | 0.635802 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,448 | image.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/mime/image.pyi | from email.mime.nonmultipart import MIMENonMultipart
from email.policy import Policy
from typing import Callable, Optional, Tuple, Union
_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
class MIMEImage(MIMENonMultipart):
def __init__(
self,
_imagedata: Union[str, bytes],
_subtype: Optional[str] = ...,
_encoder: Callable[[MIMEImage], None] = ...,
*,
policy: Optional[Policy] = ...,
**_params: _ParamsType,
) -> None: ...
| 502 | Python | .py | 14 | 30.142857 | 62 | 0.635802 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,449 | text.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/email/mime/text.pyi | from email.mime.nonmultipart import MIMENonMultipart
from email.policy import Policy
from typing import Optional
class MIMEText(MIMENonMultipart):
def __init__(
self, _text: str, _subtype: str = ..., _charset: Optional[str] = ..., *, policy: Optional[Policy] = ...
) -> None: ...
| 297 | Python | .py | 7 | 39 | 111 | 0.681661 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,450 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/html/__init__.pyi | from typing import AnyStr
def escape(s: AnyStr, quote: bool = ...) -> AnyStr: ...
def unescape(s: AnyStr) -> AnyStr: ...
| 122 | Python | .py | 3 | 39.333333 | 55 | 0.652542 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,451 | parser.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/html/parser.pyi | from _markupbase import ParserBase
from typing import List, Optional, Tuple
class HTMLParser(ParserBase):
def __init__(self, *, convert_charrefs: bool = ...) -> None: ...
def feed(self, feed: str) -> None: ...
def close(self) -> None: ...
def reset(self) -> None: ...
def getpos(self) -> Tuple[int, int]: ...
def get_starttag_text(self) -> Optional[str]: ...
def handle_starttag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None: ...
def handle_endtag(self, tag: str) -> None: ...
def handle_startendtag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None: ...
def handle_data(self, data: str) -> None: ...
def handle_entityref(self, name: str) -> None: ...
def handle_charref(self, name: str) -> None: ...
def handle_comment(self, data: str) -> None: ...
def handle_decl(self, decl: str) -> None: ...
def handle_pi(self, data: str) -> None: ...
def unknown_decl(self, data: str) -> None: ...
| 984 | Python | .py | 19 | 47.368421 | 95 | 0.610996 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,452 | entities.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/html/entities.pyi | from typing import Dict
name2codepoint: Dict[str, int]
html5: Dict[str, str]
codepoint2name: Dict[int, str]
entitydefs: Dict[str, str]
| 136 | Python | .py | 5 | 26 | 30 | 0.792308 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,453 | util.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/util.pyi | from typing import Any, List, Sequence, Tuple, TypeVar
_T = TypeVar("_T")
_Mismatch = Tuple[_T, _T, int]
_MAX_LENGTH: int
_PLACEHOLDER_LEN: int
_MIN_BEGIN_LEN: int
_MIN_END_LEN: int
_MIN_COMMON_LEN: int
_MIN_DIFF_LEN: int
def _shorten(s: str, prefixlen: int, suffixlen: int) -> str: ...
def _common_shorten_repr(*args: str) -> Tuple[str]: ...
def safe_repr(obj: object, short: bool = ...) -> str: ...
def strclass(cls: type) -> str: ...
def sorted_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[List[_T], List[_T]]: ...
def unorderable_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[List[_T], List[_T]]: ...
def three_way_cmp(x: Any, y: Any) -> int: ...
def _count_diff_all_purpose(actual: Sequence[_T], expected: Sequence[_T]) -> List[_Mismatch[_T]]: ...
def _count_diff_hashable(actual: Sequence[_T], expected: Sequence[_T]) -> List[_Mismatch[_T]]: ...
| 906 | Python | .py | 18 | 49.166667 | 111 | 0.659887 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,454 | signals.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/signals.pyi | import unittest.result
from typing import Any, Callable, TypeVar, overload
_F = TypeVar("_F", bound=Callable[..., Any])
def installHandler() -> None: ...
def registerResult(result: unittest.result.TestResult) -> None: ...
def removeResult(result: unittest.result.TestResult) -> bool: ...
@overload
def removeHandler(method: None = ...) -> None: ...
@overload
def removeHandler(method: _F) -> _F: ...
| 402 | Python | .py | 10 | 39 | 67 | 0.712821 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,455 | result.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/result.pyi | import unittest.case
from types import TracebackType
from typing import Any, Callable, List, Optional, TextIO, Tuple, Type, TypeVar, Union
_SysExcInfoType = Union[Tuple[Type[BaseException], BaseException, TracebackType], Tuple[None, None, None]]
_F = TypeVar("_F", bound=Callable[..., Any])
# undocumented
def failfast(method: _F) -> _F: ...
class TestResult:
errors: List[Tuple[unittest.case.TestCase, str]]
failures: List[Tuple[unittest.case.TestCase, str]]
skipped: List[Tuple[unittest.case.TestCase, str]]
expectedFailures: List[Tuple[unittest.case.TestCase, str]]
unexpectedSuccesses: List[unittest.case.TestCase]
shouldStop: bool
testsRun: int
buffer: bool
failfast: bool
tb_locals: bool
def __init__(
self, stream: Optional[TextIO] = ..., descriptions: Optional[bool] = ..., verbosity: Optional[int] = ...
) -> None: ...
def printErrors(self) -> None: ...
def wasSuccessful(self) -> bool: ...
def stop(self) -> None: ...
def startTest(self, test: unittest.case.TestCase) -> None: ...
def stopTest(self, test: unittest.case.TestCase) -> None: ...
def startTestRun(self) -> None: ...
def stopTestRun(self) -> None: ...
def addError(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ...
def addFailure(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ...
def addSuccess(self, test: unittest.case.TestCase) -> None: ...
def addSkip(self, test: unittest.case.TestCase, reason: str) -> None: ...
def addExpectedFailure(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ...
def addUnexpectedSuccess(self, test: unittest.case.TestCase) -> None: ...
def addSubTest(
self, test: unittest.case.TestCase, subtest: unittest.case.TestCase, err: Optional[_SysExcInfoType]
) -> None: ...
| 1,859 | Python | .py | 37 | 45.783784 | 112 | 0.685369 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,456 | loader.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/loader.pyi | import sys
import unittest.case
import unittest.result
import unittest.suite
from types import ModuleType
from typing import Any, Callable, List, Optional, Sequence, Type
_SortComparisonMethod = Callable[[str, str], int]
_SuiteClass = Callable[[List[unittest.case.TestCase]], unittest.suite.TestSuite]
class TestLoader:
errors: List[Type[BaseException]]
testMethodPrefix: str
sortTestMethodsUsing: _SortComparisonMethod
if sys.version_info >= (3, 7):
testNamePatterns: Optional[List[str]]
suiteClass: _SuiteClass
def loadTestsFromTestCase(self, testCaseClass: Type[unittest.case.TestCase]) -> unittest.suite.TestSuite: ...
def loadTestsFromModule(self, module: ModuleType, *args: Any, pattern: Any = ...) -> unittest.suite.TestSuite: ...
def loadTestsFromName(self, name: str, module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ...
def loadTestsFromNames(self, names: Sequence[str], module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ...
def getTestCaseNames(self, testCaseClass: Type[unittest.case.TestCase]) -> Sequence[str]: ...
def discover(self, start_dir: str, pattern: str = ..., top_level_dir: Optional[str] = ...) -> unittest.suite.TestSuite: ...
defaultTestLoader: TestLoader
if sys.version_info >= (3, 7):
def getTestCaseNames(
testCaseClass: Type[unittest.case.TestCase],
prefix: str,
sortUsing: _SortComparisonMethod = ...,
testNamePatterns: Optional[List[str]] = ...,
) -> Sequence[str]: ...
else:
def getTestCaseNames(
testCaseClass: Type[unittest.case.TestCase], prefix: str, sortUsing: _SortComparisonMethod = ...
) -> Sequence[str]: ...
def makeSuite(
testCaseClass: Type[unittest.case.TestCase],
prefix: str = ...,
sortUsing: _SortComparisonMethod = ...,
suiteClass: _SuiteClass = ...,
) -> unittest.suite.TestSuite: ...
def findTestCases(
module: ModuleType, prefix: str = ..., sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ...
) -> unittest.suite.TestSuite: ...
| 2,067 | Python | .py | 42 | 44.97619 | 127 | 0.707486 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,457 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/__init__.pyi | from typing import Optional
from unittest.async_case import *
from unittest.case import *
from unittest.loader import *
from unittest.main import *
from unittest.result import TestResult as TestResult
from unittest.runner import *
from unittest.signals import *
from unittest.suite import *
def load_tests(loader: TestLoader, tests: TestSuite, pattern: Optional[str]) -> TestSuite: ...
| 387 | Python | .py | 10 | 37.6 | 94 | 0.81383 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,458 | main.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/main.pyi | import sys
import unittest.case
import unittest.loader
import unittest.result
import unittest.suite
from types import ModuleType
from typing import Any, Iterable, List, Optional, Protocol, Type, Union
class _TestRunner(Protocol):
def run(self, test: Union[unittest.suite.TestSuite, unittest.case.TestCase]) -> unittest.result.TestResult: ...
# not really documented
class TestProgram:
result: unittest.result.TestResult
module: Union[None, str, ModuleType]
verbosity: int
failfast: Optional[bool]
catchbreak: Optional[bool]
buffer: Optional[bool]
progName: Optional[str]
warnings: Optional[str]
if sys.version_info >= (3, 7):
testNamePatterns: Optional[List[str]]
def __init__(
self,
module: Union[None, str, ModuleType] = ...,
defaultTest: Union[str, Iterable[str], None] = ...,
argv: Optional[List[str]] = ...,
testRunner: Union[Type[_TestRunner], _TestRunner, None] = ...,
testLoader: unittest.loader.TestLoader = ...,
exit: bool = ...,
verbosity: int = ...,
failfast: Optional[bool] = ...,
catchbreak: Optional[bool] = ...,
buffer: Optional[bool] = ...,
warnings: Optional[str] = ...,
*,
tb_locals: bool = ...,
) -> None: ...
def usageExit(self, msg: Any = ...) -> None: ...
def parseArgs(self, argv: List[str]) -> None: ...
if sys.version_info >= (3, 7):
def createTests(self, from_discovery: bool = ..., Loader: Optional[unittest.loader.TestLoader] = ...) -> None: ...
else:
def createTests(self) -> None: ...
def runTests(self) -> None: ... # undocumented
main = TestProgram
| 1,691 | Python | .py | 45 | 31.955556 | 122 | 0.630329 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,459 | case.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/case.pyi | import datetime
import logging
import sys
import unittest.result
from types import TracebackType
from typing import (
Any,
AnyStr,
Callable,
Container,
ContextManager,
Dict,
FrozenSet,
Generic,
Iterable,
List,
Mapping,
NoReturn,
Optional,
Pattern,
Sequence,
Set,
Tuple,
Type,
TypeVar,
Union,
overload,
)
from warnings import WarningMessage
if sys.version_info >= (3, 9):
from types import GenericAlias
_E = TypeVar("_E", bound=BaseException)
_FT = TypeVar("_FT", bound=Callable[..., Any])
if sys.version_info >= (3, 8):
def addModuleCleanup(__function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
def doModuleCleanups() -> None: ...
def expectedFailure(test_item: _FT) -> _FT: ...
def skip(reason: str) -> Callable[[_FT], _FT]: ...
def skipIf(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
def skipUnless(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
class SkipTest(Exception):
def __init__(self, reason: str) -> None: ...
class TestCase:
failureException: Type[BaseException]
longMessage: bool
maxDiff: Optional[int]
# undocumented
_testMethodName: str
# undocumented
_testMethodDoc: str
def __init__(self, methodName: str = ...) -> None: ...
def setUp(self) -> None: ...
def tearDown(self) -> None: ...
@classmethod
def setUpClass(cls) -> None: ...
@classmethod
def tearDownClass(cls) -> None: ...
def run(self, result: Optional[unittest.result.TestResult] = ...) -> Optional[unittest.result.TestResult]: ...
def __call__(self, result: Optional[unittest.result.TestResult] = ...) -> Optional[unittest.result.TestResult]: ...
def skipTest(self, reason: Any) -> None: ...
def subTest(self, msg: Any = ..., **params: Any) -> ContextManager[None]: ...
def debug(self) -> None: ...
def _addSkip(self, result: unittest.result.TestResult, test_case: TestCase, reason: str) -> None: ...
def assertEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def assertNotEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def assertTrue(self, expr: Any, msg: Any = ...) -> None: ...
def assertFalse(self, expr: Any, msg: Any = ...) -> None: ...
def assertIs(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ...
def assertIsNot(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ...
def assertIsNone(self, obj: Any, msg: Any = ...) -> None: ...
def assertIsNotNone(self, obj: Any, msg: Any = ...) -> None: ...
def assertIn(self, member: Any, container: Union[Iterable[Any], Container[Any]], msg: Any = ...) -> None: ...
def assertNotIn(self, member: Any, container: Union[Iterable[Any], Container[Any]], msg: Any = ...) -> None: ...
def assertIsInstance(self, obj: Any, cls: Union[type, Tuple[type, ...]], msg: Any = ...) -> None: ...
def assertNotIsInstance(self, obj: Any, cls: Union[type, Tuple[type, ...]], msg: Any = ...) -> None: ...
def assertGreater(self, a: Any, b: Any, msg: Any = ...) -> None: ...
def assertGreaterEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ...
def assertLess(self, a: Any, b: Any, msg: Any = ...) -> None: ...
def assertLessEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ...
@overload
def assertRaises( # type: ignore
self,
expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
callable: Callable[..., Any],
*args: Any,
**kwargs: Any,
) -> None: ...
@overload
def assertRaises(
self, expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any = ...
) -> _AssertRaisesContext[_E]: ...
@overload
def assertRaisesRegex( # type: ignore
self,
expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
callable: Callable[..., Any],
*args: Any,
**kwargs: Any,
) -> None: ...
@overload
def assertRaisesRegex(
self,
expected_exception: Union[Type[_E], Tuple[Type[_E], ...]],
expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
msg: Any = ...,
) -> _AssertRaisesContext[_E]: ...
@overload
def assertWarns( # type: ignore
self,
expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
callable: Callable[..., Any],
*args: Any,
**kwargs: Any,
) -> None: ...
@overload
def assertWarns(
self, expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]], msg: Any = ...
) -> _AssertWarnsContext: ...
@overload
def assertWarnsRegex( # type: ignore
self,
expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
callable: Callable[..., Any],
*args: Any,
**kwargs: Any,
) -> None: ...
@overload
def assertWarnsRegex(
self,
expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
msg: Any = ...,
) -> _AssertWarnsContext: ...
def assertLogs(
self, logger: Optional[Union[str, logging.Logger]] = ..., level: Union[int, str, None] = ...
) -> _AssertLogsContext: ...
@overload
def assertAlmostEqual(
self, first: float, second: float, places: Optional[int] = ..., msg: Any = ..., delta: Optional[float] = ...
) -> None: ...
@overload
def assertAlmostEqual(
self,
first: datetime.datetime,
second: datetime.datetime,
places: Optional[int] = ...,
msg: Any = ...,
delta: Optional[datetime.timedelta] = ...,
) -> None: ...
@overload
def assertNotAlmostEqual(self, first: float, second: float, *, msg: Any = ...) -> None: ...
@overload
def assertNotAlmostEqual(self, first: float, second: float, places: Optional[int] = ..., msg: Any = ...) -> None: ...
@overload
def assertNotAlmostEqual(self, first: float, second: float, *, msg: Any = ..., delta: Optional[float] = ...) -> None: ...
@overload
def assertNotAlmostEqual(
self,
first: datetime.datetime,
second: datetime.datetime,
places: Optional[int] = ...,
msg: Any = ...,
delta: Optional[datetime.timedelta] = ...,
) -> None: ...
def assertRegex(self, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ...
def assertNotRegex(self, text: AnyStr, unexpected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ...
def assertCountEqual(self, first: Iterable[Any], second: Iterable[Any], msg: Any = ...) -> None: ...
def addTypeEqualityFunc(self, typeobj: Type[Any], function: Callable[..., None]) -> None: ...
def assertMultiLineEqual(self, first: str, second: str, msg: Any = ...) -> None: ...
def assertSequenceEqual(
self, seq1: Sequence[Any], seq2: Sequence[Any], msg: Any = ..., seq_type: Optional[Type[Sequence[Any]]] = ...
) -> None: ...
def assertListEqual(self, list1: List[Any], list2: List[Any], msg: Any = ...) -> None: ...
def assertTupleEqual(self, tuple1: Tuple[Any, ...], tuple2: Tuple[Any, ...], msg: Any = ...) -> None: ...
def assertSetEqual(
self, set1: Union[Set[Any], FrozenSet[Any]], set2: Union[Set[Any], FrozenSet[Any]], msg: Any = ...
) -> None: ...
def assertDictEqual(self, d1: Dict[Any, Any], d2: Dict[Any, Any], msg: Any = ...) -> None: ...
def fail(self, msg: Any = ...) -> NoReturn: ...
def countTestCases(self) -> int: ...
def defaultTestResult(self) -> unittest.result.TestResult: ...
def id(self) -> str: ...
def shortDescription(self) -> Optional[str]: ...
if sys.version_info >= (3, 8):
def addCleanup(self, __function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
else:
def addCleanup(self, function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
def doCleanups(self) -> None: ...
if sys.version_info >= (3, 8):
@classmethod
def addClassCleanup(cls, __function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
@classmethod
def doClassCleanups(cls) -> None: ...
def _formatMessage(self, msg: Optional[str], standardMsg: str) -> str: ... # undocumented
def _getAssertEqualityFunc(self, first: Any, second: Any) -> Callable[..., None]: ... # undocumented
# below is deprecated
def failUnlessEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def assertEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def failIfEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def assertNotEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ...
def failUnless(self, expr: bool, msg: Any = ...) -> None: ...
def assert_(self, expr: bool, msg: Any = ...) -> None: ...
def failIf(self, expr: bool, msg: Any = ...) -> None: ...
@overload
def failUnlessRaises( # type: ignore
self,
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
callable: Callable[..., Any] = ...,
*args: Any,
**kwargs: Any,
) -> None: ...
@overload
def failUnlessRaises(self, exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any = ...) -> _AssertRaisesContext[_E]: ...
def failUnlessAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ...
def assertAlmostEquals(self, first: float, second: float, places: int = ..., msg: Any = ..., delta: float = ...) -> None: ...
def failIfAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ...
def assertNotAlmostEquals(
self, first: float, second: float, places: int = ..., msg: Any = ..., delta: float = ...
) -> None: ...
def assertRegexpMatches(self, text: AnyStr, regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ...
def assertNotRegexpMatches(self, text: AnyStr, regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ...
@overload
def assertRaisesRegexp( # type: ignore
self,
exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
callable: Callable[..., Any],
*args: Any,
**kwargs: Any,
) -> None: ...
@overload
def assertRaisesRegexp(
self,
exception: Union[Type[_E], Tuple[Type[_E], ...]],
expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
msg: Any = ...,
) -> _AssertRaisesContext[_E]: ...
def assertDictContainsSubset(self, subset: Mapping[Any, Any], dictionary: Mapping[Any, Any], msg: object = ...) -> None: ...
class FunctionTestCase(TestCase):
def __init__(
self,
testFunc: Callable[[], None],
setUp: Optional[Callable[[], None]] = ...,
tearDown: Optional[Callable[[], None]] = ...,
description: Optional[str] = ...,
) -> None: ...
def runTest(self) -> None: ...
class _AssertRaisesContext(Generic[_E]):
exception: _E
def __enter__(self) -> _AssertRaisesContext[_E]: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> bool: ...
if sys.version_info >= (3, 9):
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
class _AssertWarnsContext:
warning: WarningMessage
filename: str
lineno: int
warnings: List[WarningMessage]
def __enter__(self) -> _AssertWarnsContext: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> None: ...
class _AssertLogsContext:
LOGGING_FORMAT: str
records: List[logging.LogRecord]
output: List[str]
def __init__(self, test_case: TestCase, logger_name: str, level: int) -> None: ...
def __enter__(self) -> _AssertLogsContext: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> Optional[bool]: ...
| 12,483 | Python | .py | 275 | 39.527273 | 129 | 0.596819 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,460 | runner.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/runner.pyi | import unittest.case
import unittest.result
import unittest.suite
from typing import Callable, Optional, TextIO, Tuple, Type, Union
_ResultClassType = Callable[[TextIO, bool, int], unittest.result.TestResult]
class TextTestResult(unittest.result.TestResult):
descriptions: bool # undocumented
dots: bool # undocumented
separator1: str
separator2: str
showall: bool # undocumented
stream: TextIO # undocumented
def __init__(self, stream: TextIO, descriptions: bool, verbosity: int) -> None: ...
def getDescription(self, test: unittest.case.TestCase) -> str: ...
def printErrors(self) -> None: ...
def printErrorList(self, flavour: str, errors: Tuple[unittest.case.TestCase, str]) -> None: ...
class TextTestRunner(object):
resultclass: _ResultClassType
def __init__(
self,
stream: Optional[TextIO] = ...,
descriptions: bool = ...,
verbosity: int = ...,
failfast: bool = ...,
buffer: bool = ...,
resultclass: Optional[_ResultClassType] = ...,
warnings: Optional[Type[Warning]] = ...,
*,
tb_locals: bool = ...,
) -> None: ...
def _makeResult(self) -> unittest.result.TestResult: ...
def run(self, test: Union[unittest.suite.TestSuite, unittest.case.TestCase]) -> unittest.result.TestResult: ...
| 1,339 | Python | .py | 32 | 36.375 | 115 | 0.661043 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,461 | mock.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/mock.pyi | import sys
from typing import Any, Callable, Generic, List, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union, overload
_F = TypeVar("_F", bound=Callable[..., Any])
_T = TypeVar("_T")
_TT = TypeVar("_TT", bound=Type[Any])
_R = TypeVar("_R")
__all__ = [
"Mock",
"MagicMock",
"patch",
"sentinel",
"DEFAULT",
"ANY",
"call",
"create_autospec",
"AsyncMock",
"FILTER_DIR",
"NonCallableMock",
"NonCallableMagicMock",
"mock_open",
"PropertyMock",
"seal",
]
__version__: str
FILTER_DIR: Any
class _slotted: ...
class _SentinelObject:
name: Any
def __init__(self, name: Any) -> None: ...
class _Sentinel:
def __init__(self) -> None: ...
def __getattr__(self, name: str) -> Any: ...
sentinel: Any
DEFAULT: Any
class _Call(Tuple[Any, ...]):
def __new__(
cls, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ...
) -> Any: ...
name: Any
parent: Any
from_kall: Any
def __init__(
self, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ...
) -> None: ...
def __eq__(self, other: Any) -> bool: ...
__ne__: Any
def __call__(self, *args: Any, **kwargs: Any) -> _Call: ...
def __getattr__(self, attr: Any) -> Any: ...
def count(self, *args: Any, **kwargs: Any) -> Any: ...
def index(self, *args: Any, **kwargs: Any) -> Any: ...
def call_list(self) -> Any: ...
call: _Call
class _CallList(List[_Call]):
def __contains__(self, value: Any) -> bool: ...
class _MockIter:
obj: Any
def __init__(self, obj: Any) -> None: ...
def __iter__(self) -> Any: ...
def __next__(self) -> Any: ...
class Base:
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
class NonCallableMock(Base, Any): # type: ignore
def __new__(__cls, *args: Any, **kw: Any) -> NonCallableMock: ...
def __init__(
self,
spec: Union[List[str], object, Type[object], None] = ...,
wraps: Optional[Any] = ...,
name: Optional[str] = ...,
spec_set: Union[List[str], object, Type[object], None] = ...,
parent: Optional[NonCallableMock] = ...,
_spec_state: Optional[Any] = ...,
_new_name: str = ...,
_new_parent: Optional[NonCallableMock] = ...,
_spec_as_instance: bool = ...,
_eat_self: Optional[bool] = ...,
unsafe: bool = ...,
**kwargs: Any,
) -> None: ...
def __getattr__(self, name: str) -> Any: ...
if sys.version_info >= (3, 8):
def _calls_repr(self, prefix: str = ...) -> str: ...
def assert_called_with(self, *args: Any, **kwargs: Any) -> None: ...
def assert_not_called(self) -> None: ...
def assert_called_once_with(self, *args: Any, **kwargs: Any) -> None: ...
def _format_mock_failure_message(self, args: Any, kwargs: Any, action: str = ...) -> str: ...
elif sys.version_info >= (3, 5):
def assert_called_with(_mock_self, *args: Any, **kwargs: Any) -> None: ...
def assert_not_called(_mock_self) -> None: ...
def assert_called_once_with(_mock_self, *args: Any, **kwargs: Any) -> None: ...
def _format_mock_failure_message(self, args: Any, kwargs: Any) -> str: ...
if sys.version_info >= (3, 8):
def assert_called(self) -> None: ...
def assert_called_once(self) -> None: ...
elif sys.version_info >= (3, 6):
def assert_called(_mock_self) -> None: ...
def assert_called_once(_mock_self) -> None: ...
if sys.version_info >= (3, 6):
def reset_mock(self, visited: Any = ..., *, return_value: bool = ..., side_effect: bool = ...) -> None: ...
elif sys.version_info >= (3, 5):
def reset_mock(self, visited: Any = ...) -> None: ...
if sys.version_info >= (3, 7):
def _extract_mock_name(self) -> str: ...
def _get_call_signature_from_name(self, name: str) -> Any: ...
def assert_any_call(self, *args: Any, **kwargs: Any) -> None: ...
def assert_has_calls(self, calls: Sequence[_Call], any_order: bool = ...) -> None: ...
def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ...
def _mock_add_spec(self, spec: Any, spec_set: bool, _spec_as_instance: bool = ..., _eat_self: bool = ...) -> None: ...
def attach_mock(self, mock: NonCallableMock, attribute: str) -> None: ...
def configure_mock(self, **kwargs: Any) -> None: ...
return_value: Any
side_effect: Any
called: bool
call_count: int
call_args: Any
call_args_list: _CallList
mock_calls: _CallList
def _format_mock_call_signature(self, args: Any, kwargs: Any) -> str: ...
def _call_matcher(self, _call: Tuple[_Call, ...]) -> _Call: ...
def _get_child_mock(self, **kw: Any) -> NonCallableMock: ...
class CallableMixin(Base):
side_effect: Any
def __init__(
self,
spec: Optional[Any] = ...,
side_effect: Optional[Any] = ...,
return_value: Any = ...,
wraps: Optional[Any] = ...,
name: Optional[Any] = ...,
spec_set: Optional[Any] = ...,
parent: Optional[Any] = ...,
_spec_state: Optional[Any] = ...,
_new_name: Any = ...,
_new_parent: Optional[Any] = ...,
**kwargs: Any,
) -> None: ...
def __call__(_mock_self, *args: Any, **kwargs: Any) -> Any: ...
class Mock(CallableMixin, NonCallableMock): ...
class _patch(Generic[_T]):
attribute_name: Any
getter: Callable[[], Any]
attribute: str
new: _T
new_callable: Any
spec: Any
create: bool
has_local: Any
spec_set: Any
autospec: Any
kwargs: Mapping[str, Any]
additional_patchers: Any
if sys.version_info >= (3, 8):
@overload
def __init__(
self: _patch[Union[MagicMock, AsyncMock]],
getter: Callable[[], Any],
attribute: str,
*,
spec: Optional[Any],
create: bool,
spec_set: Optional[Any],
autospec: Optional[Any],
new_callable: Optional[Any],
kwargs: Mapping[str, Any],
) -> None: ...
# This overload also covers the case, where new==DEFAULT. In this case, self is _patch[Any].
# Ideally we'd be able to add an overload for it so that self is _patch[MagicMock],
# but that's impossible with the current type system.
@overload
def __init__(
self: _patch[_T],
getter: Callable[[], Any],
attribute: str,
new: _T,
spec: Optional[Any],
create: bool,
spec_set: Optional[Any],
autospec: Optional[Any],
new_callable: Optional[Any],
kwargs: Mapping[str, Any],
) -> None: ...
else:
@overload
def __init__(
self: _patch[MagicMock],
getter: Callable[[], Any],
attribute: str,
*,
spec: Optional[Any],
create: bool,
spec_set: Optional[Any],
autospec: Optional[Any],
new_callable: Optional[Any],
kwargs: Mapping[str, Any],
) -> None: ...
@overload
def __init__(
self: _patch[_T],
getter: Callable[[], Any],
attribute: str,
new: _T,
spec: Optional[Any],
create: bool,
spec_set: Optional[Any],
autospec: Optional[Any],
new_callable: Optional[Any],
kwargs: Mapping[str, Any],
) -> None: ...
def copy(self) -> _patch[_T]: ...
def __call__(self, func: Callable[..., _R]) -> Callable[..., _R]: ...
def decorate_class(self, klass: _TT) -> _TT: ...
def decorate_callable(self, func: _F) -> _F: ...
def get_original(self) -> Tuple[Any, bool]: ...
target: Any
temp_original: Any
is_local: bool
def __enter__(self) -> _T: ...
def __exit__(self, *exc_info: Any) -> None: ...
def start(self) -> _T: ...
def stop(self) -> None: ...
class _patch_dict:
in_dict: Any
values: Any
clear: Any
def __init__(self, in_dict: Any, values: Any = ..., clear: Any = ..., **kwargs: Any) -> None: ...
def __call__(self, f: Any) -> Any: ...
def decorate_class(self, klass: Any) -> Any: ...
def __enter__(self) -> Any: ...
def __exit__(self, *args: Any) -> Any: ...
start: Any
stop: Any
class _patcher:
TEST_PREFIX: str
dict: Type[_patch_dict]
if sys.version_info >= (3, 8):
@overload
def __call__( # type: ignore
self,
target: Any,
*,
spec: Optional[Any] = ...,
create: bool = ...,
spec_set: Optional[Any] = ...,
autospec: Optional[Any] = ...,
new_callable: Optional[Any] = ...,
**kwargs: Any,
) -> _patch[Union[MagicMock, AsyncMock]]: ...
# This overload also covers the case, where new==DEFAULT. In this case, the return type is _patch[Any].
# Ideally we'd be able to add an overload for it so that the return type is _patch[MagicMock],
# but that's impossible with the current type system.
@overload
def __call__(
self,
target: Any,
new: _T,
spec: Optional[Any] = ...,
create: bool = ...,
spec_set: Optional[Any] = ...,
autospec: Optional[Any] = ...,
new_callable: Optional[Any] = ...,
**kwargs: Any,
) -> _patch[_T]: ...
else:
@overload
def __call__( # type: ignore
self,
target: Any,
*,
spec: Optional[Any] = ...,
create: bool = ...,
spec_set: Optional[Any] = ...,
autospec: Optional[Any] = ...,
new_callable: Optional[Any] = ...,
**kwargs: Any,
) -> _patch[MagicMock]: ...
@overload
def __call__(
self,
target: Any,
new: _T,
spec: Optional[Any] = ...,
create: bool = ...,
spec_set: Optional[Any] = ...,
autospec: Optional[Any] = ...,
new_callable: Optional[Any] = ...,
**kwargs: Any,
) -> _patch[_T]: ...
if sys.version_info >= (3, 8):
@overload
def object( # type: ignore
self,
target: Any,
attribute: str,
*,
spec: Optional[Any] = ...,
create: bool = ...,
spec_set: Optional[Any] = ...,
autospec: Optional[Any] = ...,
new_callable: Optional[Any] = ...,
**kwargs: Any,
) -> _patch[Union[MagicMock, AsyncMock]]: ...
@overload
def object(
self,
target: Any,
attribute: str,
new: _T = ...,
spec: Optional[Any] = ...,
create: bool = ...,
spec_set: Optional[Any] = ...,
autospec: Optional[Any] = ...,
new_callable: Optional[Any] = ...,
**kwargs: Any,
) -> _patch[_T]: ...
else:
@overload
def object( # type: ignore
self,
target: Any,
attribute: str,
*,
spec: Optional[Any] = ...,
create: bool = ...,
spec_set: Optional[Any] = ...,
autospec: Optional[Any] = ...,
new_callable: Optional[Any] = ...,
**kwargs: Any,
) -> _patch[MagicMock]: ...
@overload
def object(
self,
target: Any,
attribute: str,
new: _T = ...,
spec: Optional[Any] = ...,
create: bool = ...,
spec_set: Optional[Any] = ...,
autospec: Optional[Any] = ...,
new_callable: Optional[Any] = ...,
**kwargs: Any,
) -> _patch[_T]: ...
def multiple(
self,
target: Any,
spec: Optional[Any] = ...,
create: bool = ...,
spec_set: Optional[Any] = ...,
autospec: Optional[Any] = ...,
new_callable: Optional[Any] = ...,
**kwargs: _T,
) -> _patch[_T]: ...
def stopall(self) -> None: ...
patch: _patcher
class MagicMixin:
def __init__(self, *args: Any, **kw: Any) -> None: ...
class NonCallableMagicMock(MagicMixin, NonCallableMock):
def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ...
class MagicMock(MagicMixin, Mock):
def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ...
if sys.version_info >= (3, 8):
class AsyncMockMixin(Base):
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
async def _execute_mock_call(self, *args: Any, **kwargs: Any) -> Any: ...
def assert_awaited(self) -> None: ...
def assert_awaited_once(self) -> None: ...
def assert_awaited_with(self, *args: Any, **kwargs: Any) -> None: ...
def assert_awaited_once_with(self, *args: Any, **kwargs: Any) -> None: ...
def assert_any_await(self, *args: Any, **kwargs: Any) -> None: ...
def assert_has_awaits(self, calls: _CallList, any_order: bool = ...) -> None: ...
def assert_not_awaited(self) -> None: ...
def reset_mock(self, *args, **kwargs) -> None: ...
await_count: int
await_args: Optional[_Call]
await_args_list: _CallList
class AsyncMagicMixin(MagicMixin):
def __init__(self, *args: Any, **kw: Any) -> None: ...
class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock): ...
class MagicProxy:
name: Any
parent: Any
def __init__(self, name: Any, parent: Any) -> None: ...
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
def create_mock(self) -> Any: ...
def __get__(self, obj: Any, _type: Optional[Any] = ...) -> Any: ...
class _ANY:
def __eq__(self, other: Any) -> bool: ...
def __ne__(self, other: Any) -> bool: ...
ANY: Any
def create_autospec(
spec: Any, spec_set: Any = ..., instance: Any = ..., _parent: Optional[Any] = ..., _name: Optional[Any] = ..., **kwargs: Any
) -> Any: ...
class _SpecState:
spec: Any
ids: Any
spec_set: Any
parent: Any
instance: Any
name: Any
def __init__(
self,
spec: Any,
spec_set: Any = ...,
parent: Optional[Any] = ...,
name: Optional[Any] = ...,
ids: Optional[Any] = ...,
instance: Any = ...,
) -> None: ...
def mock_open(mock: Optional[Any] = ..., read_data: Any = ...) -> Any: ...
PropertyMock = Any
if sys.version_info >= (3, 7):
def seal(mock: Any) -> None: ...
| 14,809 | Python | .py | 410 | 28.04878 | 128 | 0.50863 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,462 | async_case.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/async_case.pyi | import sys
from typing import Any, Awaitable, Callable
from .case import TestCase
if sys.version_info >= (3, 8):
class IsolatedAsyncioTestCase(TestCase):
async def asyncSetUp(self) -> None: ...
async def asyncTearDown(self) -> None: ...
def addAsyncCleanup(self, __func: Callable[..., Awaitable[Any]], *args: Any, **kwargs: Any) -> None: ...
| 372 | Python | .py | 8 | 41.75 | 112 | 0.668508 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,463 | suite.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/unittest/suite.pyi | import unittest.case
import unittest.result
from typing import Iterable, Iterator, List, Union
_TestType = Union[unittest.case.TestCase, TestSuite]
class BaseTestSuite(Iterable[_TestType]):
_tests: List[unittest.case.TestCase]
_removed_tests: int
def __init__(self, tests: Iterable[_TestType] = ...) -> None: ...
def __call__(self, result: unittest.result.TestResult) -> unittest.result.TestResult: ...
def addTest(self, test: _TestType) -> None: ...
def addTests(self, tests: Iterable[_TestType]) -> None: ...
def run(self, result: unittest.result.TestResult) -> unittest.result.TestResult: ...
def debug(self) -> None: ...
def countTestCases(self) -> int: ...
def __iter__(self) -> Iterator[_TestType]: ...
class TestSuite(BaseTestSuite):
def run(self, result: unittest.result.TestResult, debug: bool = ...) -> unittest.result.TestResult: ...
| 892 | Python | .py | 17 | 48.705882 | 107 | 0.68922 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,464 | client.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/xmlrpc/client.pyi | import gzip
import http.client
import sys
import time
from _typeshed import SupportsRead, SupportsWrite
from datetime import datetime
from io import BytesIO
from types import TracebackType
from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Protocol, Tuple, Type, Union, overload
from typing_extensions import Literal
class _SupportsTimeTuple(Protocol):
def timetuple(self) -> time.struct_time: ...
_DateTimeComparable = Union[DateTime, datetime, str, _SupportsTimeTuple]
_Marshallable = Union[None, bool, int, float, str, bytes, tuple, list, dict, datetime, DateTime, Binary]
_XMLDate = Union[int, datetime, Tuple[int, ...], time.struct_time]
_HostType = Union[Tuple[str, Dict[str, str]], str]
def escape(s: str) -> str: ... # undocumented
PARSE_ERROR: int # undocumented
SERVER_ERROR: int # undocumented
APPLICATION_ERROR: int # undocumented
SYSTEM_ERROR: int # undocumented
TRANSPORT_ERROR: int # undocumented
NOT_WELLFORMED_ERROR: int # undocumented
UNSUPPORTED_ENCODING: int # undocumented
INVALID_ENCODING_CHAR: int # undocumented
INVALID_XMLRPC: int # undocumented
METHOD_NOT_FOUND: int # undocumented
INVALID_METHOD_PARAMS: int # undocumented
INTERNAL_ERROR: int # undocumented
class Error(Exception): ...
class ProtocolError(Error):
url: str
errcode: int
errmsg: str
headers: Dict[str, str]
def __init__(self, url: str, errcode: int, errmsg: str, headers: Dict[str, str]) -> None: ...
class ResponseError(Error): ...
class Fault(Error):
faultCode: str
faultString: str
def __init__(self, faultCode: str, faultString: str, **extra: Any) -> None: ...
boolean = bool
Boolean = bool
def _iso8601_format(value: datetime) -> str: ... # undocumented
def _strftime(value: _XMLDate) -> str: ... # undocumented
class DateTime:
value: str # undocumented
def __init__(self, value: Union[int, str, datetime, time.struct_time, Tuple[int, ...]] = ...) -> None: ...
def __lt__(self, other: _DateTimeComparable) -> bool: ...
def __le__(self, other: _DateTimeComparable) -> bool: ...
def __gt__(self, other: _DateTimeComparable) -> bool: ...
def __ge__(self, other: _DateTimeComparable) -> bool: ...
def __eq__(self, other: _DateTimeComparable) -> bool: ... # type: ignore
def make_comparable(self, other: _DateTimeComparable) -> Tuple[str, str]: ... # undocumented
def timetuple(self) -> time.struct_time: ... # undocumented
def decode(self, data: Any) -> None: ...
def encode(self, out: SupportsWrite[str]) -> None: ...
def _datetime(data: Any) -> DateTime: ... # undocumented
def _datetime_type(data: str) -> datetime: ... # undocumented
class Binary:
data: bytes
def __init__(self, data: Optional[bytes] = ...) -> None: ...
def decode(self, data: bytes) -> None: ...
def encode(self, out: SupportsWrite[str]) -> None: ...
def _binary(data: bytes) -> Binary: ... # undocumented
WRAPPERS: Tuple[Type[DateTime], Type[Binary]] # undocumented
class ExpatParser: # undocumented
def __init__(self, target: Unmarshaller) -> None: ...
def feed(self, data: Union[str, bytes]) -> None: ...
def close(self) -> None: ...
class Marshaller:
dispatch: Dict[
Type[Any], Callable[[Marshaller, Any, Callable[[str], Any]], None]
] = ... # TODO: Replace 'Any' with some kind of binding
memo: Dict[Any, None]
data: None
encoding: Optional[str]
allow_none: bool
def __init__(self, encoding: Optional[str] = ..., allow_none: bool = ...) -> None: ...
def dumps(self, values: Union[Fault, Iterable[_Marshallable]]) -> str: ...
def __dump(self, value: Union[_Marshallable], write: Callable[[str], Any]) -> None: ... # undocumented
def dump_nil(self, value: None, write: Callable[[str], Any]) -> None: ...
def dump_bool(self, value: bool, write: Callable[[str], Any]) -> None: ...
def dump_long(self, value: int, write: Callable[[str], Any]) -> None: ...
def dump_int(self, value: int, write: Callable[[str], Any]) -> None: ...
def dump_double(self, value: float, write: Callable[[str], Any]) -> None: ...
def dump_unicode(self, value: str, write: Callable[[str], Any], escape: Callable[[str], str] = ...) -> None: ...
def dump_bytes(self, value: bytes, write: Callable[[str], Any]) -> None: ...
def dump_array(self, value: Iterable[_Marshallable], write: Callable[[str], Any]) -> None: ...
def dump_struct(
self, value: Mapping[str, _Marshallable], write: Callable[[str], Any], escape: Callable[[str], str] = ...
) -> None: ...
def dump_datetime(self, value: _XMLDate, write: Callable[[str], Any]) -> None: ...
def dump_instance(self, value: object, write: Callable[[str], Any]) -> None: ...
class Unmarshaller:
dispatch: Dict[str, Callable[[Unmarshaller, str], None]] = ...
_type: Optional[str]
_stack: List[_Marshallable]
_marks: List[int]
_data: List[str]
_value: bool
_methodname: Optional[str]
_encoding: str
append: Callable[[Any], None]
_use_datetime: bool
_use_builtin_types: bool
def __init__(self, use_datetime: bool = ..., use_builtin_types: bool = ...) -> None: ...
def close(self) -> Tuple[_Marshallable, ...]: ...
def getmethodname(self) -> Optional[str]: ...
def xml(self, encoding: str, standalone: Any) -> None: ... # Standalone is ignored
def start(self, tag: str, attrs: Dict[str, str]) -> None: ...
def data(self, text: str) -> None: ...
def end(self, tag: str) -> None: ...
def end_dispatch(self, tag: str, data: str) -> None: ...
def end_nil(self, data: str) -> None: ...
def end_boolean(self, data: str) -> None: ...
def end_int(self, data: str) -> None: ...
def end_double(self, data: str) -> None: ...
def end_bigdecimal(self, data: str) -> None: ...
def end_string(self, data: str) -> None: ...
def end_array(self, data: str) -> None: ...
def end_struct(self, data: str) -> None: ...
def end_base64(self, data: str) -> None: ...
def end_dateTime(self, data: str) -> None: ...
def end_value(self, data: str) -> None: ...
def end_params(self, data: str) -> None: ...
def end_fault(self, data: str) -> None: ...
def end_methodName(self, data: str) -> None: ...
class _MultiCallMethod: # undocumented
__call_list: List[Tuple[str, Tuple[_Marshallable, ...]]]
__name: str
def __init__(self, call_list: List[Tuple[str, _Marshallable]], name: str) -> None: ...
def __getattr__(self, name: str) -> _MultiCallMethod: ...
def __call__(self, *args: _Marshallable) -> None: ...
class MultiCallIterator: # undocumented
results: List[List[_Marshallable]]
def __init__(self, results: List[List[_Marshallable]]) -> None: ...
def __getitem__(self, i: int) -> _Marshallable: ...
class MultiCall:
__server: ServerProxy
__call_list: List[Tuple[str, Tuple[_Marshallable, ...]]]
def __init__(self, server: ServerProxy) -> None: ...
def __getattr__(self, item: str) -> _MultiCallMethod: ...
def __call__(self) -> MultiCallIterator: ...
# A little white lie
FastMarshaller: Optional[Marshaller]
FastParser: Optional[ExpatParser]
FastUnmarshaller: Optional[Unmarshaller]
def getparser(use_datetime: bool = ..., use_builtin_types: bool = ...) -> Tuple[ExpatParser, Unmarshaller]: ...
def dumps(
params: Union[Fault, Tuple[_Marshallable, ...]],
methodname: Optional[str] = ...,
methodresponse: Optional[bool] = ...,
encoding: Optional[str] = ...,
allow_none: bool = ...,
) -> str: ...
def loads(
data: str, use_datetime: bool = ..., use_builtin_types: bool = ...
) -> Tuple[Tuple[_Marshallable, ...], Optional[str]]: ...
def gzip_encode(data: bytes) -> bytes: ... # undocumented
def gzip_decode(data: bytes, max_decode: int = ...) -> bytes: ... # undocumented
class GzipDecodedResponse(gzip.GzipFile): # undocumented
io: BytesIO
def __init__(self, response: SupportsRead[bytes]) -> None: ...
def close(self) -> None: ...
class _Method: # undocumented
__send: Callable[[str, Tuple[_Marshallable, ...]], _Marshallable]
__name: str
def __init__(self, send: Callable[[str, Tuple[_Marshallable, ...]], _Marshallable], name: str) -> None: ...
def __getattr__(self, name: str) -> _Method: ...
def __call__(self, *args: _Marshallable) -> _Marshallable: ...
class Transport:
user_agent: str = ...
accept_gzip_encoding: bool = ...
encode_threshold: Optional[int] = ...
_use_datetime: bool
_use_builtin_types: bool
_connection: Tuple[Optional[_HostType], Optional[http.client.HTTPConnection]]
_headers: List[Tuple[str, str]]
_extra_headers: List[Tuple[str, str]]
if sys.version_info >= (3, 8):
def __init__(
self, use_datetime: bool = ..., use_builtin_types: bool = ..., *, headers: Iterable[Tuple[str, str]] = ...
) -> None: ...
else:
def __init__(self, use_datetime: bool = ..., use_builtin_types: bool = ...) -> None: ...
def request(self, host: _HostType, handler: str, request_body: bytes, verbose: bool = ...) -> Tuple[_Marshallable, ...]: ...
def single_request(
self, host: _HostType, handler: str, request_body: bytes, verbose: bool = ...
) -> Tuple[_Marshallable, ...]: ...
def getparser(self) -> Tuple[ExpatParser, Unmarshaller]: ...
def get_host_info(self, host: _HostType) -> Tuple[str, List[Tuple[str, str]], Dict[str, str]]: ...
def make_connection(self, host: _HostType) -> http.client.HTTPConnection: ...
def close(self) -> None: ...
def send_request(self, host: _HostType, handler: str, request_body: bytes, debug: bool) -> http.client.HTTPConnection: ...
def send_headers(self, connection: http.client.HTTPConnection, headers: List[Tuple[str, str]]) -> None: ...
def send_content(self, connection: http.client.HTTPConnection, request_body: bytes) -> None: ...
def parse_response(self, response: http.client.HTTPResponse) -> Tuple[_Marshallable, ...]: ...
class SafeTransport(Transport):
if sys.version_info >= (3, 8):
def __init__(
self,
use_datetime: bool = ...,
use_builtin_types: bool = ...,
*,
headers: Iterable[Tuple[str, str]] = ...,
context: Optional[Any] = ...,
) -> None: ...
else:
def __init__(self, use_datetime: bool = ..., use_builtin_types: bool = ..., *, context: Optional[Any] = ...) -> None: ...
def make_connection(self, host: _HostType) -> http.client.HTTPSConnection: ...
class ServerProxy:
__host: str
__handler: str
__transport: Transport
__encoding: str
__verbose: bool
__allow_none: bool
if sys.version_info >= (3, 8):
def __init__(
self,
uri: str,
transport: Optional[Transport] = ...,
encoding: Optional[str] = ...,
verbose: bool = ...,
allow_none: bool = ...,
use_datetime: bool = ...,
use_builtin_types: bool = ...,
*,
headers: Iterable[Tuple[str, str]] = ...,
context: Optional[Any] = ...,
) -> None: ...
else:
def __init__(
self,
uri: str,
transport: Optional[Transport] = ...,
encoding: Optional[str] = ...,
verbose: bool = ...,
allow_none: bool = ...,
use_datetime: bool = ...,
use_builtin_types: bool = ...,
*,
context: Optional[Any] = ...,
) -> None: ...
def __getattr__(self, name: str) -> _Method: ...
@overload
def __call__(self, attr: Literal["close"]) -> Callable[[], None]: ...
@overload
def __call__(self, attr: Literal["transport"]) -> Transport: ...
@overload
def __call__(self, attr: str) -> Union[Callable[[], None], Transport]: ...
def __enter__(self) -> ServerProxy: ...
def __exit__(
self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
) -> None: ...
def __close(self) -> None: ... # undocumented
def __request(self, methodname: str, params: Tuple[_Marshallable, ...]) -> Tuple[_Marshallable, ...]: ... # undocumented
Server = ServerProxy
| 12,285 | Python | .py | 259 | 42.166023 | 129 | 0.615263 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,465 | server.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/3/xmlrpc/server.pyi | import http.server
import pydoc
import socketserver
import sys
from datetime import datetime
from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Pattern, Protocol, Tuple, Type, Union
from xmlrpc.client import Fault
_Marshallable = Union[
None, bool, int, float, str, bytes, tuple, list, dict, datetime
] # TODO: Recursive type on tuple, list, dict
# The dispatch accepts anywhere from 0 to N arguments, no easy way to allow this in mypy
class _DispatchArity0(Protocol):
def __call__(self) -> _Marshallable: ...
class _DispatchArity1(Protocol):
def __call__(self, __arg1: _Marshallable) -> _Marshallable: ...
class _DispatchArity2(Protocol):
def __call__(self, __arg1: _Marshallable, __arg2: _Marshallable) -> _Marshallable: ...
class _DispatchArity3(Protocol):
def __call__(self, __arg1: _Marshallable, __arg2: _Marshallable, __arg3: _Marshallable) -> _Marshallable: ...
class _DispatchArity4(Protocol):
def __call__(
self, __arg1: _Marshallable, __arg2: _Marshallable, __arg3: _Marshallable, __arg4: _Marshallable
) -> _Marshallable: ...
class _DispatchArityN(Protocol):
def __call__(self, *args: _Marshallable) -> _Marshallable: ...
_DispatchProtocol = Union[_DispatchArity0, _DispatchArity1, _DispatchArity2, _DispatchArity3, _DispatchArity4, _DispatchArityN]
def resolve_dotted_attribute(obj: Any, attr: str, allow_dotted_names: bool = ...) -> Any: ... # undocumented
def list_public_methods(obj: Any) -> List[str]: ... # undocumented
class SimpleXMLRPCDispatcher: # undocumented
funcs: Dict[str, _DispatchProtocol]
instance: Optional[Any]
allow_none: bool
encoding: str
use_builtin_types: bool
def __init__(self, allow_none: bool = ..., encoding: Optional[str] = ..., use_builtin_types: bool = ...) -> None: ...
def register_instance(self, instance: Any, allow_dotted_names: bool = ...) -> None: ...
if sys.version_info >= (3, 7):
def register_function(
self, function: Optional[_DispatchProtocol] = ..., name: Optional[str] = ...
) -> Callable[..., Any]: ...
else:
def register_function(self, function: _DispatchProtocol, name: Optional[str] = ...) -> Callable[..., Any]: ...
def register_introspection_functions(self) -> None: ...
def register_multicall_functions(self) -> None: ...
def _marshaled_dispatch(
self,
data: str,
dispatch_method: Optional[
Callable[[Optional[str], Tuple[_Marshallable, ...]], Union[Fault, Tuple[_Marshallable, ...]]]
] = ...,
path: Optional[Any] = ...,
) -> str: ... # undocumented
def system_listMethods(self) -> List[str]: ... # undocumented
def system_methodSignature(self, method_name: str) -> str: ... # undocumented
def system_methodHelp(self, method_name: str) -> str: ... # undocumented
def system_multicall(self, call_list: List[Dict[str, _Marshallable]]) -> List[_Marshallable]: ... # undocumented
def _dispatch(self, method: str, params: Iterable[_Marshallable]) -> _Marshallable: ... # undocumented
class SimpleXMLRPCRequestHandler(http.server.BaseHTTPRequestHandler):
rpc_paths: Tuple[str, str] = ...
encode_threshold: int = ... # undocumented
aepattern: Pattern[str] # undocumented
def accept_encodings(self) -> Dict[str, float]: ...
def is_rpc_path_valid(self) -> bool: ...
def do_POST(self) -> None: ...
def decode_request_content(self, data: bytes) -> Optional[bytes]: ...
def report_404(self) -> None: ...
def log_request(self, code: Union[int, str] = ..., size: Union[int, str] = ...) -> None: ...
class SimpleXMLRPCServer(socketserver.TCPServer, SimpleXMLRPCDispatcher):
allow_reuse_address: bool = ...
_send_traceback_handler: bool = ...
def __init__(
self,
addr: Tuple[str, int],
requestHandler: Type[SimpleXMLRPCRequestHandler] = ...,
logRequests: bool = ...,
allow_none: bool = ...,
encoding: Optional[str] = ...,
bind_and_activate: bool = ...,
use_builtin_types: bool = ...,
) -> None: ...
class MultiPathXMLRPCServer(SimpleXMLRPCServer): # undocumented
dispatchers: Dict[str, SimpleXMLRPCDispatcher]
allow_none: bool
encoding: str
def __init__(
self,
addr: Tuple[str, int],
requestHandler: Type[SimpleXMLRPCRequestHandler] = ...,
logRequests: bool = ...,
allow_none: bool = ...,
encoding: Optional[str] = ...,
bind_and_activate: bool = ...,
use_builtin_types: bool = ...,
) -> None: ...
def add_dispatcher(self, path: str, dispatcher: SimpleXMLRPCDispatcher) -> SimpleXMLRPCDispatcher: ...
def get_dispatcher(self, path: str) -> SimpleXMLRPCDispatcher: ...
def _marshaled_dispatch(
self,
data: str,
dispatch_method: Optional[
Callable[[Optional[str], Tuple[_Marshallable, ...]], Union[Fault, Tuple[_Marshallable, ...]]]
] = ...,
path: Optional[Any] = ...,
) -> str: ...
class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher):
def __init__(self, allow_none: bool = ..., encoding: Optional[str] = ..., use_builtin_types: bool = ...) -> None: ...
def handle_xmlrpc(self, request_text: str) -> None: ...
def handle_get(self) -> None: ...
def handle_request(self, request_text: Optional[str] = ...) -> None: ...
class ServerHTMLDoc(pydoc.HTMLDoc): # undocumented
def docroutine(self, object: object, name: str, mod: Optional[str] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., methods: Mapping[str, str] = ..., cl: Optional[type] = ...) -> str: ... # type: ignore
def docserver(self, server_name: str, package_documentation: str, methods: Dict[str, str]) -> str: ...
class XMLRPCDocGenerator: # undocumented
server_name: str
server_documentation: str
server_title: str
def __init__(self) -> None: ...
def set_server_title(self, server_title: str) -> None: ...
def set_server_name(self, server_name: str) -> None: ...
def set_server_documentation(self, server_documentation: str) -> None: ...
def generate_html_documentation(self) -> str: ...
class DocXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
def do_GET(self) -> None: ...
class DocXMLRPCServer(SimpleXMLRPCServer, XMLRPCDocGenerator):
def __init__(
self,
addr: Tuple[str, int],
requestHandler: Type[SimpleXMLRPCRequestHandler] = ...,
logRequests: bool = ...,
allow_none: bool = ...,
encoding: Optional[str] = ...,
bind_and_activate: bool = ...,
use_builtin_types: bool = ...,
) -> None: ...
class DocCGIXMLRPCRequestHandler(CGIXMLRPCRequestHandler, XMLRPCDocGenerator):
def __init__(self) -> None: ...
| 6,810 | Python | .py | 136 | 44.455882 | 231 | 0.642256 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,466 | update-stubtest-whitelist.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/scripts/update-stubtest-whitelist.py | #!/usr/bin/env python3
# This script removes lines from stubtest whitelists, according to
# an input file. The input file has one entry to remove per line.
# Each line consists of a whitelist filename and an entry, separated
# by a colon.
# This script is used by the workflow to remove unused whitelist entries.
import sys
from collections import defaultdict
from typing import Dict, List, Set, Tuple
def main() -> None:
if len(sys.argv) != 2:
print(f"Usage: {sys.argv[0]} FILENAME", file=sys.stderr)
sys.exit(1)
to_remove = parse_input_file(sys.argv[1])
for filename, entries in to_remove.items():
remove_entries_from_whitelist(filename, entries)
def parse_input_file(input_file: str) -> Dict[str, Set[str]]:
to_remove = defaultdict(set)
with open(input_file) as f:
for filename, wl_entry in [parse_input_line(li) for li in f if li.strip()]:
to_remove[filename].add(wl_entry)
return to_remove
# Returns a (filename, entry) tuple.
def parse_input_line(line: str) -> Tuple[str, str]:
line = line.strip()
filename, entry = line.split(":", maxsplit=1)
return filename, entry
def remove_entries_from_whitelist(filename: str, entries: Set[str]) -> None:
new_lines: List[str] = []
with open(filename) as f:
for line in f:
entry = line.strip().split(" #")[0]
if entry in entries:
entries.remove(entry)
else:
new_lines.append(line)
if entries:
print(f"WARNING: The following entries were not found in '{filename}':", file=sys.stderr)
for entry in entries:
print(f" * {entry}")
with open(filename, "w") as f:
for line in new_lines:
f.write(line)
if __name__ == "__main__":
main()
| 1,811 | Python | .py | 45 | 33.955556 | 97 | 0.64726 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,467 | migrate_script.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/scripts/migrate_script.py | """
Ad-hoc script to migrate typeshed to a new directory structure proposed in
https://github.com/python/typeshed/issues/2491#issuecomment-611607557
"""
import ast
import os
import os.path
import shutil
from dataclasses import dataclass
from typing import List, Optional, Set, Tuple
# These names may be still discussed so I make them constants.
STDLIB_NAMESPACE = "stdlib"
THIRD_PARTY_NAMESPACE = "stubs"
DEFAULT_VERSION = "0.1"
DEFAULT_PY3_VERSION = "3.6"
PY2_NAMESPACE = "python2"
OUTPUT_DIR = "out"
# Third party imports (type ignored) of missing stubs.
MISSING_WHITELIST = {
"thrift",
}
# Manually collected special cases where distribution name and
# package name are different.
package_to_distribution = {
"_pytest": "pytest",
"yaml": "PyYAML",
"typing_extensions": "typing-extensions",
"mypy_extensions": "mypy-extensions",
"pyre_extensions": "pyre-extensions",
"attr": "attrs",
"concurrent": "futures",
"Crypto": "pycrypto",
"datetimerange": "DateTimeRange",
"dateutil": "python-dateutil",
"enum": "enum34",
"flask": "Flask",
"gflags": "python-gflags",
"google": "protobuf",
"jinja2": "Jinja2",
"markupsafe": "MarkupSafe",
"OpenSSL": "openssl-python",
"pymysql": "PyMySQL",
"pyVmomi": "pyvmomi",
"routes": "Routes",
"typed_ast": "typed-ast",
"werkzeug": "Werkzeug",
}
known_versions = {
"mypy-extensions": "0.4",
"typing-extensions": "3.7",
"typed-ast": "1.4",
}
# Classes with "Package" in name represent both packages and modules.
# The latter two are distinguished by is_dir flag.
class PackageBase:
"""Common attributes for packages/modules"""
path: str # full initial path like stdlib/2and3/argparse.pyi
is_dir: bool
@property
def name(self) -> str:
_, tail = os.path.split(self.path)
if self.is_dir:
assert not tail.endswith(".pyi")
return tail
assert tail.endswith(".pyi")
name, _ = os.path.splitext(tail)
return name
@dataclass
class StdLibPackage(PackageBase):
"""Package/module in standard library."""
path: str
py_version: Optional[str] # Can be omitted for Python 2 only packages.
is_dir: bool
@dataclass
class ThirdPartyPackage(PackageBase):
path: str
py2_compatible: bool
py3_compatible: bool
is_dir: bool
requires: List[str] # distributions this depends on
def add_stdlib_packages_from(subdir: str, packages: List[StdLibPackage], py_version: Optional[str]) -> None:
"""Add standard library packages/modules from a given stdlib/xxx subdirectory.
Append to packages list in-place, use py_version as the minimal supported version.
"""
for name in os.listdir(subdir):
path = os.path.join(subdir, name)
packages.append(StdLibPackage(path, py_version, is_dir=os.path.isdir(path)))
def collect_stdlib_packages() -> Tuple[List[StdLibPackage], List[StdLibPackage]]:
"""Collect standard library packages/modules from all current stdlib/xxx sub-directories."""
stdlib: List[StdLibPackage] = []
py2_stdlib: List[StdLibPackage] = []
# These will go to a separate subdirectory.
add_stdlib_packages_from("stdlib/2", py2_stdlib, None)
add_stdlib_packages_from("stdlib/2and3", stdlib, "2.7")
# Use oldest currently supported version for Python 3 packages/modules.
add_stdlib_packages_from("stdlib/3", stdlib, DEFAULT_PY3_VERSION)
for version in ("3.7", "3.8", "3.9"):
subdir = os.path.join("stdlib", version)
if os.path.isdir(subdir):
add_stdlib_packages_from(subdir, stdlib, version)
return stdlib, py2_stdlib
def add_third_party_packages_from(
subdir: str, packages: List[ThirdPartyPackage], py2_compatible: bool, py3_compatible: bool
) -> None:
"""Add third party packages/modules from a given third_party/xxx subdirectory."""
for name in os.listdir(subdir):
path = os.path.join(subdir, name)
packages.append(ThirdPartyPackage(path, py2_compatible, py3_compatible, requires=[], is_dir=os.path.isdir(path)))
def collect_third_party_packages() -> Tuple[List[ThirdPartyPackage], List[ThirdPartyPackage]]:
"""Collect third party packages/modules from all current third_party/xxx sub-directories."""
third_party: List[ThirdPartyPackage] = []
py2_third_party: List[ThirdPartyPackage] = []
add_third_party_packages_from("third_party/3", third_party, py2_compatible=False, py3_compatible=True)
add_third_party_packages_from("third_party/2and3", third_party, py2_compatible=True, py3_compatible=True)
# We special-case Python 2 for third party packages like six.
subdir = "third_party/2"
py3_packages = os.listdir("third_party/3")
for name in os.listdir(subdir):
path = os.path.join(subdir, name)
package = ThirdPartyPackage(path, py2_compatible=True, py3_compatible=False, requires=[], is_dir=os.path.isdir(path))
if name in py3_packages:
# If there is a package with the same name in /2 and /3, we add the former to
# a separate list, packages from there will be put into /python2 sub-directories.
py2_third_party.append(package)
else:
third_party.append(package)
return third_party, py2_third_party
def get_top_imported_names(file: str) -> Set[str]:
"""Collect names imported in given file.
We only collect top-level names, i.e. `from foo.bar import baz`
will only add `foo` to the list.
"""
if not file.endswith(".pyi"):
return set()
with open(os.path.join(file), "rb") as f:
content = f.read()
parsed = ast.parse(content)
top_imported = set()
for node in ast.walk(parsed):
if isinstance(node, ast.Import):
for name in node.names:
top_imported.add(name.name.split(".")[0])
elif isinstance(node, ast.ImportFrom):
if node.level > 0:
# Relative imports always refer to the current package.
continue
assert node.module
top_imported.add(node.module.split(".")[0])
return top_imported
def populate_requirements(
package: ThirdPartyPackage, stdlib: List[str], py2_stdlib: List[str], known_distributions: Set[str]
) -> None:
"""Generate requirements using imports found in a package."""
assert not package.requires, "Populate must be called once"
if not package.is_dir:
all_top_imports = get_top_imported_names(package.path)
else:
all_top_imports = set()
for dir_path, _, file_names in os.walk(package.path):
for file_name in file_names:
all_top_imports |= get_top_imported_names(os.path.join(dir_path, file_name))
# Generate dependencies using collected imports.
requirements = set()
for name in all_top_imports:
# Note: dependencies are between distributions, not packages.
distribution = package_to_distribution.get(name, name)
if package.py3_compatible and name not in stdlib:
if distribution in known_distributions:
requirements.add(distribution)
else:
# Likely a conditional import.
assert distribution in py2_stdlib or distribution in MISSING_WHITELIST
if package.py2_compatible and name not in py2_stdlib:
if distribution in known_distributions:
requirements.add(distribution)
else:
# Likely a conditional import.
assert distribution in stdlib or distribution in MISSING_WHITELIST
# Remove dependency to itself generated by absolute imports.
current_distribution = package_to_distribution.get(package.name, package.name)
package.requires = sorted(requirements - {current_distribution})
def generate_versions(packages: List[StdLibPackage]) -> str:
"""Generate the stdlib/VERSIONS file for packages/modules."""
lines = []
for package in packages:
assert package.py_version is not None
lines.append(f"{package.name}: {package.py_version}")
return "\n".join(sorted(lines))
def copy_stdlib(packages: List[StdLibPackage], py2_packages: List[StdLibPackage]) -> None:
"""Refactor the standard library part using collected metadata."""
stdlib_dir = os.path.join(OUTPUT_DIR, STDLIB_NAMESPACE)
os.makedirs(stdlib_dir, exist_ok=True)
# Write version metadata.
with open(os.path.join(stdlib_dir, "VERSIONS"), "w") as f:
f.write(generate_versions(packages))
f.write("\n")
# Copy stdlib/2and3 and stdlib/3 packages/modules.
for package in packages:
if not package.is_dir:
shutil.copy(package.path, stdlib_dir)
else:
shutil.copytree(package.path, os.path.join(stdlib_dir, package.name))
# Copy stdlib/2 packages/modules to a nested /python namespace.
if py2_packages:
py2_stdlib_dir = os.path.join(stdlib_dir, PY2_NAMESPACE)
os.makedirs(py2_stdlib_dir, exist_ok=True)
for package in py2_packages:
if not package.is_dir:
shutil.copy(package.path, py2_stdlib_dir)
else:
shutil.copytree(package.path, os.path.join(py2_stdlib_dir, package.name))
def generate_metadata(package: ThirdPartyPackage, py2_packages: List[str]) -> str:
"""Generate METADATA.toml for a given package.
Only add compatibility flags if they are different from default values:
python2 = false, python3 = true.
Note: the metadata should be generated per distribution, but we just use
an arbitrary package to populate it, since it should be the same for all
packages.
"""
version = known_versions.get(
package_to_distribution.get(package.name, package.name),
DEFAULT_VERSION,
)
lines = [f'version = "{version}"']
if package.py2_compatible or package.name in py2_packages:
# Note: for packages like six that appear in both normal and Python 2 only
# lists we force set python2 = true.
lines.append("python2 = true")
if not package.py3_compatible:
lines.append("python3 = false")
if package.requires:
distributions = [f'"types-{package_to_distribution.get(dep, dep)}"' for dep in package.requires]
lines.append(f"requires = [{', '.join(distributions)}]")
return "\n".join(lines)
def copy_third_party(packages: List[ThirdPartyPackage], py2_packages: List[ThirdPartyPackage]) -> None:
"""Refactor the third party part using collected metadata."""
third_party_dir = os.path.join(OUTPUT_DIR, THIRD_PARTY_NAMESPACE)
os.makedirs(third_party_dir, exist_ok=True)
# Note: these include Python 3 versions of packages like six.
for package in packages:
distribution = package_to_distribution.get(package.name, package.name)
distribution_dir = os.path.join(third_party_dir, distribution)
os.makedirs(distribution_dir, exist_ok=True)
metadata_file = os.path.join(distribution_dir, "METADATA.toml")
if not os.path.isfile(metadata_file):
# Write metadata once.
# TODO: check consistency between different packages in same distribution?
with open(metadata_file, "w") as f:
f.write(generate_metadata(package, [package.name for package in py2_packages]))
f.write("\n")
if not package.is_dir:
shutil.copy(package.path, distribution_dir)
else:
shutil.copytree(package.path, os.path.join(distribution_dir, package.name))
# Add Python 2 counterparts of packages like six (with different stubs) to nested
# namespaces like six/python2/six.
for package in py2_packages:
distribution = package_to_distribution.get(package.name, package.name)
distribution_dir = os.path.join(third_party_dir, distribution, PY2_NAMESPACE)
os.makedirs(distribution_dir, exist_ok=True)
if not package.is_dir:
shutil.copy(package.path, distribution_dir)
else:
shutil.copytree(package.path, os.path.join(distribution_dir, package.name))
def main() -> None:
# Collect metadata for Python 2 and 3, and Python 2 only standard library
# packages/modules. The latter will go to a separate nested namespace.
stdlib, py2_stdlib = collect_stdlib_packages()
third_party, py2_third_party = collect_third_party_packages()
# Collect standard library names to filter out from dependencies.
stdlib_names = [package.name for package in stdlib]
py2_stdlib_names = [package.name for package in py2_stdlib]
py2_stdlib_names += [package.name for package in stdlib if package.py_version == "2.7"]
# Collect all known distributions (for sanity checks).
known_distributions = {package_to_distribution.get(package.name, package.name) for package in third_party + py2_third_party}
# Compute dependencies between third party packages/modules to populate metadata.
for package in third_party + py2_third_party:
populate_requirements(package, stdlib_names, py2_stdlib_names, known_distributions)
# Copy the files to a separate location (to not clobber the root directory).
if not os.path.isdir(OUTPUT_DIR):
os.mkdir(OUTPUT_DIR)
copy_stdlib(stdlib, py2_stdlib)
copy_third_party(third_party, py2_third_party)
if __name__ == "__main__":
main()
| 13,437 | Python | .py | 285 | 40.477193 | 128 | 0.685649 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,468 | setup.py | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/setup.py | import os
from distutils.core import setup
from typing import List
from setuptools import find_packages
def find_stub_files(name: str) -> List[str]:
result = []
for root, dirs, files in os.walk(name):
for file in files:
if file.endswith('.pyi'):
if os.path.sep in root:
sub_root = root.split(os.path.sep, 1)[-1]
file = os.path.join(sub_root, file)
result.append(file)
return result
with open('README.md', 'r') as f:
readme = f.read()
dependencies = [
'mypy>=0.780,<0.790',
'typing-extensions',
'django',
]
setup(
name="django-stubs",
version="1.5.0",
description='Mypy stubs for Django',
long_description=readme,
long_description_content_type='text/markdown',
license='MIT',
url="https://github.com/typeddjango/django-stubs",
author="Maksim Kurnikov",
author_email="maxim.kurnikov@gmail.com",
py_modules=[],
python_requires='>=3.6',
install_requires=dependencies,
packages=['django-stubs', *find_packages(exclude=['scripts'])],
package_data={'django-stubs': find_stub_files('django-stubs')},
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8'
],
project_urls={
'Release notes': 'https://github.com/typeddjango/django-stubs/releases',
},
)
| 1,548 | Python | .py | 47 | 26.680851 | 80 | 0.621821 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,469 | flake8-pyi.ini | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/flake8-pyi.ini | [flake8]
filename =
*.pyi
exclude =
django-sources
test-data
mypy_django_plugin
scripts
select = F401, Y
max_line_length = 120
per-file-ignores =
*__init__.pyi: F401
base_user.pyi: Y003
models.pyi: Y003
| 233 | Python | .py | 14 | 13.5 | 23 | 0.675799 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,470 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/__init__.pyi | from typing import Any, NamedTuple
from .utils.version import get_version as get_version
VERSION: Any
__version__: str
def setup(set_prefix: bool = ...) -> None: ...
# Used by mypy_django_plugin when returning a QuerySet row that is a NamedTuple where the field names are unknown
class _NamedTupleAnyAttr(NamedTuple):
def __getattr__(self, item: str) -> Any: ...
def __setattr__(self, item: str, value: Any) -> None: ...
| 432 | Python | .py | 9 | 45.777778 | 113 | 0.711905 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,471 | shortcuts.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/shortcuts.pyi | import sys
from typing import Any, Callable, List, Mapping, Optional, overload, Protocol, Sequence, Type, TypeVar, Union
from django.db.models.base import Model
from django.http.response import (
HttpResponse as HttpResponse,
HttpResponseRedirect as HttpResponseRedirect,
HttpResponsePermanentRedirect as HttpResponsePermanentRedirect,
)
from django.db.models import Manager, QuerySet
from django.http import HttpRequest
if sys.version_info < (3, 8):
from typing_extensions import Literal
else:
from typing import Literal
def render_to_response(
template_name: Union[str, Sequence[str]],
context: Optional[Mapping[str, Any]] = ...,
content_type: Optional[str] = ...,
status: Optional[int] = ...,
using: Optional[str] = ...,
) -> HttpResponse: ...
def render(
request: HttpRequest,
template_name: Union[str, Sequence[str]],
context: Optional[Mapping[str, Any]] = ...,
content_type: Optional[str] = ...,
status: Optional[int] = ...,
using: Optional[str] = ...,
) -> HttpResponse: ...
class SupportsGetAbsoluteUrl(Protocol): ...
@overload
def redirect(
to: Union[Callable, str, SupportsGetAbsoluteUrl], *args: Any, permanent: Literal[True], **kwargs: Any
) -> HttpResponsePermanentRedirect: ...
@overload
def redirect(
to: Union[Callable, str, SupportsGetAbsoluteUrl], *args: Any, permanent: Literal[False], **kwargs: Any
) -> HttpResponseRedirect: ...
@overload
def redirect(
to: Union[Callable, str, SupportsGetAbsoluteUrl], *args: Any, permanent: bool = ..., **kwargs: Any
) -> Union[HttpResponseRedirect, HttpResponsePermanentRedirect]: ...
_T = TypeVar("_T", bound=Model)
def get_object_or_404(klass: Union[Type[_T], Manager[_T], QuerySet[_T]], *args: Any, **kwargs: Any) -> _T: ...
def get_list_or_404(klass: Union[Type[_T], Manager[_T], QuerySet[_T]], *args: Any, **kwargs: Any) -> List[_T]: ...
def resolve_url(to: Union[Callable, Model, str], *args: Any, **kwargs: Any) -> str: ...
| 1,972 | Python | .py | 46 | 40.043478 | 114 | 0.706465 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,472 | client.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/test/client.pyi | from io import BytesIO
from types import TracebackType
from typing import Any, Dict, List, Optional, Pattern, Tuple, Type, Union
from django.contrib.auth.models import AbstractUser
from django.contrib.sessions.backends.base import SessionBase
from django.core.handlers.base import BaseHandler
from django.http.cookie import SimpleCookie
from django.http.request import HttpRequest
from django.http.response import HttpResponse, HttpResponseBase
from django.core.handlers.wsgi import WSGIRequest
from json import JSONEncoder
BOUNDARY: str = ...
MULTIPART_CONTENT: str = ...
CONTENT_TYPE_RE: Pattern = ...
JSON_CONTENT_TYPE_RE: Pattern = ...
class RedirectCycleError(Exception):
last_response: HttpResponseBase = ...
redirect_chain: List[Tuple[str, int]] = ...
def __init__(self, message: str, last_response: HttpResponseBase) -> None: ...
class FakePayload:
read_started: bool = ...
def __init__(self, content: Optional[Union[bytes, str]] = ...) -> None: ...
def __len__(self) -> int: ...
def read(self, num_bytes: int = ...) -> bytes: ...
def write(self, content: Union[bytes, str]) -> None: ...
class ClientHandler(BaseHandler):
enforce_csrf_checks: bool = ...
def __init__(self, enforce_csrf_checks: bool = ..., *args: Any, **kwargs: Any) -> None: ...
def __call__(self, environ: Dict[str, Any]) -> HttpResponseBase: ...
def encode_multipart(boundary: str, data: Dict[str, Any]) -> bytes: ...
def encode_file(boundary: str, key: str, file: Any) -> List[bytes]: ...
class RequestFactory:
json_encoder: Type[JSONEncoder]
defaults: Dict[str, str]
cookies: SimpleCookie
errors: BytesIO
def __init__(self, *, json_encoder: Type[JSONEncoder] = ..., **defaults: Any) -> None: ...
def request(self, **request: Any) -> WSGIRequest: ...
def get(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> WSGIRequest: ...
def post(
self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
) -> WSGIRequest: ...
def head(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> WSGIRequest: ...
def trace(self, path: str, secure: bool = ..., **extra: Any) -> WSGIRequest: ...
def options(
self,
path: str,
data: Union[Dict[str, str], str] = ...,
content_type: str = ...,
follow: bool = ...,
secure: bool = ...,
**extra: Any
) -> WSGIRequest: ...
def put(
self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
) -> WSGIRequest: ...
def patch(
self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
) -> WSGIRequest: ...
def delete(
self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any
) -> WSGIRequest: ...
def generic(
self,
method: str,
path: str,
data: Any = ...,
content_type: Optional[str] = ...,
secure: bool = ...,
**extra: Any
) -> WSGIRequest: ...
class Client(RequestFactory):
handler: ClientHandler
raise_request_exception: bool
exc_info: Optional[Tuple[Type[BaseException], BaseException, TracebackType]]
def __init__(
self,
enforce_csrf_checks: bool = ...,
raise_request_exception: bool = ...,
*,
json_encoder: Type[JSONEncoder] = ...,
**defaults: Any
) -> None: ...
# Silence type warnings, since this class overrides arguments and return types in an unsafe manner.
def request(self, **request: Any) -> HttpResponse: ... # type: ignore
def get( # type: ignore
self, path: str, data: Any = ..., follow: bool = ..., secure: bool = ..., **extra: Any
) -> HttpResponse: ... # type: ignore
def post( # type: ignore
self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any
) -> HttpResponse: ... # type: ignore
def head( # type: ignore
self, path: str, data: Any = ..., follow: bool = ..., secure: bool = ..., **extra: Any
) -> HttpResponse: ... # type: ignore
def trace( # type: ignore
self, path: str, follow: bool = ..., secure: bool = ..., **extra: Any
) -> HttpResponse: ... # type: ignore
def options( # type: ignore
self,
path: str,
data: Union[Dict[str, str], str] = ...,
content_type: str = ...,
follow: bool = ...,
secure: bool = ...,
**extra: Any
) -> HttpResponse: ... # type: ignore
def put( # type: ignore
self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any
) -> HttpResponse: ... # type: ignore
def patch( # type: ignore
self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any
) -> HttpResponse: ... # type: ignore
def delete( # type: ignore
self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any
) -> HttpResponse: ... # type: ignore
def store_exc_info(self, **kwargs: Any) -> None: ...
@property
def session(self) -> SessionBase: ...
def login(self, **credentials: Any) -> bool: ...
def force_login(self, user: AbstractUser, backend: Optional[str] = ...) -> None: ...
def logout(self) -> None: ...
def conditional_content_removal(request: HttpRequest, response: HttpResponseBase) -> HttpResponse: ...
| 5,593 | Python | .py | 122 | 40.270492 | 119 | 0.58872 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,473 | selenium.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/test/selenium.pyi | from typing import Any
from django.test import LiveServerTestCase
class SeleniumTestCaseBase:
browsers: Any = ...
browser: Any = ...
@classmethod
def import_webdriver(cls, browser: Any): ...
def create_webdriver(self): ...
class SeleniumTestCase(LiveServerTestCase):
implicit_wait: int = ...
def disable_implicit_wait(self) -> None: ...
| 368 | Python | .py | 11 | 29.636364 | 48 | 0.70904 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,474 | signals.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/test/signals.pyi | from typing import Any
from django.core.signals import setting_changed as setting_changed # noqa: F401
template_rendered: Any
COMPLEX_OVERRIDE_SETTINGS: Any
def clear_cache_handlers(**kwargs: Any) -> None: ...
def update_installed_apps(**kwargs: Any) -> None: ...
def update_connections_time_zone(**kwargs: Any) -> None: ...
def clear_routers_cache(**kwargs: Any) -> None: ...
def reset_template_engines(**kwargs: Any) -> None: ...
def clear_serializers_cache(**kwargs: Any) -> None: ...
def language_changed(**kwargs: Any) -> None: ...
def localize_settings_changed(**kwargs: Any) -> None: ...
def file_storage_changed(**kwargs: Any) -> None: ...
def complex_setting_changed(**kwargs: Any) -> None: ...
def root_urlconf_changed(**kwargs: Any) -> None: ...
def static_storage_changed(**kwargs: Any) -> None: ...
def static_finders_changed(**kwargs: Any) -> None: ...
def auth_password_validators_changed(**kwargs: Any) -> None: ...
def user_model_swapped(**kwargs: Any) -> None: ...
| 986 | Python | .py | 19 | 50.789474 | 80 | 0.693264 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,475 | utils.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/test/utils.pyi | import decimal
from contextlib import contextmanager
from decimal import Decimal
from io import StringIO
from typing import (
Any,
Callable,
Dict,
Iterable,
Iterator,
List,
Mapping,
Optional,
Set,
Tuple,
Type,
Union,
ContextManager,
TypeVar,
)
from django.apps.registry import Apps
from django.core.checks.registry import CheckRegistry
from django.db.models.lookups import Lookup, Transform
from django.db.models.query_utils import RegisterLookupMixin
from django.test.runner import DiscoverRunner
from django.test.testcases import SimpleTestCase
from django.conf import LazySettings, Settings
_TestClass = Type[SimpleTestCase]
_DecoratedTest = Union[Callable, _TestClass]
_C = TypeVar("_C", bound=Callable) # Any callable
TZ_SUPPORT: bool = ...
class Approximate:
val: Union[decimal.Decimal, float] = ...
places: int = ...
def __init__(self, val: Union[Decimal, float], places: int = ...) -> None: ...
class ContextList(list):
def get(self, key: str, default: Optional[str] = ...) -> str: ...
def keys(self) -> Set[str]: ...
class _TestState: ...
def setup_test_environment(debug: Optional[bool] = ...) -> None: ...
def teardown_test_environment() -> None: ...
def get_runner(settings: LazySettings, test_runner_class: Optional[str] = ...) -> Type[DiscoverRunner]: ...
class TestContextDecorator:
attr_name: Optional[str] = ...
kwarg_name: Optional[str] = ...
def __init__(self, attr_name: Optional[str] = ..., kwarg_name: Optional[str] = ...) -> None: ...
def enable(self) -> Any: ...
def disable(self) -> None: ...
def __enter__(self) -> Optional[Apps]: ...
def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ...
def decorate_class(self, cls: _TestClass) -> _TestClass: ...
def decorate_callable(self, func: _C) -> _C: ...
def __call__(self, decorated: _DecoratedTest) -> Any: ...
class override_settings(TestContextDecorator):
options: Dict[str, Any] = ...
def __init__(self, **kwargs: Any) -> None: ...
wrapped: Settings = ...
def save_options(self, test_func: _DecoratedTest) -> None: ...
def decorate_class(self, cls: type) -> type: ...
class modify_settings(override_settings):
wrapped: Settings
operations: List[Tuple[str, Dict[str, Union[List[str], str]]]] = ...
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
def save_options(self, test_func: _DecoratedTest) -> None: ...
options: Dict[str, List[Union[Tuple[str, str], str]]] = ...
class override_system_checks(TestContextDecorator):
registry: CheckRegistry = ...
new_checks: List[Callable] = ...
deployment_checks: Optional[List[Callable]] = ...
def __init__(self, new_checks: List[Callable], deployment_checks: Optional[List[Callable]] = ...) -> None: ...
old_checks: Set[Callable] = ...
old_deployment_checks: Set[Callable] = ...
class CaptureQueriesContext:
connection: Any = ...
force_debug_cursor: bool = ...
initial_queries: int = ...
final_queries: Optional[int] = ...
def __init__(self, connection: Any) -> None: ...
def __iter__(self): ...
def __getitem__(self, index: int) -> Dict[str, str]: ...
def __len__(self) -> int: ...
@property
def captured_queries(self) -> List[Dict[str, str]]: ...
def __enter__(self) -> CaptureQueriesContext: ...
def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ...
class ignore_warnings(TestContextDecorator):
ignore_kwargs: Dict[str, Any] = ...
filter_func: Callable = ...
def __init__(self, **kwargs: Any) -> None: ...
catch_warnings: ContextManager[Optional[list]] = ...
requires_tz_support: Any
def isolate_lru_cache(lru_cache_object: Callable) -> Iterator[None]: ...
class override_script_prefix(TestContextDecorator):
prefix: str = ...
def __init__(self, prefix: str) -> None: ...
old_prefix: str = ...
class LoggingCaptureMixin:
logger: Any = ...
old_stream: Any = ...
logger_output: Any = ...
def setUp(self) -> None: ...
def tearDown(self) -> None: ...
class isolate_apps(TestContextDecorator):
installed_apps: Tuple[str] = ...
def __init__(self, *installed_apps: Any, **kwargs: Any) -> None: ...
old_apps: Apps = ...
@contextmanager
def extend_sys_path(*paths: str) -> Iterator[None]: ...
@contextmanager
def captured_output(stream_name) -> Iterator[StringIO]: ...
@contextmanager
def captured_stdin() -> Iterator[StringIO]: ...
@contextmanager
def captured_stdout() -> Iterator[StringIO]: ...
@contextmanager
def captured_stderr() -> Iterator[StringIO]: ...
@contextmanager
def freeze_time(t: float) -> Iterator[None]: ...
def tag(*tags: str): ...
_Signature = str
_TestDatabase = Tuple[str, List[str]]
def dependency_ordered(
test_databases: Iterable[Tuple[_Signature, _TestDatabase]], dependencies: Mapping[str, List[str]]
) -> List[Tuple[_Signature, _TestDatabase]]: ...
def get_unique_databases_and_mirrors() -> Tuple[Dict[_Signature, _TestDatabase], Dict[str, Any]]: ...
def teardown_databases(
old_config: Iterable[Tuple[Any, str, bool]], verbosity: int, parallel: int = ..., keepdb: bool = ...
) -> None: ...
def require_jinja2(test_func: _C) -> _C: ...
@contextmanager
def register_lookup(
field: Type[RegisterLookupMixin], *lookups: Type[Union[Lookup, Transform]], lookup_name: Optional[str] = ...
) -> Iterator[None]: ...
| 5,436 | Python | .py | 133 | 37.451128 | 114 | 0.66067 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,476 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/test/__init__.pyi | from .testcases import (
TestCase as TestCase,
TransactionTestCase as TransactionTestCase,
SimpleTestCase as SimpleTestCase,
LiveServerTestCase as LiveServerTestCase,
skipIfDBFeature as skipIfDBFeature,
skipUnlessDBFeature as skipUnlessDBFeature,
skipUnlessAnyDBFeature as skipUnlessAnyDBFeature,
)
from .utils import (
override_settings as override_settings,
modify_settings as modify_settings,
override_script_prefix as override_script_prefix,
override_system_checks as override_system_checks,
ignore_warnings as ignore_warnings,
tag as tag,
)
from .client import Client as Client, RequestFactory as RequestFactory
| 671 | Python | .py | 18 | 33.277778 | 70 | 0.804916 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,477 | runner.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/test/runner.pyi | import logging
from argparse import ArgumentParser
from io import StringIO
from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type
from unittest import TestCase, TestSuite, TextTestResult
from django.db.backends.base.base import BaseDatabaseWrapper
from django.test.testcases import SimpleTestCase, TestCase
from django.utils.datastructures import OrderedSet
class DebugSQLTextTestResult(TextTestResult):
buffer: bool
descriptions: bool
dots: bool
expectedFailures: List[Any]
failfast: bool
shouldStop: bool
showAll: bool
skipped: List[Any]
tb_locals: bool
testsRun: int
unexpectedSuccesses: List[Any]
logger: logging.Logger = ...
def __init__(self, stream: Any, descriptions: bool, verbosity: int) -> None: ...
debug_sql_stream: StringIO = ...
handler: logging.StreamHandler = ...
def startTest(self, test: TestCase) -> None: ...
def stopTest(self, test: TestCase) -> None: ...
def addError(self, test: Any, err: Any) -> None: ...
def addFailure(self, test: Any, err: Any) -> None: ...
class RemoteTestResult:
events: List[Any] = ...
failfast: bool = ...
shouldStop: bool = ...
testsRun: int = ...
def __init__(self) -> None: ...
@property
def test_index(self): ...
def check_picklable(self, test: Any, err: Any) -> None: ...
def _confirm_picklable(self, obj: Any) -> None: ...
def check_subtest_picklable(self, test: Any, subtest: Any) -> None: ...
def stop_if_failfast(self) -> None: ...
def stop(self) -> None: ...
def startTestRun(self) -> None: ...
def stopTestRun(self) -> None: ...
def startTest(self, test: Any) -> None: ...
def stopTest(self, test: Any) -> None: ...
def addError(self, test: Any, err: Any) -> None: ...
def addFailure(self, test: Any, err: Any) -> None: ...
def addSubTest(self, test: Any, subtest: Any, err: Any) -> None: ...
def addSuccess(self, test: Any) -> None: ...
def addSkip(self, test: Any, reason: Any) -> None: ...
def addExpectedFailure(self, test: Any, err: Any) -> None: ...
def addUnexpectedSuccess(self, test: Any) -> None: ...
class RemoteTestRunner:
resultclass: Any = ...
failfast: Any = ...
def __init__(self, failfast: bool = ..., resultclass: Optional[Any] = ...) -> None: ...
def run(self, test: Any): ...
def default_test_processes() -> int: ...
class ParallelTestSuite(TestSuite):
init_worker: Any = ...
run_subsuite: Any = ...
runner_class: Any = ...
subsuites: Any = ...
processes: Any = ...
failfast: Any = ...
def __init__(self, suite: Any, processes: Any, failfast: bool = ...) -> None: ...
def run(self, result: Any): ...
class DiscoverRunner:
test_suite: Any = ...
parallel_test_suite: Any = ...
test_runner: Any = ...
test_loader: Any = ...
reorder_by: Any = ...
pattern: Optional[str] = ...
top_level: None = ...
verbosity: int = ...
interactive: bool = ...
failfast: bool = ...
keepdb: bool = ...
reverse: bool = ...
debug_mode: bool = ...
debug_sql: bool = ...
parallel: int = ...
tags: Set[str] = ...
exclude_tags: Set[str] = ...
def __init__(
self,
pattern: Optional[str] = ...,
top_level: None = ...,
verbosity: int = ...,
interactive: bool = ...,
failfast: bool = ...,
keepdb: bool = ...,
reverse: bool = ...,
debug_mode: bool = ...,
debug_sql: bool = ...,
parallel: int = ...,
tags: Optional[List[str]] = ...,
exclude_tags: Optional[List[str]] = ...,
**kwargs: Any
) -> None: ...
@classmethod
def add_arguments(cls, parser: ArgumentParser) -> None: ...
def setup_test_environment(self, **kwargs: Any) -> None: ...
def build_suite(
self, test_labels: Sequence[str] = ..., extra_tests: Optional[List[Any]] = ..., **kwargs: Any
) -> TestSuite: ...
def setup_databases(self, **kwargs: Any) -> List[Tuple[BaseDatabaseWrapper, str, bool]]: ...
def get_resultclass(self) -> Optional[Type[DebugSQLTextTestResult]]: ...
def get_test_runner_kwargs(self) -> Dict[str, Optional[int]]: ...
def run_checks(self) -> None: ...
def run_suite(self, suite: TestSuite, **kwargs: Any) -> TextTestResult: ...
def teardown_databases(self, old_config: List[Tuple[BaseDatabaseWrapper, str, bool]], **kwargs: Any) -> None: ...
def teardown_test_environment(self, **kwargs: Any) -> None: ...
def suite_result(self, suite: TestSuite, result: TextTestResult, **kwargs: Any) -> int: ...
def run_tests(self, test_labels: List[str], extra_tests: List[Any] = ..., **kwargs: Any) -> int: ...
def is_discoverable(label: str) -> bool: ...
def reorder_suite(
suite: TestSuite, classes: Tuple[Type[TestCase], Type[SimpleTestCase]], reverse: bool = ...
) -> TestSuite: ...
def partition_suite_by_type(
suite: TestSuite, classes: Tuple[Type[TestCase], Type[SimpleTestCase]], bins: List[OrderedSet], reverse: bool = ...
) -> None: ...
def partition_suite_by_case(suite: Any): ...
def filter_tests_by_tags(suite: TestSuite, tags: Set[str], exclude_tags: Set[str]) -> TestSuite: ...
| 5,210 | Python | .py | 125 | 36.808 | 119 | 0.615521 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,478 | html.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/test/html.pyi | from html.parser import HTMLParser
from typing import Any, List, Optional, Sequence, Tuple, TypeVar, Union
_Self = TypeVar("_Self")
WHITESPACE: Any
def normalize_whitespace(string: str) -> str: ...
_ElementAttribute = Tuple[str, Optional[str]]
class Element:
name: Optional[str] = ...
attributes: List[_ElementAttribute] = ...
children: List[Any] = ...
def __init__(self, name: Optional[str], attributes: Sequence[_ElementAttribute]) -> None: ...
def append(self, element: Union[Element, str]) -> None: ...
def finalize(self) -> None: ...
def __contains__(self, element: Union[Element, str]) -> bool: ...
def count(self, element: Union[Element, str]) -> int: ...
def __getitem__(self, key: int) -> Any: ...
class RootElement(Element):
def __init__(self) -> None: ...
class HTMLParseError(Exception): ...
class Parser(HTMLParser):
SELF_CLOSING_TAGS: Any = ...
root: Any = ...
open_tags: Any = ...
element_positions: Any = ...
def __init__(self) -> None: ...
def format_position(self, position: Any = ..., element: Any = ...) -> str: ...
@property
def current(self) -> Element: ...
def parse_html(html: str) -> Element: ...
| 1,203 | Python | .py | 29 | 37.689655 | 97 | 0.630901 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,479 | testcases.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/test/testcases.pyi | import threading
import unittest
from datetime import date
from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, Union, ClassVar, overload
from django.core.exceptions import ImproperlyConfigured
from django.core.handlers.wsgi import WSGIHandler
from django.core.servers.basehttp import ThreadedWSGIServer, WSGIRequestHandler
from django.db.backends.sqlite3.base import DatabaseWrapper
from django.db.models.base import Model
from django.db.models.query import QuerySet, RawQuerySet
from django.forms.fields import EmailField
from django.http.response import HttpResponse, HttpResponseBase
from django.template.base import Template
from django.test.client import Client
from django.test.utils import CaptureQueriesContext, ContextList
from django.utils.safestring import SafeText
from django.db import connections as connections # noqa: F401
class _AssertNumQueriesContext(CaptureQueriesContext):
test_case: SimpleTestCase = ...
num: int = ...
def __init__(self, test_case: Any, num: Any, connection: Any) -> None: ...
class _AssertTemplateUsedContext:
test_case: SimpleTestCase = ...
template_name: str = ...
rendered_templates: List[Template] = ...
rendered_template_names: List[str] = ...
context: ContextList = ...
def __init__(self, test_case: Any, template_name: Any) -> None: ...
def on_template_render(self, sender: Any, signal: Any, template: Any, context: Any, **kwargs: Any) -> None: ...
def test(self): ...
def message(self): ...
def __enter__(self): ...
def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any): ...
class _AssertTemplateNotUsedContext(_AssertTemplateUsedContext): ...
class _CursorFailure:
cls_name: str = ...
wrapped: Callable = ...
def __init__(self, cls_name: Any, wrapped: Any) -> None: ...
def __call__(self) -> None: ...
class SimpleTestCase(unittest.TestCase):
client_class: Any = ...
client: Client
allow_database_queries: bool = ...
# TODO: str -> Literal['__all__']
databases: Union[Set[str], str] = ...
def __call__(self, result: Optional[unittest.TestResult] = ...) -> None: ...
def settings(self, **kwargs: Any) -> Any: ...
def modify_settings(self, **kwargs: Any) -> Any: ...
def assertRedirects(
self,
response: HttpResponse,
expected_url: str,
status_code: int = ...,
target_status_code: int = ...,
msg_prefix: str = ...,
fetch_redirect_response: bool = ...,
) -> None: ...
def assertContains(
self,
response: HttpResponseBase,
text: Union[bytes, int, str],
count: Optional[int] = ...,
status_code: int = ...,
msg_prefix: str = ...,
html: bool = ...,
) -> None: ...
def assertNotContains(
self,
response: HttpResponse,
text: Union[bytes, str],
status_code: int = ...,
msg_prefix: str = ...,
html: bool = ...,
) -> None: ...
def assertFormError(
self,
response: HttpResponse,
form: str,
field: Optional[str],
errors: Union[List[str], str],
msg_prefix: str = ...,
) -> None: ...
def assertFormsetError(
self,
response: HttpResponse,
formset: str,
form_index: Optional[int],
field: Optional[str],
errors: Union[List[str], str],
msg_prefix: str = ...,
) -> None: ...
def assertTemplateUsed(
self,
response: Optional[Union[HttpResponse, str]] = ...,
template_name: Optional[str] = ...,
msg_prefix: str = ...,
count: Optional[int] = ...,
) -> Optional[_AssertTemplateUsedContext]: ...
def assertTemplateNotUsed(
self, response: Union[HttpResponse, str] = ..., template_name: Optional[str] = ..., msg_prefix: str = ...
) -> Optional[_AssertTemplateNotUsedContext]: ...
def assertRaisesMessage(
self, expected_exception: Type[Exception], expected_message: str, *args: Any, **kwargs: Any
) -> Any: ...
def assertWarnsMessage(
self, expected_warning: Type[Exception], expected_message: str, *args: Any, **kwargs: Any
) -> Any: ...
def assertFieldOutput(
self,
fieldclass: Type[EmailField],
valid: Dict[str, str],
invalid: Dict[str, List[str]],
field_args: None = ...,
field_kwargs: None = ...,
empty_value: str = ...,
) -> Any: ...
def assertHTMLEqual(self, html1: str, html2: str, msg: Optional[str] = ...) -> None: ...
def assertHTMLNotEqual(self, html1: str, html2: str, msg: Optional[str] = ...) -> None: ...
def assertInHTML(
self, needle: str, haystack: SafeText, count: Optional[int] = ..., msg_prefix: str = ...
) -> None: ...
def assertJSONEqual(
self,
raw: str,
expected_data: Union[Dict[str, Any], List[Any], str, int, float, bool, None],
msg: Optional[str] = ...,
) -> None: ...
def assertJSONNotEqual(
self,
raw: str,
expected_data: Union[Dict[str, Any], List[Any], str, int, float, bool, None],
msg: Optional[str] = ...,
) -> None: ...
def assertXMLEqual(self, xml1: str, xml2: str, msg: Optional[str] = ...) -> None: ...
def assertXMLNotEqual(self, xml1: str, xml2: str, msg: Optional[str] = ...) -> None: ...
class TransactionTestCase(SimpleTestCase):
reset_sequences: bool = ...
available_apps: Any = ...
fixtures: Any = ...
multi_db: bool = ...
serialized_rollback: bool = ...
def assertQuerysetEqual(
self,
qs: Union[Iterator[Any], List[Model], QuerySet, RawQuerySet],
values: Union[List[None], List[Tuple[str, str]], List[date], List[int], List[str], Set[str], QuerySet],
transform: Union[Callable, Type[str]] = ...,
ordered: bool = ...,
msg: Optional[str] = ...,
) -> None: ...
@overload
def assertNumQueries(
self, num: int, func: Callable[..., Any], *args: Any, using: str = ..., **kwargs: Any
) -> None: ...
@overload
def assertNumQueries(
self, num: int, func: None = ..., *args: Any, using: str = ..., **kwargs: Any
) -> _AssertNumQueriesContext: ...
class TestCase(TransactionTestCase):
@classmethod
def setUpTestData(cls) -> None: ...
class CheckCondition:
conditions: Tuple[Tuple[Callable, str]] = ...
def __init__(self, *conditions: Any) -> None: ...
def add_condition(self, condition: Callable, reason: str) -> CheckCondition: ...
def __get__(self, instance: None, cls: Type[TransactionTestCase] = ...) -> bool: ...
def skipIfDBFeature(*features: Any) -> Callable: ...
def skipUnlessDBFeature(*features: Any) -> Callable: ...
def skipUnlessAnyDBFeature(*features: Any) -> Callable: ...
class QuietWSGIRequestHandler(WSGIRequestHandler): ...
class FSFilesHandler(WSGIHandler):
application: Any = ...
base_url: Any = ...
def __init__(self, application: Any) -> None: ...
def file_path(self, url: Any): ...
def serve(self, request: Any): ...
class _StaticFilesHandler(FSFilesHandler):
def get_base_dir(self): ...
def get_base_url(self): ...
class _MediaFilesHandler(FSFilesHandler):
def get_base_dir(self): ...
def get_base_url(self): ...
class LiveServerThread(threading.Thread):
host: str = ...
port: int = ...
is_ready: threading.Event = ...
error: Optional[ImproperlyConfigured] = ...
static_handler: Type[WSGIHandler] = ...
connections_override: Dict[str, Any] = ...
def __init__(
self,
host: str,
static_handler: Type[WSGIHandler],
connections_override: Dict[str, DatabaseWrapper] = ...,
port: int = ...,
) -> None: ...
httpd: ThreadedWSGIServer = ...
def terminate(self) -> None: ...
class LiveServerTestCase(TransactionTestCase):
live_server_url: ClassVar[str]
host: str = ...
port: int = ...
server_thread_class: Type[Any] = ...
server_thread: Any
static_handler: Any = ...
class SerializeMixin:
lockfile: Any = ...
@classmethod
def setUpClass(cls) -> None: ...
@classmethod
def tearDownClass(cls) -> None: ...
def connections_support_transactions() -> bool: ...
| 8,273 | Python | .py | 211 | 33.478673 | 115 | 0.620214 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,480 | dispatcher.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/dispatch/dispatcher.pyi | from typing import Any, Callable, List, Optional, Tuple, Union
NONE_ID: Any
NO_RECEIVERS: Any
class Signal:
receivers: Any = ...
providing_args: Any = ...
lock: Any = ...
use_caching: Any = ...
sender_receivers_cache: Any = ...
def __init__(self, providing_args: List[str] = ..., use_caching: bool = ...) -> None: ...
def connect(
self, receiver: Callable, sender: Optional[object] = ..., weak: bool = ..., dispatch_uid: Optional[str] = ...
) -> None: ...
def disconnect(
self, receiver: Optional[Callable] = ..., sender: Optional[object] = ..., dispatch_uid: Optional[str] = ...
) -> bool: ...
def has_listeners(self, sender: Any = ...) -> bool: ...
def send(self, sender: Any, **named: Any) -> List[Tuple[Callable, Optional[str]]]: ...
def send_robust(self, sender: Any, **named: Any) -> List[Tuple[Callable, Union[ValueError, str]]]: ...
def receiver(signal: Union[List[Signal], Signal], **kwargs: Any) -> Callable: ...
| 994 | Python | .py | 20 | 45.15 | 117 | 0.603502 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,481 | cache.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/templatetags/cache.pyi | from typing import Any, List, Optional
from django.template.base import FilterExpression, NodeList, Parser, Token
from django.template import Node
register: Any
class CacheNode(Node):
nodelist: NodeList = ...
expire_time_var: FilterExpression = ...
fragment_name: str = ...
vary_on: List[FilterExpression] = ...
cache_name: Optional[FilterExpression] = ...
def __init__(
self,
nodelist: NodeList,
expire_time_var: FilterExpression,
fragment_name: str,
vary_on: List[FilterExpression],
cache_name: Optional[FilterExpression],
) -> None: ...
def do_cache(parser: Parser, token: Token) -> CacheNode: ...
| 682 | Python | .py | 19 | 30.631579 | 74 | 0.676292 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,482 | i18n.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/templatetags/i18n.pyi | from typing import Any, Dict, List, Optional, Tuple
from django.template.base import FilterExpression, NodeList, Parser, Token
from django.template import Node
register: Any
class GetAvailableLanguagesNode(Node):
variable: str = ...
def __init__(self, variable: str) -> None: ...
class GetLanguageInfoNode(Node):
lang_code: FilterExpression = ...
variable: str = ...
def __init__(self, lang_code: FilterExpression, variable: str) -> None: ...
class GetLanguageInfoListNode(Node):
languages: FilterExpression = ...
variable: str = ...
def __init__(self, languages: FilterExpression, variable: str) -> None: ...
def get_language_info(self, language: Any): ...
class GetCurrentLanguageNode(Node):
variable: str = ...
def __init__(self, variable: str) -> None: ...
class GetCurrentLanguageBidiNode(Node):
variable: str = ...
def __init__(self, variable: str) -> None: ...
class TranslateNode(Node):
noop: bool = ...
asvar: Optional[str] = ...
message_context: Optional[FilterExpression] = ...
filter_expression: FilterExpression = ...
def __init__(
self,
filter_expression: FilterExpression,
noop: bool,
asvar: Optional[str] = ...,
message_context: Optional[FilterExpression] = ...,
) -> None: ...
class BlockTranslateNode(Node):
extra_context: Dict[str, FilterExpression] = ...
singular: List[Token] = ...
plural: List[Token] = ...
countervar: Optional[str] = ...
counter: Optional[FilterExpression] = ...
message_context: Optional[FilterExpression] = ...
trimmed: bool = ...
asvar: Optional[str] = ...
def __init__(
self,
extra_context: Dict[str, FilterExpression],
singular: List[Token],
plural: List[Token] = ...,
countervar: Optional[str] = ...,
counter: Optional[FilterExpression] = ...,
message_context: Optional[FilterExpression] = ...,
trimmed: bool = ...,
asvar: Optional[str] = ...,
) -> None: ...
def render_token_list(self, tokens: List[Token]) -> Tuple[str, List[str]]: ...
class LanguageNode(Node):
nodelist: NodeList = ...
language: FilterExpression = ...
def __init__(self, nodelist: NodeList, language: FilterExpression) -> None: ...
def do_get_available_languages(parser: Parser, token: Token) -> GetAvailableLanguagesNode: ...
def do_get_language_info(parser: Parser, token: Token) -> GetLanguageInfoNode: ...
def do_get_language_info_list(parser: Parser, token: Token) -> GetLanguageInfoListNode: ...
def language_name(lang_code: str) -> str: ...
def language_name_translated(lang_code: str) -> str: ...
def language_name_local(lang_code: str) -> str: ...
def language_bidi(lang_code: str) -> bool: ...
def do_get_current_language(parser: Parser, token: Token) -> GetCurrentLanguageNode: ...
def do_get_current_language_bidi(parser: Parser, token: Token) -> GetCurrentLanguageBidiNode: ...
def do_translate(parser: Parser, token: Token) -> TranslateNode: ...
def do_block_translate(parser: Parser, token: Token) -> BlockTranslateNode: ...
def language(parser: Parser, token: Token) -> LanguageNode: ...
| 3,176 | Python | .py | 71 | 40.126761 | 97 | 0.66311 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,483 | tz.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/templatetags/tz.pyi | from datetime import datetime
from typing import Any, Optional, Union
from django.template.base import FilterExpression, NodeList, Parser, Token
from django.utils.timezone import FixedOffset
from django.template import Node
register: Any
class datetimeobject(datetime): ...
def localtime(value: Optional[Union[datetime, str]]) -> Any: ...
def utc(value: Optional[Union[datetime, str]]) -> Any: ...
def do_timezone(value: Optional[Union[datetime, str]], arg: Optional[Union[FixedOffset, str]]) -> Any: ...
class LocalTimeNode(Node):
nodelist: NodeList = ...
use_tz: bool = ...
def __init__(self, nodelist: NodeList, use_tz: bool) -> None: ...
class TimezoneNode(Node):
nodelist: NodeList = ...
tz: FilterExpression = ...
def __init__(self, nodelist: NodeList, tz: FilterExpression) -> None: ...
class GetCurrentTimezoneNode(Node):
variable: str = ...
def __init__(self, variable: str) -> None: ...
def localtime_tag(parser: Parser, token: Token) -> LocalTimeNode: ...
def timezone_tag(parser: Parser, token: Token) -> TimezoneNode: ...
def get_current_timezone_tag(parser: Parser, token: Token) -> GetCurrentTimezoneNode: ...
| 1,166 | Python | .py | 24 | 45.875 | 106 | 0.714034 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,484 | l10n.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/templatetags/l10n.pyi | from typing import Any, List
from django.template.base import Parser, Token
from django.template import Node
register: Any
def localize(value: Any) -> str: ...
def unlocalize(value: Any) -> str: ...
class LocalizeNode(Node):
nodelist: List[Node] = ...
use_l10n: bool = ...
def __init__(self, nodelist: List[Node], use_l10n: bool) -> None: ...
def localize_tag(parser: Parser, token: Token) -> LocalizeNode: ...
| 429 | Python | .py | 11 | 36.363636 | 73 | 0.691748 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,485 | static.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/templatetags/static.pyi | from typing import Any, Optional
from django.template.base import FilterExpression, Parser, Token
from django.template.context import Context
from django import template
register: Any
class PrefixNode(template.Node):
varname: Optional[str] = ...
name: str = ...
def __init__(self, varname: Optional[str] = ..., name: str = ...) -> None: ...
@classmethod
def handle_token(cls, parser: Parser, token: Token, name: str) -> PrefixNode: ...
@classmethod
def handle_simple(cls, name: str) -> str: ...
def get_static_prefix(parser: Parser, token: Token) -> PrefixNode: ...
def get_media_prefix(parser: Parser, token: Token) -> PrefixNode: ...
class StaticNode(template.Node):
path: FilterExpression = ...
varname: Optional[str] = ...
def __init__(self, varname: Optional[str] = ..., path: FilterExpression = ...) -> None: ...
def url(self, context: Context) -> str: ...
@classmethod
def handle_simple(cls, path: str) -> str: ...
@classmethod
def handle_token(cls, parser: Parser, token: Token) -> StaticNode: ...
def do_static(parser: Parser, token: Token) -> StaticNode: ...
def static(path: str) -> str: ...
| 1,170 | Python | .py | 26 | 41.423077 | 95 | 0.666667 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,486 | utils.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/utils.pyi | from typing import Any, Dict, Iterable, List, Optional
DEFAULT_DB_ALIAS: str
DJANGO_VERSION_PICKLE_KEY: str
class Error(Exception): ...
class InterfaceError(Error): ...
class DatabaseError(Error): ...
class DataError(DatabaseError): ...
class OperationalError(DatabaseError): ...
class IntegrityError(DatabaseError): ...
class InternalError(DatabaseError): ...
class ProgrammingError(DatabaseError): ...
class NotSupportedError(DatabaseError): ...
def load_backend(backend_name: str) -> Any: ...
class ConnectionDoesNotExist(Exception): ...
class ConnectionHandler:
databases: Dict[str, Dict[str, Optional[Any]]]
def __init__(self, databases: Dict[str, Dict[str, Optional[Any]]] = ...) -> None: ...
def ensure_defaults(self, alias: str) -> None: ...
def prepare_test_settings(self, alias: str) -> None: ...
def __getitem__(self, alias: str) -> Any: ...
def __setitem__(self, key: Any, value: Any) -> None: ...
def __delitem__(self, key: Any) -> None: ...
def __iter__(self): ...
def all(self) -> List[Any]: ...
def close_all(self) -> None: ...
class ConnectionRouter:
def __init__(self, routers: Optional[Iterable[Any]] = ...) -> None: ...
@property
def routers(self) -> List[Any]: ...
| 1,244 | Python | .py | 29 | 39.896552 | 89 | 0.666667 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,487 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/__init__.pyi | from typing import Any
from .utils import (
DEFAULT_DB_ALIAS as DEFAULT_DB_ALIAS,
DJANGO_VERSION_PICKLE_KEY as DJANGO_VERSION_PICKLE_KEY,
ProgrammingError as ProgrammingError,
IntegrityError as IntegrityError,
OperationalError as OperationalError,
DatabaseError as DatabaseError,
DataError as DataError,
NotSupportedError as NotSupportedError,
InternalError as InternalError,
InterfaceError as InterfaceError,
ConnectionHandler as ConnectionHandler,
Error as Error,
ConnectionDoesNotExist as ConnectionDoesNotExist,
)
from . import migrations
connections: Any
router: Any
connection: Any
class DefaultConnectionProxy:
def __getattr__(self, item: str) -> Any: ...
def __setattr__(self, name: str, value: Any) -> None: ...
def __delattr__(self, name: str) -> None: ...
def close_old_connections(**kwargs: Any) -> None: ...
def reset_queries(**kwargs: Any) -> None: ...
| 936 | Python | .py | 26 | 32.346154 | 61 | 0.742541 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,488 | transaction.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/transaction.pyi | from contextlib import contextmanager
from typing import Any, Callable, Optional, overload, TypeVar, Iterator
from django.db import ProgrammingError
class TransactionManagementError(ProgrammingError): ...
def get_connection(using: Optional[str] = ...) -> Any: ...
def get_autocommit(using: Optional[str] = ...) -> bool: ...
def set_autocommit(autocommit: bool, using: Optional[str] = ...) -> Any: ...
def commit(using: Optional[str] = ...) -> Any: ...
def rollback(using: Optional[str] = ...) -> Any: ...
def savepoint(using: Optional[str] = ...) -> str: ...
def savepoint_rollback(sid: str, using: Optional[str] = ...) -> None: ...
def savepoint_commit(sid: Any, using: Optional[Any] = ...) -> None: ...
def clean_savepoints(using: Optional[Any] = ...) -> None: ...
def get_rollback(using: Optional[str] = ...) -> bool: ...
def set_rollback(rollback: bool, using: Optional[str] = ...) -> None: ...
@contextmanager
def mark_for_rollback_on_error(using: Optional[str] = ...) -> Iterator[None]: ...
def on_commit(func: Callable, using: Optional[str] = ...) -> None: ...
_C = TypeVar("_C", bound=Callable) # Any callable
# Don't inherit from ContextDecorator, so we can provide a more specific signature for __call__
class Atomic:
using: Optional[str] = ...
savepoint: bool = ...
def __init__(self, using: Optional[str], savepoint: bool) -> None: ...
# When decorating, return the decorated function as-is, rather than clobbering it as ContextDecorator does.
def __call__(self, func: _C) -> _C: ...
def __enter__(self) -> None: ...
def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ...
# Bare decorator
@overload
def atomic(using: _C) -> _C: ...
# Decorator or context-manager with parameters
@overload
def atomic(using: Optional[str] = ..., savepoint: bool = ...) -> Atomic: ...
# Bare decorator
@overload
def non_atomic_requests(using: _C) -> _C: ...
# Decorator with arguments
@overload
def non_atomic_requests(using: Optional[str] = ...) -> Callable[[_C], _C]: ...
| 2,032 | Python | .py | 40 | 48.875 | 111 | 0.663137 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,489 | signals.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/signals.pyi | from typing import Any, Callable, Optional, Type, Union
from django.apps.registry import Apps
from django.db.models.base import Model
from django.dispatch import Signal
class_prepared: Any
class ModelSignal(Signal):
def connect( # type: ignore
self,
receiver: Callable,
sender: Optional[Union[Type[Model], str]] = ...,
weak: bool = ...,
dispatch_uid: None = ...,
apps: Optional[Apps] = ...,
) -> None: ...
def disconnect( # type: ignore
self,
receiver: Callable = ...,
sender: Optional[Union[Type[Model], str]] = ...,
dispatch_uid: None = ...,
apps: Optional[Apps] = ...,
) -> Optional[bool]: ...
pre_init: Any
post_init: Any
pre_save: Any
post_save: Any
pre_delete: Any
post_delete: Any
m2m_changed: Any
pre_migrate: Any
post_migrate: Any
| 850 | Python | .py | 30 | 23.733333 | 56 | 0.631127 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,490 | utils.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/utils.pyi | from typing import Tuple, Type, Union
from django.db.models.base import Model
def make_model_tuple(model: Union[Type[Model], str]) -> Tuple[str, str]: ...
| 157 | Python | .py | 3 | 50.666667 | 76 | 0.743421 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,491 | options.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/options.pyi | import collections
from typing import Any, Callable, Dict, Generic, Iterator, List, Optional, Sequence, Tuple, Type, TypeVar, Union
from django.apps.config import AppConfig
from django.apps.registry import Apps
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.postgres.fields.array import ArrayField
from django.contrib.postgres.fields.citext import CIText
from django.db.backends.sqlite3.base import DatabaseWrapper
from django.db.models.base import Model
from django.db.models.constraints import BaseConstraint
from django.db.models.fields.mixins import FieldCacheMixin
from django.db.models.fields.related import ManyToManyField, OneToOneField
from django.db.models.fields.reverse_related import ForeignObjectRel
from django.db.models.manager import Manager
from django.db.models.query_utils import PathInfo
from django.utils.datastructures import ImmutableList
from django.db.models.fields import AutoField, Field
PROXY_PARENTS: Any
EMPTY_RELATION_TREE: Any
IMMUTABLE_WARNING: str
DEFAULT_NAMES: Tuple[str, ...]
def normalize_together(
option_together: Union[Sequence[Tuple[str, str]], Tuple[str, str]]
) -> Tuple[Tuple[str, str], ...]: ...
def make_immutable_fields_list(
name: str, data: Union[Iterator[Any], List[Union[ArrayField, CIText]], List[Union[Field, FieldCacheMixin]]]
) -> ImmutableList: ...
_M = TypeVar("_M", bound=Model)
class Options(Generic[_M]):
base_manager: Manager
concrete_fields: ImmutableList
constraints: List[BaseConstraint]
default_manager: Manager
fields: ImmutableList
local_concrete_fields: ImmutableList
related_objects: ImmutableList
FORWARD_PROPERTIES: Any = ...
REVERSE_PROPERTIES: Any = ...
default_apps: Any = ...
local_fields: List[Field] = ...
local_many_to_many: List[ManyToManyField] = ...
private_fields: List[Any] = ...
local_managers: List[Manager] = ...
base_manager_name: Optional[str] = ...
default_manager_name: Optional[str] = ...
model_name: Optional[str] = ...
verbose_name: Optional[str] = ...
verbose_name_plural: Optional[str] = ...
db_table: str = ...
ordering: Optional[Sequence[str]] = ...
indexes: List[Any] = ...
unique_together: Union[List[Any], Tuple] = ...
index_together: Union[List[Any], Tuple] = ...
select_on_save: bool = ...
default_permissions: Sequence[str] = ...
permissions: List[Any] = ...
object_name: Optional[str] = ...
app_label: str = ...
get_latest_by: Optional[Sequence[str]] = ...
order_with_respect_to: None = ...
db_tablespace: str = ...
required_db_features: List[Any] = ...
required_db_vendor: None = ...
meta: Optional[type] = ...
pk: Optional[Field] = ...
auto_field: Optional[AutoField] = ...
abstract: bool = ...
managed: bool = ...
proxy: bool = ...
proxy_for_model: Optional[Type[Model]] = ...
concrete_model: Optional[Type[Model]] = ...
swappable: None = ...
parents: collections.OrderedDict = ...
auto_created: bool = ...
related_fkey_lookups: List[Any] = ...
apps: Apps = ...
default_related_name: Optional[str] = ...
model: Type[Model] = ...
original_attrs: Dict[str, Any] = ...
def __init__(self, meta: Optional[type], app_label: Optional[str] = ...) -> None: ...
@property
def label(self) -> str: ...
@property
def label_lower(self) -> str: ...
@property
def app_config(self) -> AppConfig: ...
@property
def installed(self): ...
def contribute_to_class(self, cls: Type[Model], name: str) -> None: ...
def add_manager(self, manager: Manager) -> None: ...
def add_field(self, field: Union[GenericForeignKey, Field], private: bool = ...) -> None: ...
def setup_pk(self, field: Field) -> None: ...
def setup_proxy(self, target: Type[Model]) -> None: ...
def can_migrate(self, connection: Union[DatabaseWrapper, str]) -> bool: ...
@property
def verbose_name_raw(self) -> str: ...
@property
def swapped(self) -> Optional[str]: ...
@property
def many_to_many(self) -> List[ManyToManyField]: ...
@property
def fields_map(self) -> Dict[str, Union[Field, ForeignObjectRel]]: ...
@property
def managers(self) -> List[Manager]: ...
@property
def managers_map(self) -> Dict[str, Manager]: ...
@property
def db_returning_fields(self) -> List[Field]: ...
def get_field(self, field_name: Union[Callable, str]) -> Field: ...
def get_base_chain(self, model: Type[Model]) -> List[Type[Model]]: ...
def get_parent_list(self) -> List[Type[Model]]: ...
def get_ancestor_link(self, ancestor: Type[Model]) -> Optional[OneToOneField]: ...
def get_path_to_parent(self, parent: Type[Model]) -> List[PathInfo]: ...
def get_path_from_parent(self, parent: Type[Model]) -> List[PathInfo]: ...
def get_fields(
self, include_parents: bool = ..., include_hidden: bool = ...
) -> List[Union[Field, ForeignObjectRel]]: ...
| 4,993 | Python | .py | 117 | 38.512821 | 112 | 0.671458 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,492 | enums.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/enums.pyi | import enum
from typing import Any, List, Tuple
class ChoicesMeta(enum.EnumMeta):
names: List[str] = ...
choices: List[Tuple[Any, str]] = ...
labels: List[str] = ...
values: List[Any] = ...
def __contains__(self, item: Any) -> bool: ...
class Choices(enum.Enum, metaclass=ChoicesMeta):
def __str__(self): ...
# fake
class _IntegerChoicesMeta(ChoicesMeta):
names: List[str] = ...
choices: List[Tuple[int, str]] = ...
labels: List[str] = ...
values: List[int] = ...
class IntegerChoices(int, Choices, metaclass=_IntegerChoicesMeta): ...
# fake
class _TextChoicesMeta(ChoicesMeta):
names: List[str] = ...
choices: List[Tuple[str, str]] = ...
labels: List[str] = ...
values: List[str] = ...
class TextChoices(str, Choices, metaclass=_TextChoicesMeta): ...
| 814 | Python | .py | 24 | 30.333333 | 70 | 0.639031 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,493 | deletion.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/deletion.pyi | from typing import Any, Callable, Iterable, Optional, Union, Collection, Type
from django.db.models.base import Model
from django.db import IntegrityError
from django.db.models.fields import Field
from django.db.models.options import Options
def CASCADE(collector, field, sub_objs, using): ...
def SET_NULL(collector, field, sub_objs, using): ...
def SET_DEFAULT(collector, field, sub_objs, using): ...
def DO_NOTHING(collector, field, sub_objs, using): ...
def PROTECT(collector, field, sub_objs, using): ...
def RESTRICT(collector, field, sub_objs, using): ...
def SET(value: Any) -> Callable: ...
def get_candidate_relations_to_delete(opts: Options) -> Iterable[Field]: ...
class ProtectedError(IntegrityError): ...
class RestrictedError(IntegrityError): ...
class Collector:
def __init__(self, using: str) -> None: ...
def collect(
self,
objs: Collection[Optional[Model]],
source: Optional[Type[Model]] = ...,
source_attr: Optional[str] = ...,
**kwargs: Any
) -> None: ...
def can_fast_delete(self, objs: Union[Model, Iterable[Model]], from_field: Optional[Field] = ...) -> bool: ...
| 1,149 | Python | .py | 25 | 42.52 | 114 | 0.692583 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,494 | __init__.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/__init__.pyi | from .base import Model as Model
from .aggregates import (
Aggregate as Aggregate,
Avg as Avg,
Count as Count,
Max as Max,
Min as Min,
StdDev as StdDev,
Sum as Sum,
Variance as Variance,
)
from .fields import (
FieldDoesNotExist as FieldDoesNotExist,
AutoField as AutoField,
IntegerField as IntegerField,
PositiveIntegerField as PositiveIntegerField,
PositiveSmallIntegerField as PositiveSmallIntegerField,
SmallIntegerField as SmallIntegerField,
BigIntegerField as BigIntegerField,
FloatField as FloatField,
CharField as CharField,
EmailField as EmailField,
URLField as URLField,
Field as Field,
SlugField as SlugField,
TextField as TextField,
BooleanField as BooleanField,
NullBooleanField as NullBooleanField,
DateField as DateField,
TimeField as TimeField,
DateTimeField as DateTimeField,
IPAddressField as IPAddressField,
GenericIPAddressField as GenericIPAddressField,
UUIDField as UUIDField,
DecimalField as DecimalField,
FilePathField as FilePathField,
BinaryField as BinaryField,
DurationField as DurationField,
BigAutoField as BigAutoField,
CommaSeparatedIntegerField as CommaSeparatedIntegerField,
NOT_PROVIDED as NOT_PROVIDED,
)
from .fields.related import (
ForeignKey as ForeignKey,
OneToOneField as OneToOneField,
ManyToManyField as ManyToManyField,
ForeignObject as ForeignObject,
ManyToManyRel as ManyToManyRel,
ManyToOneRel as ManyToOneRel,
OneToOneRel as OneToOneRel,
ForeignObjectRel as ForeignObjectRel,
)
from .fields.files import (
ImageField as ImageField,
FileField as FileField,
FieldFile as FieldFile,
FileDescriptor as FileDescriptor,
)
from .fields.proxy import OrderWrt as OrderWrt
from .deletion import (
CASCADE as CASCADE,
SET_DEFAULT as SET_DEFAULT,
SET_NULL as SET_NULL,
DO_NOTHING as DO_NOTHING,
PROTECT as PROTECT,
SET as SET,
RESTRICT as RESTRICT,
ProtectedError as ProtectedError,
RestrictedError as RestrictedError,
)
from .query import (
Prefetch as Prefetch,
QuerySet as QuerySet,
RawQuerySet as RawQuerySet,
prefetch_related_objects as prefetch_related_objects,
)
from .query_utils import Q as Q, FilteredRelation as FilteredRelation
from .lookups import Lookup as Lookup, Transform as Transform
from .expressions import (
F as F,
Expression as Expression,
Subquery as Subquery,
Exists as Exists,
OrderBy as OrderBy,
OuterRef as OuterRef,
Case as Case,
When as When,
RawSQL as RawSQL,
Value as Value,
Func as Func,
ExpressionWrapper as ExpressionWrapper,
Combinable as Combinable,
Col as Col,
CombinedExpression as CombinedExpression,
ExpressionList as ExpressionList,
Random as Random,
Ref as Ref,
Window as Window,
WindowFrame as WindowFrame,
RowRange as RowRange,
ValueRange as ValueRange,
)
from .manager import BaseManager as BaseManager, Manager as Manager
from . import lookups as lookups
from .aggregates import (
Avg as Avg,
Min as Min,
Max as Max,
Variance as Variance,
StdDev as StdDev,
Sum as Sum,
Aggregate as Aggregate,
)
from .indexes import Index as Index
from . import signals as signals
from .constraints import (
BaseConstraint as BaseConstraint,
CheckConstraint as CheckConstraint,
UniqueConstraint as UniqueConstraint,
)
from .enums import Choices as Choices, IntegerChoices as IntegerChoices, TextChoices as TextChoices
| 3,576 | Python | .py | 121 | 25.322314 | 99 | 0.76686 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,495 | manager.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/manager.pyi | from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Iterable, Union
from django.db.models.base import Model
from django.db.models.query import QuerySet
_T = TypeVar("_T", bound=Model, covariant=True)
_M = TypeVar("_M", bound="BaseManager")
class BaseManager(QuerySet[_T]):
creation_counter: int = ...
auto_created: bool = ...
use_in_migrations: bool = ...
name: str = ...
model: Type[_T] = ...
db: str
_db: Optional[str]
def __init__(self) -> None: ...
def deconstruct(self) -> Tuple[bool, str, None, Tuple, Dict[str, int]]: ...
def check(self, **kwargs: Any) -> List[Any]: ...
@classmethod
def from_queryset(cls, queryset_class: Type[QuerySet], class_name: Optional[str] = ...) -> Any: ...
@classmethod
def _get_queryset_methods(cls, queryset_class: type) -> Dict[str, Any]: ...
def contribute_to_class(self, model: Type[Model], name: str) -> None: ...
def db_manager(self: _M, using: Optional[str] = ..., hints: Optional[Dict[str, Model]] = ...) -> _M: ...
def get_queryset(self) -> QuerySet[_T]: ...
class Manager(BaseManager[_T]): ...
class RelatedManager(Manager[_T]):
related_val: Tuple[int, ...]
def add(self, *objs: Union[_T, int], bulk: bool = ...) -> None: ...
def remove(self, *objs: Union[_T, int], bulk: bool = ...) -> None: ...
def set(
self, objs: Union[QuerySet[_T], Iterable[Union[_T, int]]], *, bulk: bool = ..., clear: bool = ...
) -> None: ...
def clear(self) -> None: ...
class ManagerDescriptor:
manager: Manager = ...
def __init__(self, manager: Manager) -> None: ...
def __get__(self, instance: Optional[Model], cls: Type[Model] = ...) -> Manager: ...
class EmptyManager(Manager):
def __init__(self, model: Type[Model]) -> None: ...
| 1,796 | Python | .py | 38 | 43.026316 | 108 | 0.605939 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,496 | constraints.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/constraints.pyi | from typing import Any, Optional, Sequence, Tuple, Type, TypeVar
from django.db.backends.base.schema import BaseDatabaseSchemaEditor
from django.db.models.base import Model
from django.db.models.query_utils import Q
_T = TypeVar("_T", bound="BaseConstraint")
class BaseConstraint:
name: str
def __init__(self, name: str) -> None: ...
def constraint_sql(
self, model: Optional[Type[Model]], schema_editor: Optional[BaseDatabaseSchemaEditor]
) -> str: ...
def create_sql(self, model: Optional[Type[Model]], schema_editor: Optional[BaseDatabaseSchemaEditor]) -> str: ...
def remove_sql(self, model: Optional[Type[Model]], schema_editor: Optional[BaseDatabaseSchemaEditor]) -> str: ...
def deconstruct(self) -> Any: ...
def clone(self: _T) -> _T: ...
class CheckConstraint(BaseConstraint):
check: Q
def __init__(self, *, check: Q, name: str) -> None: ...
class UniqueConstraint(BaseConstraint):
fields: Tuple[str]
condition: Optional[Q]
def __init__(self, *, fields: Sequence[str], name: str, condition: Optional[Q] = ...): ...
| 1,089 | Python | .py | 22 | 45.545455 | 117 | 0.693974 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,497 | base.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/base.pyi | from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Type, TypeVar, Union, Collection, ClassVar
from django.core.checks.messages import CheckMessage
from django.core.exceptions import ValidationError
from django.db.models.manager import BaseManager
from django.db.models.options import Options
_Self = TypeVar("_Self", bound="Model")
class ModelStateFieldsCacheDescriptor: ...
class ModelState:
db: Optional[str] = ...
adding: bool = ...
fields_cache: ModelStateFieldsCacheDescriptor = ...
class ModelBase(type): ...
class Model(metaclass=ModelBase):
class DoesNotExist(Exception): ...
class MultipleObjectsReturned(Exception): ...
class Meta: ...
_meta: Options[Any]
_default_manager: BaseManager[Model]
objects: ClassVar[BaseManager[Any]]
pk: Any = ...
_state: ModelState
def __init__(self: _Self, *args, **kwargs) -> None: ...
@classmethod
def add_to_class(cls, name: str, value: Any): ...
@classmethod
def from_db(cls, db: Optional[str], field_names: Collection[str], values: Collection[Any]) -> _Self: ...
def delete(self, using: Any = ..., keep_parents: bool = ...) -> Tuple[int, Dict[str, int]]: ...
def full_clean(self, exclude: Optional[Collection[str]] = ..., validate_unique: bool = ...) -> None: ...
def clean(self) -> None: ...
def clean_fields(self, exclude: Optional[Collection[str]] = ...) -> None: ...
def validate_unique(self, exclude: Optional[Collection[str]] = ...) -> None: ...
def unique_error_message(
self, model_class: Type[_Self], unique_check: Collection[Union[Callable, str]]
) -> ValidationError: ...
def save(
self,
force_insert: bool = ...,
force_update: bool = ...,
using: Optional[str] = ...,
update_fields: Optional[Union[Sequence[str], str]] = ...,
) -> None: ...
def save_base(
self,
raw: bool = ...,
force_insert: bool = ...,
force_update: bool = ...,
using: Optional[str] = ...,
update_fields: Optional[Union[Sequence[str], str]] = ...,
): ...
def refresh_from_db(self: _Self, using: Optional[str] = ..., fields: Optional[List[str]] = ...) -> None: ...
def get_deferred_fields(self) -> Set[str]: ...
@classmethod
def check(cls, **kwargs: Any) -> List[CheckMessage]: ...
def __getstate__(self) -> dict: ...
| 2,400 | Python | .py | 54 | 39.185185 | 120 | 0.628632 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,498 | indexes.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/indexes.pyi | from typing import Any, List, Optional, Sequence, Tuple, Type
from django.db.backends.base.schema import BaseDatabaseSchemaEditor
from django.db.backends.ddl_references import Statement
from django.db.models.base import Model
from django.db.models.query_utils import Q
class Index:
model: Type[Model]
suffix: str = ...
max_name_length: int = ...
fields: Sequence[str] = ...
fields_orders: Sequence[Tuple[str, str]] = ...
name: str = ...
db_tablespace: Optional[str] = ...
opclasses: Sequence[str] = ...
condition: Optional[Q] = ...
def __init__(
self,
*,
fields: Sequence[str] = ...,
name: Optional[str] = ...,
db_tablespace: Optional[str] = ...,
opclasses: Sequence[str] = ...,
condition: Optional[Q] = ...
) -> None: ...
def check_name(self) -> List[str]: ...
def create_sql(
self, model: Type[Model], schema_editor: BaseDatabaseSchemaEditor, using: str = ...
) -> Statement: ...
def remove_sql(self, model: Type[Model], schema_editor: BaseDatabaseSchemaEditor) -> str: ...
def deconstruct(self) -> Any: ...
def clone(self) -> Index: ...
def set_name_with_model(self, model: Type[Model]) -> None: ...
| 1,241 | Python | .py | 32 | 33.46875 | 97 | 0.622204 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |
29,499 | aggregates.pyi | DamnWidget_anaconda/anaconda_lib/jedi/third_party/django-stubs/django-stubs/db/models/aggregates.pyi | from typing import Any, Optional
from django.db.models.expressions import Func
class Aggregate(Func):
filter_template: str = ...
filter: Any = ...
allow_distinct: bool = ...
def __init__(self, *expressions: Any, distinct: bool = ..., filter: Optional[Any] = ..., **extra: Any) -> None: ...
class Avg(Aggregate): ...
class Count(Aggregate): ...
class Max(Aggregate): ...
class Min(Aggregate): ...
class StdDev(Aggregate): ...
class Sum(Aggregate): ...
class Variance(Aggregate): ...
| 501 | Python | .py | 14 | 33.428571 | 119 | 0.665289 | DamnWidget/anaconda | 2,213 | 260 | 184 | GPL-3.0 | 9/5/2024, 5:14:06 PM (Europe/Amsterdam) |