mirror of
https://github.com/davidhalter/typeshed.git
synced 2025-12-07 04:34:28 +08:00
356 lines
11 KiB
Python
356 lines
11 KiB
Python
import enum
|
|
import sys
|
|
import types
|
|
from _typeshed import Self
|
|
from collections import OrderedDict
|
|
from collections.abc import Awaitable, Callable, Generator, Mapping, Sequence, Set
|
|
from types import (
|
|
AsyncGeneratorType,
|
|
BuiltinFunctionType,
|
|
CodeType,
|
|
CoroutineType,
|
|
FrameType,
|
|
FunctionType,
|
|
GeneratorType,
|
|
MethodType,
|
|
ModuleType,
|
|
TracebackType,
|
|
)
|
|
from typing import Any, ClassVar, NamedTuple, Tuple, Type, Union
|
|
from typing_extensions import Literal, TypeGuard
|
|
|
|
#
|
|
# Types and members
|
|
#
|
|
class EndOfBlock(Exception): ...
|
|
|
|
class BlockFinder:
|
|
indent: int
|
|
islambda: bool
|
|
started: bool
|
|
passline: bool
|
|
indecorator: bool
|
|
decoratorhasargs: bool
|
|
last: int
|
|
def tokeneater(self, type: int, token: str, srowcol: Tuple[int, int], erowcol: Tuple[int, int], line: str) -> None: ...
|
|
|
|
CO_OPTIMIZED: int
|
|
CO_NEWLOCALS: int
|
|
CO_VARARGS: int
|
|
CO_VARKEYWORDS: int
|
|
CO_NESTED: int
|
|
CO_GENERATOR: int
|
|
CO_NOFREE: int
|
|
CO_COROUTINE: int
|
|
CO_ITERABLE_COROUTINE: int
|
|
CO_ASYNC_GENERATOR: int
|
|
TPFLAGS_IS_ABSTRACT: int
|
|
|
|
def getmembers(object: object, predicate: Callable[[Any], bool] | None = ...) -> list[Tuple[str, Any]]: ...
|
|
def getmodulename(path: str) -> str | None: ...
|
|
def ismodule(object: object) -> TypeGuard[ModuleType]: ...
|
|
def isclass(object: object) -> TypeGuard[Type[Any]]: ...
|
|
def ismethod(object: object) -> TypeGuard[MethodType]: ...
|
|
def isfunction(object: object) -> TypeGuard[FunctionType]: ...
|
|
|
|
if sys.version_info >= (3, 8):
|
|
def isgeneratorfunction(obj: object) -> bool: ...
|
|
def iscoroutinefunction(obj: object) -> bool: ...
|
|
|
|
else:
|
|
def isgeneratorfunction(object: object) -> bool: ...
|
|
def iscoroutinefunction(object: object) -> bool: ...
|
|
|
|
def isgenerator(object: object) -> TypeGuard[GeneratorType[Any, Any, Any]]: ...
|
|
def iscoroutine(object: object) -> TypeGuard[CoroutineType[Any, Any, Any]]: ...
|
|
def isawaitable(object: object) -> TypeGuard[Awaitable[Any]]: ...
|
|
|
|
if sys.version_info >= (3, 8):
|
|
def isasyncgenfunction(obj: object) -> bool: ...
|
|
|
|
else:
|
|
def isasyncgenfunction(object: object) -> bool: ...
|
|
|
|
def isasyncgen(object: object) -> TypeGuard[AsyncGeneratorType[Any, Any]]: ...
|
|
def istraceback(object: object) -> TypeGuard[TracebackType]: ...
|
|
def isframe(object: object) -> TypeGuard[FrameType]: ...
|
|
def iscode(object: object) -> TypeGuard[CodeType]: ...
|
|
def isbuiltin(object: object) -> TypeGuard[BuiltinFunctionType]: ...
|
|
def isroutine(object: object) -> bool: ...
|
|
def isabstract(object: object) -> bool: ...
|
|
def ismethoddescriptor(object: object) -> bool: ...
|
|
def isdatadescriptor(object: object) -> bool: ...
|
|
def isgetsetdescriptor(object: object) -> bool: ...
|
|
def ismemberdescriptor(object: object) -> bool: ...
|
|
|
|
#
|
|
# Retrieving source code
|
|
#
|
|
_SourceObjectType = Union[ModuleType, Type[Any], MethodType, FunctionType, TracebackType, FrameType, CodeType, Callable[..., Any]]
|
|
|
|
def findsource(object: _SourceObjectType) -> Tuple[list[str], int]: ...
|
|
def getabsfile(object: _SourceObjectType, _filename: str | None = ...) -> str: ...
|
|
def getblock(lines: Sequence[str]) -> Sequence[str]: ...
|
|
def getdoc(object: object) -> str | None: ...
|
|
def getcomments(object: object) -> str | None: ...
|
|
def getfile(object: _SourceObjectType) -> str: ...
|
|
def getmodule(object: object, _filename: str | None = ...) -> ModuleType | None: ...
|
|
def getsourcefile(object: _SourceObjectType) -> str | None: ...
|
|
def getsourcelines(object: _SourceObjectType) -> Tuple[list[str], int]: ...
|
|
def getsource(object: _SourceObjectType) -> str: ...
|
|
def cleandoc(doc: str) -> str: ...
|
|
def indentsize(line: str) -> int: ...
|
|
|
|
#
|
|
# Introspecting callables with the Signature object
|
|
#
|
|
if sys.version_info >= (3, 10):
|
|
def signature(
|
|
obj: Callable[..., Any],
|
|
*,
|
|
follow_wrapped: bool = ...,
|
|
globals: Mapping[str, Any] | None = ...,
|
|
locals: Mapping[str, Any] | None = ...,
|
|
eval_str: bool = ...,
|
|
) -> Signature: ...
|
|
|
|
else:
|
|
def signature(obj: Callable[..., Any], *, follow_wrapped: bool = ...) -> Signature: ...
|
|
|
|
class _void: ...
|
|
class _empty: ...
|
|
|
|
class Signature:
|
|
def __init__(
|
|
self, parameters: Sequence[Parameter] | None = ..., *, return_annotation: Any = ..., __validate_parameters__: bool = ...
|
|
) -> None: ...
|
|
empty = _empty
|
|
@property
|
|
def parameters(self) -> types.MappingProxyType[str, Parameter]: ...
|
|
# TODO: can we be more specific here?
|
|
@property
|
|
def return_annotation(self) -> Any: ...
|
|
def bind(self, *args: Any, **kwargs: Any) -> BoundArguments: ...
|
|
def bind_partial(self, *args: Any, **kwargs: Any) -> BoundArguments: ...
|
|
def replace(
|
|
self: Self, *, parameters: Sequence[Parameter] | Type[_void] | None = ..., return_annotation: Any = ...
|
|
) -> Self: ...
|
|
if sys.version_info >= (3, 10):
|
|
@classmethod
|
|
def from_callable(
|
|
cls,
|
|
obj: Callable[..., Any],
|
|
*,
|
|
follow_wrapped: bool = ...,
|
|
globals: Mapping[str, Any] | None = ...,
|
|
locals: Mapping[str, Any] | None = ...,
|
|
eval_str: bool = ...,
|
|
) -> Signature: ...
|
|
else:
|
|
@classmethod
|
|
def from_callable(cls, obj: Callable[..., Any], *, follow_wrapped: bool = ...) -> Signature: ...
|
|
|
|
if sys.version_info >= (3, 10):
|
|
def get_annotations(
|
|
obj: Callable[..., Any] | Type[Any] | ModuleType,
|
|
*,
|
|
globals: Mapping[str, Any] | None = ...,
|
|
locals: Mapping[str, Any] | None = ...,
|
|
eval_str: bool = ...,
|
|
) -> dict[str, Any]: ...
|
|
|
|
# The name is the same as the enum's name in CPython
|
|
class _ParameterKind(enum.IntEnum):
|
|
POSITIONAL_ONLY: int
|
|
POSITIONAL_OR_KEYWORD: int
|
|
VAR_POSITIONAL: int
|
|
KEYWORD_ONLY: int
|
|
VAR_KEYWORD: int
|
|
|
|
if sys.version_info >= (3, 8):
|
|
description: str
|
|
|
|
class Parameter:
|
|
def __init__(self, name: str, kind: _ParameterKind, *, default: Any = ..., annotation: Any = ...) -> None: ...
|
|
empty = _empty
|
|
name: str
|
|
default: Any
|
|
annotation: Any
|
|
|
|
kind: _ParameterKind
|
|
POSITIONAL_ONLY: ClassVar[Literal[_ParameterKind.POSITIONAL_ONLY]]
|
|
POSITIONAL_OR_KEYWORD: ClassVar[Literal[_ParameterKind.POSITIONAL_OR_KEYWORD]]
|
|
VAR_POSITIONAL: ClassVar[Literal[_ParameterKind.VAR_POSITIONAL]]
|
|
KEYWORD_ONLY: ClassVar[Literal[_ParameterKind.KEYWORD_ONLY]]
|
|
VAR_KEYWORD: ClassVar[Literal[_ParameterKind.VAR_KEYWORD]]
|
|
def replace(
|
|
self: Self,
|
|
*,
|
|
name: str | Type[_void] = ...,
|
|
kind: _ParameterKind | Type[_void] = ...,
|
|
default: Any = ...,
|
|
annotation: Any = ...,
|
|
) -> Self: ...
|
|
|
|
class BoundArguments:
|
|
arguments: OrderedDict[str, Any]
|
|
args: Tuple[Any, ...]
|
|
kwargs: dict[str, Any]
|
|
signature: Signature
|
|
def __init__(self, signature: Signature, arguments: OrderedDict[str, Any]) -> None: ...
|
|
def apply_defaults(self) -> None: ...
|
|
|
|
#
|
|
# Classes and functions
|
|
#
|
|
|
|
# TODO: The actual return type should be list[_ClassTreeItem] but mypy doesn't
|
|
# seem to be supporting this at the moment:
|
|
# _ClassTreeItem = list[_ClassTreeItem] | Tuple[type, Tuple[type, ...]]
|
|
def getclasstree(classes: list[type], unique: bool = ...) -> list[Any]: ...
|
|
def walktree(classes: list[type], children: dict[Type[Any], list[type]], parent: Type[Any] | None) -> list[Any]: ...
|
|
|
|
class ArgSpec(NamedTuple):
|
|
args: list[str]
|
|
varargs: str | None
|
|
keywords: str | None
|
|
defaults: Tuple[Any, ...]
|
|
|
|
class Arguments(NamedTuple):
|
|
args: list[str]
|
|
varargs: str | None
|
|
varkw: str | None
|
|
|
|
def getargs(co: CodeType) -> Arguments: ...
|
|
def getargspec(func: object) -> ArgSpec: ...
|
|
|
|
class FullArgSpec(NamedTuple):
|
|
args: list[str]
|
|
varargs: str | None
|
|
varkw: str | None
|
|
defaults: Tuple[Any, ...] | None
|
|
kwonlyargs: list[str]
|
|
kwonlydefaults: dict[str, Any] | None
|
|
annotations: dict[str, Any]
|
|
|
|
def getfullargspec(func: object) -> FullArgSpec: ...
|
|
|
|
class ArgInfo(NamedTuple):
|
|
args: list[str]
|
|
varargs: str | None
|
|
keywords: str | None
|
|
locals: dict[str, Any]
|
|
|
|
def getargvalues(frame: FrameType) -> ArgInfo: ...
|
|
def formatannotation(annotation: object, base_module: str | None = ...) -> str: ...
|
|
def formatannotationrelativeto(object: object) -> Callable[[object], str]: ...
|
|
def formatargspec(
|
|
args: list[str],
|
|
varargs: str | None = ...,
|
|
varkw: str | None = ...,
|
|
defaults: Tuple[Any, ...] | None = ...,
|
|
kwonlyargs: Sequence[str] | None = ...,
|
|
kwonlydefaults: dict[str, Any] | None = ...,
|
|
annotations: dict[str, Any] = ...,
|
|
formatarg: Callable[[str], str] = ...,
|
|
formatvarargs: Callable[[str], str] = ...,
|
|
formatvarkw: Callable[[str], str] = ...,
|
|
formatvalue: Callable[[Any], str] = ...,
|
|
formatreturns: Callable[[Any], str] = ...,
|
|
formatannotation: Callable[[Any], str] = ...,
|
|
) -> str: ...
|
|
def formatargvalues(
|
|
args: list[str],
|
|
varargs: str | None,
|
|
varkw: str | None,
|
|
locals: dict[str, Any] | None,
|
|
formatarg: Callable[[str], str] | None = ...,
|
|
formatvarargs: Callable[[str], str] | None = ...,
|
|
formatvarkw: Callable[[str], str] | None = ...,
|
|
formatvalue: Callable[[Any], str] | None = ...,
|
|
) -> str: ...
|
|
def getmro(cls: type) -> Tuple[type, ...]: ...
|
|
def getcallargs(__func: Callable[..., Any], *args: Any, **kwds: Any) -> dict[str, Any]: ...
|
|
|
|
class ClosureVars(NamedTuple):
|
|
nonlocals: Mapping[str, Any]
|
|
globals: Mapping[str, Any]
|
|
builtins: Mapping[str, Any]
|
|
unbound: Set[str]
|
|
|
|
def getclosurevars(func: Callable[..., Any]) -> ClosureVars: ...
|
|
def unwrap(func: Callable[..., Any], *, stop: Callable[[Any], Any] | None = ...) -> Any: ...
|
|
|
|
#
|
|
# The interpreter stack
|
|
#
|
|
|
|
class Traceback(NamedTuple):
|
|
filename: str
|
|
lineno: int
|
|
function: str
|
|
code_context: list[str] | None
|
|
index: int | None # type: ignore
|
|
|
|
class FrameInfo(NamedTuple):
|
|
frame: FrameType
|
|
filename: str
|
|
lineno: int
|
|
function: str
|
|
code_context: list[str] | None
|
|
index: int | None # type: ignore
|
|
|
|
def getframeinfo(frame: FrameType | TracebackType, context: int = ...) -> Traceback: ...
|
|
def getouterframes(frame: Any, context: int = ...) -> list[FrameInfo]: ...
|
|
def getinnerframes(tb: TracebackType, context: int = ...) -> list[FrameInfo]: ...
|
|
def getlineno(frame: FrameType) -> int: ...
|
|
def currentframe() -> FrameType | None: ...
|
|
def stack(context: int = ...) -> list[FrameInfo]: ...
|
|
def trace(context: int = ...) -> list[FrameInfo]: ...
|
|
|
|
#
|
|
# Fetching attributes statically
|
|
#
|
|
|
|
def getattr_static(obj: object, attr: str, default: Any | None = ...) -> Any: ...
|
|
|
|
#
|
|
# Current State of Generators and Coroutines
|
|
#
|
|
|
|
# TODO In the next two blocks of code, can we be more specific regarding the
|
|
# type of the "enums"?
|
|
|
|
GEN_CREATED: str
|
|
GEN_RUNNING: str
|
|
GEN_SUSPENDED: str
|
|
GEN_CLOSED: str
|
|
|
|
def getgeneratorstate(generator: Generator[Any, Any, Any]) -> str: ...
|
|
|
|
CORO_CREATED: str
|
|
CORO_RUNNING: str
|
|
CORO_SUSPENDED: str
|
|
CORO_CLOSED: str
|
|
# TODO can we be more specific than "object"?
|
|
def getcoroutinestate(coroutine: object) -> str: ...
|
|
def getgeneratorlocals(generator: Generator[Any, Any, Any]) -> dict[str, Any]: ...
|
|
|
|
# TODO can we be more specific than "object"?
|
|
def getcoroutinelocals(coroutine: object) -> dict[str, Any]: ...
|
|
|
|
# Create private type alias to avoid conflict with symbol of same
|
|
# name created in Attribute class.
|
|
_Object = object
|
|
|
|
class Attribute(NamedTuple):
|
|
name: str
|
|
kind: str
|
|
defining_class: type
|
|
object: _Object
|
|
|
|
def classify_class_attrs(cls: type) -> list[Attribute]: ...
|
|
|
|
if sys.version_info >= (3, 9):
|
|
class ClassFoundException(Exception): ...
|