.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/stdlib/3/subprocess.pyi

   1 # Stubs for subprocess\r
   2 \r
   3 # Based on http://docs.python.org/3.6/library/subprocess.html\r
   4 import sys\r
   5 from typing import Sequence, Any, Mapping, Callable, Tuple, IO, Optional, Union, List, Type, Text\r
   6 from types import TracebackType\r
   7 \r
   8 # We prefer to annotate inputs to methods (eg subprocess.check_call) with these\r
   9 # union types. However, outputs (eg check_call return) and class attributes\r
  10 # (eg TimeoutError.cmd) we prefer to annotate with Any, so the caller does not\r
  11 # have to use an assertion to confirm which type.\r
  12 #\r
  13 # For example:\r
  14 #\r
  15 # try:\r
  16 #    x = subprocess.check_output(["ls", "-l"])\r
  17 #    reveal_type(x)  # Any, but morally is _TXT\r
  18 # except TimeoutError as e:\r
  19 #    reveal_type(e.cmd)  # Any, but morally is _CMD\r
  20 _FILE = Union[None, int, IO[Any]]\r
  21 _TXT = Union[bytes, Text]\r
  22 if sys.version_info >= (3, 6):\r
  23     from builtins import _PathLike\r
  24     _PATH = Union[bytes, Text, _PathLike]\r
  25 else:\r
  26     _PATH = Union[bytes, Text]\r
  27 # Python 3.6 does't support _CMD being a single PathLike.\r
  28 # See: https://bugs.python.org/issue31961\r
  29 _CMD = Union[_TXT, Sequence[_PATH]]\r
  30 _ENV = Union[Mapping[bytes, _TXT], Mapping[Text, _TXT]]\r
  31 \r
  32 if sys.version_info >= (3, 5):\r
  33     class CompletedProcess:\r
  34         # morally: _CMD\r
  35         args = ...  # type: Any\r
  36         returncode = ...  # type: int\r
  37         # morally: Optional[_TXT]\r
  38         stdout = ...  # type: Any\r
  39         stderr = ...  # type: Any\r
  40         def __init__(self, args: _CMD,\r
  41                      returncode: int,\r
  42                      stdout: Optional[_TXT] = ...,\r
  43                      stderr: Optional[_TXT] = ...) -> None: ...\r
  44         def check_returncode(self) -> None: ...\r
  45 \r
  46     if sys.version_info >= (3, 6):\r
  47         # Nearly same args as Popen.__init__ except for timeout, input, and check\r
  48         def run(args: _CMD,\r
  49                 timeout: Optional[float] = ...,\r
  50                 input: Optional[_TXT] = ...,\r
  51                 check: bool = ...,\r
  52                 bufsize: int = ...,\r
  53                 executable: _PATH = ...,\r
  54                 stdin: _FILE = ...,\r
  55                 stdout: _FILE = ...,\r
  56                 stderr: _FILE = ...,\r
  57                 preexec_fn: Callable[[], Any] = ...,\r
  58                 close_fds: bool = ...,\r
  59                 shell: bool = ...,\r
  60                 cwd: Optional[_PATH] = ...,\r
  61                 env: Optional[_ENV] = ...,\r
  62                 universal_newlines: bool = ...,\r
  63                 startupinfo: Any = ...,\r
  64                 creationflags: int = ...,\r
  65                 restore_signals: bool = ...,\r
  66                 start_new_session: bool = ...,\r
  67                 pass_fds: Any = ...,\r
  68                 *,\r
  69                 encoding: Optional[str] = ...,\r
  70                 errors: Optional[str] = ...) -> CompletedProcess: ...\r
  71     else:\r
  72         # Nearly same args as Popen.__init__ except for timeout, input, and check\r
  73         def run(args: _CMD,\r
  74                 timeout: Optional[float] = ...,\r
  75                 input: Optional[_TXT] = ...,\r
  76                 check: bool = ...,\r
  77                 bufsize: int = ...,\r
  78                 executable: _PATH = ...,\r
  79                 stdin: _FILE = ...,\r
  80                 stdout: _FILE = ...,\r
  81                 stderr: _FILE = ...,\r
  82                 preexec_fn: Callable[[], Any] = ...,\r
  83                 close_fds: bool = ...,\r
  84                 shell: bool = ...,\r
  85                 cwd: Optional[_PATH] = ...,\r
  86                 env: Optional[_ENV] = ...,\r
  87                 universal_newlines: bool = ...,\r
  88                 startupinfo: Any = ...,\r
  89                 creationflags: int = ...,\r
  90                 restore_signals: bool = ...,\r
  91                 start_new_session: bool = ...,\r
  92                 pass_fds: Any = ...) -> CompletedProcess: ...\r
  93 \r
  94 # Same args as Popen.__init__\r
  95 def call(args: _CMD,\r
  96          bufsize: int = ...,\r
  97          executable: _PATH = ...,\r
  98          stdin: _FILE = ...,\r
  99          stdout: _FILE = ...,\r
 100          stderr: _FILE = ...,\r
 101          preexec_fn: Callable[[], Any] = ...,\r
 102          close_fds: bool = ...,\r
 103          shell: bool = ...,\r
 104          cwd: Optional[_PATH] = ...,\r
 105          env: Optional[_ENV] = ...,\r
 106          universal_newlines: bool = ...,\r
 107          startupinfo: Any = ...,\r
 108          creationflags: int = ...,\r
 109          restore_signals: bool = ...,\r
 110          start_new_session: bool = ...,\r
 111          pass_fds: Any = ...,\r
 112          timeout: float = ...) -> int: ...\r
 113 \r
 114 # Same args as Popen.__init__\r
 115 def check_call(args: _CMD,\r
 116                bufsize: int = ...,\r
 117                executable: _PATH = ...,\r
 118                stdin: _FILE = ...,\r
 119                stdout: _FILE = ...,\r
 120                stderr: _FILE = ...,\r
 121                preexec_fn: Callable[[], Any] = ...,\r
 122                close_fds: bool = ...,\r
 123                shell: bool = ...,\r
 124                cwd: Optional[_PATH] = ...,\r
 125                env: Optional[_ENV] = ...,\r
 126                universal_newlines: bool = ...,\r
 127                startupinfo: Any = ...,\r
 128                creationflags: int = ...,\r
 129                restore_signals: bool = ...,\r
 130                start_new_session: bool = ...,\r
 131                pass_fds: Any = ...,\r
 132                timeout: float = ...) -> int: ...\r
 133 \r
 134 if sys.version_info >= (3, 6):\r
 135     # 3.6 added encoding and errors\r
 136     def check_output(args: _CMD,\r
 137                      bufsize: int = ...,\r
 138                      executable: _PATH = ...,\r
 139                      stdin: _FILE = ...,\r
 140                      stderr: _FILE = ...,\r
 141                      preexec_fn: Callable[[], Any] = ...,\r
 142                      close_fds: bool = ...,\r
 143                      shell: bool = ...,\r
 144                      cwd: Optional[_PATH] = ...,\r
 145                      env: Optional[_ENV] = ...,\r
 146                      universal_newlines: bool = ...,\r
 147                      startupinfo: Any = ...,\r
 148                      creationflags: int = ...,\r
 149                      restore_signals: bool = ...,\r
 150                      start_new_session: bool = ...,\r
 151                      pass_fds: Any = ...,\r
 152                      *,\r
 153                      timeout: float = ...,\r
 154                      input: _TXT = ...,\r
 155                      encoding: Optional[str] = ...,\r
 156                      errors: Optional[str] = ...,\r
 157                      ) -> Any: ...  # morally: -> _TXT\r
 158 else:\r
 159     def check_output(args: _CMD,\r
 160                      bufsize: int = ...,\r
 161                      executable: _PATH = ...,\r
 162                      stdin: _FILE = ...,\r
 163                      stderr: _FILE = ...,\r
 164                      preexec_fn: Callable[[], Any] = ...,\r
 165                      close_fds: bool = ...,\r
 166                      shell: bool = ...,\r
 167                      cwd: Optional[_PATH] = ...,\r
 168                      env: Optional[_ENV] = ...,\r
 169                      universal_newlines: bool = ...,\r
 170                      startupinfo: Any = ...,\r
 171                      creationflags: int = ...,\r
 172                      restore_signals: bool = ...,\r
 173                      start_new_session: bool = ...,\r
 174                      pass_fds: Any = ...,\r
 175                      timeout: float = ...,\r
 176                      input: _TXT = ...,\r
 177                      ) -> Any: ...  # morally: -> _TXT\r
 178 \r
 179 \r
 180 PIPE = ...  # type: int\r
 181 STDOUT = ...  # type: int\r
 182 DEVNULL = ...  # type: int\r
 183 class SubprocessError(Exception): ...\r
 184 class TimeoutExpired(SubprocessError):\r
 185     # morally: _CMD\r
 186     cmd = ...  # type: Any\r
 187     timeout = ...  # type: float\r
 188     # morally: Optional[_TXT]\r
 189     output = ...  # type: Any\r
 190     stdout = ...  # type: Any\r
 191     stderr = ...  # type: Any\r
 192 \r
 193 \r
 194 class CalledProcessError(Exception):\r
 195     returncode = 0\r
 196     # morally: _CMD\r
 197     cmd = ...  # type: Any\r
 198     # morally: Optional[_TXT]\r
 199     output = ...  # type: Any\r
 200 \r
 201     if sys.version_info >= (3, 5):\r
 202         # morally: Optional[_TXT]\r
 203         stdout = ...  # type: Any\r
 204         stderr = ...  # type: Any\r
 205 \r
 206     def __init__(self,\r
 207                  returncode: int,\r
 208                  cmd: _CMD,\r
 209                  output: Optional[_TXT] = ...,\r
 210                  stderr: Optional[_TXT] = ...) -> None: ...\r
 211 \r
 212 class Popen:\r
 213     args = ...  # type: _CMD\r
 214     stdin = ...  # type: IO[Any]\r
 215     stdout = ...  # type: IO[Any]\r
 216     stderr = ...  # type: IO[Any]\r
 217     pid = 0\r
 218     returncode = 0\r
 219 \r
 220     if sys.version_info >= (3, 6):\r
 221         def __init__(self,\r
 222                      args: _CMD,\r
 223                      bufsize: int = ...,\r
 224                      executable: Optional[_PATH] = ...,\r
 225                      stdin: Optional[_FILE] = ...,\r
 226                      stdout: Optional[_FILE] = ...,\r
 227                      stderr: Optional[_FILE] = ...,\r
 228                      preexec_fn: Optional[Callable[[], Any]] = ...,\r
 229                      close_fds: bool = ...,\r
 230                      shell: bool = ...,\r
 231                      cwd: Optional[_PATH] = ...,\r
 232                      env: Optional[_ENV] = ...,\r
 233                      universal_newlines: bool = ...,\r
 234                      startupinfo: Optional[Any] = ...,\r
 235                      creationflags: int = ...,\r
 236                      restore_signals: bool = ...,\r
 237                      start_new_session: bool = ...,\r
 238                      pass_fds: Any = ...,\r
 239                      *,\r
 240                      encoding: Optional[str] = ...,\r
 241                      errors: Optional[str] = ...) -> None: ...\r
 242     else:\r
 243         def __init__(self,\r
 244                      args: _CMD,\r
 245                      bufsize: int = ...,\r
 246                      executable: Optional[_PATH] = ...,\r
 247                      stdin: Optional[_FILE] = ...,\r
 248                      stdout: Optional[_FILE] = ...,\r
 249                      stderr: Optional[_FILE] = ...,\r
 250                      preexec_fn: Optional[Callable[[], Any]] = ...,\r
 251                      close_fds: bool = ...,\r
 252                      shell: bool = ...,\r
 253                      cwd: Optional[_PATH] = ...,\r
 254                      env: Optional[_ENV] = ...,\r
 255                      universal_newlines: bool = ...,\r
 256                      startupinfo: Optional[Any] = ...,\r
 257                      creationflags: int = ...,\r
 258                      restore_signals: bool = ...,\r
 259                      start_new_session: bool = ...,\r
 260                      pass_fds: Any = ...) -> None: ...\r
 261 \r
 262     def poll(self) -> int: ...\r
 263     def wait(self, timeout: Optional[float] = ...) -> int: ...\r
 264     # Return str/bytes\r
 265     def communicate(self,\r
 266                     input: Optional[_TXT] = ...,\r
 267                     timeout: Optional[float] = ...,\r
 268                     # morally: -> Tuple[Optional[_TXT], Optional[_TXT]]\r
 269                     ) -> Tuple[Any, Any]: ...\r
 270     def send_signal(self, signal: int) -> None: ...\r
 271     def terminate(self) -> None: ...\r
 272     def kill(self) -> None: ...\r
 273     def __enter__(self) -> 'Popen': ...\r
 274     def __exit__(self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]) -> bool: ...\r
 275 \r
 276 # The result really is always a str.\r
 277 def getstatusoutput(cmd: _TXT) -> Tuple[int, str]: ...\r
 278 def getoutput(cmd: _TXT) -> str: ...\r
 279 \r
 280 def list2cmdline(seq: Sequence[str]) -> str: ...  # undocumented\r
 281 \r
 282 if sys.platform == 'win32':\r
 283     class STARTUPINFO:\r
 284         if sys.version_info >= (3, 7):\r
 285             def __init__(self, *, dwFlags: int = ..., hStdInput: Optional[Any] = ..., hStdOutput: Optional[Any] = ..., hStdError: Optional[Any] = ..., wShowWindow: int = ..., lpAttributeList: Optional[Mapping[str, Any]] = ...) -> None: ...\r
 286         dwFlags: int\r
 287         hStdInput: Optional[Any]\r
 288         hStdOutput: Optional[Any]\r
 289         hStdError: Optional[Any]\r
 290         wShowWindow: int\r
 291         if sys.version_info >= (3, 7):\r
 292             lpAttributeList: Mapping[str, Any]\r
 293 \r
 294     STD_INPUT_HANDLE: Any\r
 295     STD_OUTPUT_HANDLE: Any\r
 296     STD_ERROR_HANDLE: Any\r
 297     SW_HIDE: int\r
 298     STARTF_USESTDHANDLES: int\r
 299     STARTF_USESHOWWINDOW: int\r
 300     CREATE_NEW_CONSOLE: int\r
 301     CREATE_NEW_PROCESS_GROUP: int\r
 302     if sys.version_info >= (3, 7):\r
 303         ABOVE_NORMAL_PRIORITY_CLASS: int\r
 304         BELOW_NORMAL_PRIORITY_CLASS: int\r
 305         HIGH_PRIORITY_CLASS: int\r
 306         IDLE_PRIORITY_CLASS: int\r
 307         NORMAL_PRIORITY_CLASS: int\r
 308         REALTIME_PRIORITY_CLASS: int\r
 309         CREATE_NO_WINDOW: int\r
 310         DETACHED_PROCESS: int\r
 311         CREATE_DEFAULT_ERROR_MODE: int\r
 312         CREATE_BREAKAWAY_FROM_JOB: int\r