.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/stdlib/2/inspect.pyi

   1 from types import CodeType, TracebackType, FrameType, ModuleType\r
   2 from typing import Any, Dict, Callable, List, NamedTuple, Optional, Sequence, Tuple, Type, Union\r
   3 \r
   4 # Types and members\r
   5 class EndOfBlock(Exception): ...\r
   6 \r
   7 class BlockFinder:\r
   8     indent: int\r
   9     islambda: bool\r
  10     started: bool\r
  11     passline: bool\r
  12     last: int\r
  13     def tokeneater(self, type: int, token: str, srow_scol: Tuple[int, int],\r
  14                    erow_ecol: Tuple[int, int], line: str) -> None: ...\r
  15 \r
  16 CO_GENERATOR = ...  # type: int\r
  17 CO_NESTED = ...  # type: int\r
  18 CO_NEWLOCALS = ...  # type: int\r
  19 CO_NOFREE = ...  # type: int\r
  20 CO_OPTIMIZED = ...  # type: int\r
  21 CO_VARARGS = ...  # type: int\r
  22 CO_VARKEYWORDS = ...  # type: int\r
  23 TPFLAGS_IS_ABSTRACT = ...  # type: int\r
  24 \r
  25 ModuleInfo = NamedTuple('ModuleInfo', [('name', str),\r
  26                                        ('suffix', str),\r
  27                                        ('mode', str),\r
  28                                        ('module_type', int),\r
  29                                        ])\r
  30 def getmembers(\r
  31     object: object,\r
  32     predicate: Optional[Callable[[Any], bool]] = ...\r
  33 ) -> List[Tuple[str, Any]]: ...\r
  34 def getmoduleinfo(path: str) -> Optional[ModuleInfo]: ...\r
  35 def getmodulename(path: str) -> Optional[str]: ...\r
  36 \r
  37 def ismodule(object: object) -> bool: ...\r
  38 def isclass(object: object) -> bool: ...\r
  39 def ismethod(object: object) -> bool: ...\r
  40 def isfunction(object: object) -> bool: ...\r
  41 def isgeneratorfunction(object: object) -> bool: ...\r
  42 def isgenerator(object: object) -> bool: ...\r
  43 def istraceback(object: object) -> bool: ...\r
  44 def isframe(object: object) -> bool: ...\r
  45 def iscode(object: object) -> bool: ...\r
  46 def isbuiltin(object: object) -> bool: ...\r
  47 def isroutine(object: object) -> bool: ...\r
  48 def isabstract(object: object) -> bool: ...\r
  49 def ismethoddescriptor(object: object) -> bool: ...\r
  50 def isdatadescriptor(object: object) -> bool: ...\r
  51 def isgetsetdescriptor(object: object) -> bool: ...\r
  52 def ismemberdescriptor(object: object) -> bool: ...\r
  53 \r
  54 # Retrieving source code\r
  55 def findsource(object: object) -> Tuple[List[str], int]: ...\r
  56 def getabsfile(object: object) -> str: ...\r
  57 def getblock(lines: Sequence[str]) -> Sequence[str]: ...\r
  58 def getdoc(object: object) -> str: ...\r
  59 def getcomments(object: object) -> str: ...\r
  60 def getfile(object: object) -> str: ...\r
  61 def getmodule(object: object) -> ModuleType: ...\r
  62 def getsourcefile(object: object) -> str: ...\r
  63 # TODO restrict to "module, class, method, function, traceback, frame,\r
  64 # or code object"\r
  65 def getsourcelines(object: object) -> Tuple[List[str], int]: ...\r
  66 # TODO restrict to "a module, class, method, function, traceback, frame,\r
  67 # or code object"\r
  68 def getsource(object: object) -> str: ...\r
  69 def cleandoc(doc: str) -> str: ...\r
  70 def indentsize(line: str) -> int: ...\r
  71 \r
  72 # Classes and functions\r
  73 def getclasstree(classes: List[type], unique: bool = ...) -> List[\r
  74     Union[Tuple[type, Tuple[type, ...]], list]]: ...\r
  75 \r
  76 ArgSpec = NamedTuple('ArgSpec', [('args', List[str]),\r
  77                                  ('varargs', Optional[str]),\r
  78                                  ('keywords', Optional[str]),\r
  79                                  ('defaults', tuple),\r
  80                                  ])\r
  81 \r
  82 ArgInfo = NamedTuple('ArgInfo', [('args', List[str]),\r
  83                                  ('varargs', Optional[str]),\r
  84                                  ('keywords', Optional[str]),\r
  85                                  ('locals', Dict[str, Any]),\r
  86                                  ])\r
  87 \r
  88 Arguments = NamedTuple('Arguments', [('args', List[Union[str, List[Any]]]),\r
  89                                      ('varargs', Optional[str]),\r
  90                                      ('keywords', Optional[str]),\r
  91                                      ])\r
  92 \r
  93 def getargs(co: CodeType) -> Arguments: ...\r
  94 def getargspec(func: object) -> ArgSpec: ...\r
  95 def getargvalues(frame: FrameType) -> ArgInfo: ...\r
  96 def formatargspec(args, varargs=..., varkw=..., defaults=...,\r
  97         formatarg=..., formatvarargs=..., formatvarkw=..., formatvalue=...,\r
  98         join=...) -> str: ...\r
  99 def formatargvalues(args, varargs=..., varkw=..., defaults=...,\r
 100         formatarg=..., formatvarargs=..., formatvarkw=..., formatvalue=...,\r
 101         join=...) -> str: ...\r
 102 def getmro(cls: type) -> Tuple[type, ...]: ...\r
 103 def getcallargs(func, *args, **kwds) -> Dict[str, Any]: ...\r
 104 \r
 105 # The interpreter stack\r
 106 \r
 107 Traceback = NamedTuple(\r
 108     'Traceback',\r
 109     [\r
 110         ('filename', str),\r
 111         ('lineno', int),\r
 112         ('function', str),\r
 113         ('code_context', List[str]),\r
 114         ('index', int),\r
 115     ]\r
 116 )\r
 117 \r
 118 _FrameInfo = Tuple[FrameType, str, int, str, List[str], int]\r
 119 \r
 120 def getouterframes(frame: FrameType, context: int = ...) -> List[_FrameInfo]: ...\r
 121 def getframeinfo(frame: Union[FrameType, TracebackType], context: int = ...) -> Traceback: ...\r
 122 def getinnerframes(traceback: TracebackType, context: int = ...) -> List[_FrameInfo]: ...\r
 123 def getlineno(frame: FrameType) -> int: ...\r
 124 \r
 125 def currentframe(depth: int = ...) -> FrameType: ...\r
 126 def stack(context: int = ...) -> List[_FrameInfo]: ...\r
 127 def trace(context: int = ...) -> List[_FrameInfo]: ...\r
 128 \r
 129 Attribute = NamedTuple('Attribute', [('name', str),\r
 130                                      ('kind', str),\r
 131                                      ('defining_class', type),\r
 132                                      ('object', object),\r
 133                                      ])\r
 134 \r
 135 def classify_class_attrs(cls: type) -> List[Attribute]: ...\r