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

   1 # Stubs for threading\r
   2 \r
   3 from typing import (\r
   4     Any, Callable, Iterable, List, Mapping, Optional, Tuple, Type, Union,\r
   5     TypeVar,\r
   6 )\r
   7 from types import FrameType, TracebackType\r
   8 import sys\r
   9 \r
  10 # TODO recursive type\r
  11 _TF = Callable[[FrameType, str, Any], Optional[Callable[..., Any]]]\r
  12 \r
  13 _PF = Callable[[FrameType, str, Any], None]\r
  14 _T = TypeVar('_T')\r
  15 \r
  16 \r
  17 def active_count() -> int: ...\r
  18 if sys.version_info < (3,):\r
  19     def activeCount() -> int: ...\r
  20 \r
  21 def current_thread() -> Thread: ...\r
  22 if sys.version_info < (3,):\r
  23     def currentThread() -> Thread: ...\r
  24 \r
  25 if sys.version_info >= (3,):\r
  26     def get_ident() -> int: ...\r
  27 \r
  28 def enumerate() -> List[Thread]: ...\r
  29 \r
  30 if sys.version_info >= (3, 4):\r
  31     def main_thread() -> Thread: ...\r
  32 \r
  33 def settrace(func: _TF) -> None: ...\r
  34 def setprofile(func: _PF) -> None: ...\r
  35 def stack_size(size: int = ...) -> int: ...\r
  36 \r
  37 if sys.version_info >= (3,):\r
  38     TIMEOUT_MAX = ...  # type: float\r
  39 \r
  40 class ThreadError(Exception): ...\r
  41 \r
  42 \r
  43 class local(object):\r
  44     def __getattribute__(self, name: str) -> Any: ...\r
  45     def __setattr__(self, name: str, value: Any) -> None: ...\r
  46     def __delattr__(self, name: str) -> None: ...\r
  47 \r
  48 \r
  49 class Thread:\r
  50     name = ...  # type: str\r
  51     ident = ...  # type: Optional[int]\r
  52     daemon = ...  # type: bool\r
  53     if sys.version_info >= (3,):\r
  54         def __init__(self, group: None = ...,\r
  55                      target: Optional[Callable[..., Any]] = ...,\r
  56                      name: Optional[str] = ...,\r
  57                      args: Iterable = ...,\r
  58                      kwargs: Mapping[str, Any] = ...,\r
  59                      *, daemon: Optional[bool] = ...) -> None: ...\r
  60     else:\r
  61         def __init__(self, group: None = ...,\r
  62                      target: Optional[Callable[..., Any]] = ...,\r
  63                      name: Optional[str] = ...,\r
  64                      args: Iterable = ...,\r
  65                      kwargs: Mapping[str, Any] = ...) -> None: ...\r
  66     def start(self) -> None: ...\r
  67     def run(self) -> None: ...\r
  68     def join(self, timeout: Optional[float] = ...) -> None: ...\r
  69     def getName(self) -> str: ...\r
  70     def setName(self, name: str) -> None: ...\r
  71     def is_alive(self) -> bool: ...\r
  72     if sys.version_info < (3,):\r
  73         def isAlive(self) -> bool: ...\r
  74     def isDaemon(self) -> bool: ...\r
  75     def setDaemon(self, daemonic: bool) -> None: ...\r
  76 \r
  77 \r
  78 class _DummyThread(Thread): ...\r
  79 \r
  80 \r
  81 class Lock:\r
  82     def __init__(self) -> None: ...\r
  83     def __enter__(self) -> bool: ...\r
  84     def __exit__(self, exc_type: Optional[Type[BaseException]],\r
  85                  exc_val: Optional[Exception],\r
  86                  exc_tb: Optional[TracebackType]) -> bool: ...\r
  87     if sys.version_info >= (3,):\r
  88         def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...\r
  89     else:\r
  90         def acquire(self, blocking: bool = ...) -> bool: ...\r
  91     def release(self) -> None: ...\r
  92     def locked(self) -> bool: ...\r
  93 \r
  94 \r
  95 class _RLock:\r
  96     def __init__(self) -> None: ...\r
  97     def __enter__(self) -> bool: ...\r
  98     def __exit__(self, exc_type: Optional[Type[BaseException]],\r
  99                  exc_val: Optional[Exception],\r
 100                  exc_tb: Optional[TracebackType]) -> bool: ...\r
 101     if sys.version_info >= (3,):\r
 102         def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...\r
 103     else:\r
 104         def acquire(self, blocking: bool = ...) -> bool: ...\r
 105     def release(self) -> None: ...\r
 106 \r
 107 \r
 108 RLock = _RLock\r
 109 \r
 110 \r
 111 class Condition:\r
 112     def __init__(self, lock: Union[Lock, _RLock, None] = ...) -> None: ...\r
 113     def __enter__(self) -> bool: ...\r
 114     def __exit__(self, exc_type: Optional[Type[BaseException]],\r
 115                  exc_val: Optional[Exception],\r
 116                  exc_tb: Optional[TracebackType]) -> bool: ...\r
 117     if sys.version_info >= (3,):\r
 118         def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...\r
 119     else:\r
 120         def acquire(self, blocking: bool = ...) -> bool: ...\r
 121     def release(self) -> None: ...\r
 122     def wait(self, timeout: Optional[float] = ...) -> bool: ...\r
 123     if sys.version_info >= (3,):\r
 124         def wait_for(self, predicate: Callable[[], _T],\r
 125                      timeout: Optional[float] = ...) -> _T: ...\r
 126     def notify(self, n: int = ...) -> None: ...\r
 127     def notify_all(self) -> None: ...\r
 128     def notifyAll(self) -> None: ...\r
 129 \r
 130 \r
 131 class Semaphore:\r
 132     def __init__(self, value: int = ...) -> None: ...\r
 133     def __enter__(self) -> bool: ...\r
 134     def __exit__(self, exc_type: Optional[Type[BaseException]],\r
 135                  exc_val: Optional[Exception],\r
 136                  exc_tb: Optional[TracebackType]) -> bool: ...\r
 137     if sys.version_info >= (3,):\r
 138         def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...\r
 139     else:\r
 140         def acquire(self, blocking: bool = ...) -> bool: ...\r
 141     def release(self) -> None: ...\r
 142 \r
 143 class BoundedSemaphore:\r
 144     def __init__(self, value: int = ...) -> None: ...\r
 145     def __enter__(self) -> bool: ...\r
 146     def __exit__(self, exc_type: Optional[Type[BaseException]],\r
 147                  exc_val: Optional[Exception],\r
 148                  exc_tb: Optional[TracebackType]) -> bool: ...\r
 149     if sys.version_info >= (3,):\r
 150         def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...\r
 151     else:\r
 152         def acquire(self, blocking: bool = ...) -> bool: ...\r
 153     def release(self) -> None: ...\r
 154 \r
 155 \r
 156 class Event:\r
 157     def __init__(self) -> None: ...\r
 158     def is_set(self) -> bool: ...\r
 159     if sys.version_info < (3,):\r
 160         def isSet(self) -> bool: ...\r
 161     def set(self) -> None: ...\r
 162     def clear(self) -> None: ...\r
 163     def wait(self, timeout: Optional[float] = ...) -> bool: ...\r
 164 \r
 165 \r
 166 class Timer(Thread):\r
 167     if sys.version_info >= (3,):\r
 168         def __init__(self, interval: float, function: Callable[..., None],\r
 169                      args: Optional[List[Any]] = ...,\r
 170                      kwargs: Optional[Mapping[str, Any]] = ...) -> None: ...\r
 171     else:\r
 172         def __init__(self, interval: float, function: Callable[..., None],\r
 173                      args: List[Any] = ...,\r
 174                      kwargs: Mapping[str, Any] = ...) -> None: ...\r
 175     def cancel(self) -> None: ...\r
 176 \r
 177 \r
 178 if sys.version_info >= (3,):\r
 179     class Barrier:\r
 180         parties = ...  # type: int\r
 181         n_waiting = ...  # type: int\r
 182         broken = ...  # type: bool\r
 183         def __init__(self, parties: int, action: Optional[Callable[[], None]] = ...,\r
 184                      timeout: Optional[float] = ...) -> None: ...\r
 185         def wait(self, timeout: Optional[float] = ...) -> int: ...\r
 186         def reset(self) -> None: ...\r
 187         def abort(self) -> None: ...\r
 188 \r
 189     class BrokenBarrierError(RuntimeError): ...\r