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

   1 # Stubs for tarfile\r
   2 \r
   3 from typing import (\r
   4     Callable, IO, Iterable, Iterator, List, Mapping, Optional, Type,\r
   5     Union,\r
   6 )\r
   7 import os\r
   8 import sys\r
   9 from types import TracebackType\r
  10 \r
  11 \r
  12 if sys.version_info >= (3, 6):\r
  13     _Path = Union[bytes, str, os.PathLike]\r
  14 elif sys.version_info >= (3,):\r
  15     _Path = Union[bytes, str]\r
  16 else:\r
  17     _Path = Union[str, unicode]\r
  18 \r
  19 ENCODING = ...  # type: str\r
  20 \r
  21 USTAR_FORMAT = ...  # type: int\r
  22 GNU_FORMAT = ...  # type: int\r
  23 PAX_FORMAT = ...  # type: int\r
  24 DEFAULT_FORMAT = ...  # type: int\r
  25 \r
  26 REGTYPE = ...  # type: bytes\r
  27 AREGTYPE = ...  # type: bytes\r
  28 LNKTYPE = ...  # type: bytes\r
  29 SYMTYPE = ...  # type: bytes\r
  30 DIRTYPE = ...  # type: bytes\r
  31 FIFOTYPE = ...  # type: bytes\r
  32 CONTTYPE = ...  # type: bytes\r
  33 CHRTYPE = ...  # type: bytes\r
  34 BLKTYPE = ...  # type: bytes\r
  35 GNUTYPE_SPARSE = ...  # type: bytes\r
  36 \r
  37 if sys.version_info < (3,):\r
  38     TAR_PLAIN = ...  # type: int\r
  39     TAR_GZIPPED = ...  # type: int\r
  40 \r
  41 def open(name: Optional[_Path] = ..., mode: str = ...,\r
  42         fileobj: Optional[IO[bytes]] = ..., bufsize: int = ...,\r
  43         *, format: Optional[int] = ..., tarinfo: Optional[TarInfo] = ...,\r
  44         dereference: Optional[bool] = ...,\r
  45         ignore_zeros: Optional[bool] = ...,\r
  46         encoding: Optional[str] = ..., errors: str = ...,\r
  47         pax_headers: Optional[Mapping[str, str]] = ...,\r
  48         debug: Optional[int] = ...,\r
  49         errorlevel: Optional[int] = ...,\r
  50         compresslevel: Optional[int] = ...) -> TarFile: ...\r
  51 \r
  52 \r
  53 class TarFile(Iterable[TarInfo]):\r
  54     name = ...  # type: Optional[_Path]\r
  55     mode = ...  # type: str\r
  56     fileobj = ...  # type: Optional[IO[bytes]]\r
  57     format = ...  # type: Optional[int]\r
  58     tarinfo = ...  # type: Optional[TarInfo]\r
  59     dereference = ...  # type: Optional[bool]\r
  60     ignore_zeros = ...  # type: Optional[bool]\r
  61     encoding = ...  # type: Optional[str]\r
  62     errors = ...  # type: str\r
  63     pax_headers = ...  # type: Optional[Mapping[str, str]]\r
  64     debug = ...  # type: Optional[int]\r
  65     errorlevel = ...  # type: Optional[int]\r
  66     if sys.version_info < (3,):\r
  67         posix = ...  # type: bool\r
  68     def __init__(self, name: Optional[_Path] = ..., mode: str = ...,\r
  69                  fileobj: Optional[IO[bytes]] = ...,\r
  70                  format: Optional[int] = ..., tarinfo: Optional[TarInfo] = ...,\r
  71                  dereference: Optional[bool] = ...,\r
  72                  ignore_zeros: Optional[bool] = ...,\r
  73                  encoding: Optional[str] = ..., errors: str = ...,\r
  74                  pax_headers: Optional[Mapping[str, str]] = ...,\r
  75                  debug: Optional[int] = ...,\r
  76                  errorlevel: Optional[int] = ...,\r
  77                  compresslevel: Optional[int] = ...) -> None: ...\r
  78     def __enter__(self) -> TarFile: ...\r
  79     def __exit__(self,\r
  80                  exc_type: Optional[Type[BaseException]],\r
  81                  exc_val: Optional[Exception],\r
  82                  exc_tb: Optional[TracebackType]) -> bool: ...\r
  83     def __iter__(self) -> Iterator[TarInfo]: ...\r
  84     @classmethod\r
  85     def open(cls, name: Optional[_Path] = ..., mode: str = ...,\r
  86              fileobj: Optional[IO[bytes]] = ..., bufsize: int = ...,\r
  87              *, format: Optional[int] = ..., tarinfo: Optional[TarInfo] = ...,\r
  88              dereference: Optional[bool] = ...,\r
  89              ignore_zeros: Optional[bool] = ...,\r
  90              encoding: Optional[str] = ..., errors: str = ...,\r
  91              pax_headers: Optional[Mapping[str, str]] = ...,\r
  92              debug: Optional[int] = ...,\r
  93              errorlevel: Optional[int] = ...) -> TarFile: ...\r
  94     def getmember(self, name: str) -> TarInfo: ...\r
  95     def getmembers(self) -> List[TarInfo]: ...\r
  96     def getnames(self) -> List[str]: ...\r
  97     if sys.version_info >= (3, 5):\r
  98         def list(self, verbose: bool = ...,\r
  99                  *, members: Optional[List[TarInfo]] = ...) -> None: ...\r
 100     else:\r
 101         def list(self, verbose: bool = ...) -> None: ...\r
 102     def next(self) -> Optional[TarInfo]: ...\r
 103     if sys.version_info >= (3, 5):\r
 104         def extractall(self, path: _Path = ...,\r
 105                        members: Optional[List[TarInfo]] = ...,\r
 106                        *, numeric_owner: bool = ...) -> None: ...\r
 107     else:\r
 108         def extractall(self, path: _Path = ...,\r
 109                        members: Optional[List[TarInfo]] = ...) -> None: ...\r
 110     if sys.version_info >= (3, 5):\r
 111         def extract(self, member: Union[str, TarInfo], path: _Path = ...,\r
 112                     set_attrs: bool = ...,\r
 113                     *, numeric_owner: bool = ...) -> None: ...\r
 114     elif sys.version_info >= (3,):\r
 115         def extract(self, member: Union[str, TarInfo], path: _Path = ...,\r
 116                     set_attrs: bool = ...) -> None: ...\r
 117     else:\r
 118         def extract(self, member: Union[str, TarInfo],\r
 119                     path: _Path = ...) -> None: ...\r
 120     def extractfile(self,\r
 121                     member: Union[str, TarInfo]) -> Optional[IO[bytes]]: ...\r
 122     if sys.version_info >= (3, 7):\r
 123         def add(self, name: str, arcname: Optional[str] = ...,\r
 124                 recursive: bool = ..., *,\r
 125                 filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ...) -> None: ...\r
 126     elif sys.version_info >= (3,):\r
 127         def add(self, name: str, arcname: Optional[str] = ...,\r
 128                 recursive: bool = ...,\r
 129                 exclude: Optional[Callable[[str], bool]] = ..., *,\r
 130                 filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ...) -> None: ...\r
 131     else:\r
 132         def add(self, name: str, arcname: Optional[str] = ...,\r
 133                 recursive: bool = ...,\r
 134                 exclude: Optional[Callable[[str], bool]] = ...,\r
 135                 filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ...) -> None: ...\r
 136     def addfile(self, tarinfo: TarInfo,\r
 137                 fileobj: Optional[IO[bytes]] = ...) -> None: ...\r
 138     def gettarinfo(self, name: Optional[str] = ...,\r
 139                    arcname: Optional[str] = ...,\r
 140                    fileobj: Optional[IO[bytes]] = ...) -> TarInfo: ...\r
 141     def close(self) -> None: ...\r
 142 \r
 143 \r
 144 def is_tarfile(name: str) -> bool: ...\r
 145 \r
 146 \r
 147 if sys.version_info < (3,):\r
 148     class TarFileCompat:\r
 149         def __init__(self, filename: str, mode: str = ...,\r
 150                      compression: int = ...) -> None: ...\r
 151 \r
 152 \r
 153 class TarError(Exception): ...\r
 154 class ReadError(TarError): ...\r
 155 class CompressionError(TarError): ...\r
 156 class StreamError(TarError): ...\r
 157 class ExtractError(TarError): ...\r
 158 class HeaderError(TarError): ...\r
 159 \r
 160 \r
 161 class TarInfo:\r
 162     name = ...  # type: str\r
 163     size = ...  # type: int\r
 164     mtime = ...  # type: int\r
 165     mode = ...  # type: int\r
 166     type = ...  # type: bytes\r
 167     linkname = ...  # type: str\r
 168     uid = ...  # type: int\r
 169     gid = ...  # type: int\r
 170     uname = ...  # type: str\r
 171     gname = ...  # type: str\r
 172     pax_headers = ...  # type: Mapping[str, str]\r
 173     def __init__(self, name: str = ...) -> None: ...\r
 174     if sys.version_info >= (3,):\r
 175         @classmethod\r
 176         def frombuf(cls, buf: bytes, encoding: str, errors: str) -> TarInfo: ...\r
 177     else:\r
 178         @classmethod\r
 179         def frombuf(cls, buf: bytes) -> TarInfo: ...\r
 180     @classmethod\r
 181     def fromtarfile(cls, tarfile: TarFile) -> TarInfo: ...\r
 182     def tobuf(self, format: Optional[int] = ...,\r
 183               encoding: Optional[str] = ..., errors: str = ...) -> bytes: ...\r
 184     def isfile(self) -> bool: ...\r
 185     def isreg(self) -> bool: ...\r
 186     def isdir(self) -> bool: ...\r
 187     def issym(self) -> bool: ...\r
 188     def islnk(self) -> bool: ...\r
 189     def ischr(self) -> bool: ...\r
 190     def isblk(self) -> bool: ...\r
 191     def isfifo(self) -> bool: ...\r
 192     def isdev(self) -> bool: ...\r