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

   1 # Stubs for urllib.request (Python 3.4)\r
   2 \r
   3 from typing import (\r
   4     Any, Callable, ClassVar, Dict, List, IO, Mapping, Optional, Sequence, Tuple,\r
   5     TypeVar, Union, overload,\r
   6 )\r
   7 from http.client import HTTPResponse, HTTPMessage\r
   8 from http.cookiejar import CookieJar\r
   9 from email.message import Message\r
  10 from urllib.response import addinfourl\r
  11 import ssl\r
  12 import sys\r
  13 import os\r
  14 \r
  15 _T = TypeVar('_T')\r
  16 _UrlopenRet = Union[HTTPResponse, addinfourl]\r
  17 \r
  18 \r
  19 def urlopen(\r
  20     url: Union[str, 'Request'], data: Optional[bytes] = ...,\r
  21     timeout: float = ..., *, cafile: Optional[str] = ...,\r
  22     capath: Optional[str] = ..., cadefault: bool = ...,\r
  23     context: Optional[ssl.SSLContext] = ...\r
  24 ) -> _UrlopenRet: ...\r
  25 def install_opener(opener: OpenerDirector) -> None: ...\r
  26 def build_opener(\r
  27     *handlers: Union[BaseHandler, Callable[[], BaseHandler]]\r
  28 ) -> OpenerDirector: ...\r
  29 def url2pathname(path: str) -> str: ...\r
  30 def pathname2url(path: str) -> str: ...\r
  31 def getproxies() -> Dict[str, str]: ...\r
  32 def parse_http_list(s: str) -> List[str]: ...\r
  33 def parse_keqv_list(l: List[str]) -> Dict[str, str]: ...\r
  34 \r
  35 class Request:\r
  36     @property\r
  37     def full_url(self) -> str: ...\r
  38     @full_url.setter\r
  39     def full_url(self, value: str) -> None: ...\r
  40     @full_url.deleter\r
  41     def full_url(self) -> None: ...\r
  42     type: str\r
  43     host: str\r
  44     origin_req_host: str\r
  45     selector: str\r
  46     data: Optional[bytes]\r
  47     headers: Dict[str, str]\r
  48     unverifiable: bool\r
  49     method: Optional[str]\r
  50     def __init__(self, url: str, data: Optional[bytes] = ...,\r
  51             headers: Dict[str, str] =..., origin_req_host: Optional[str] = ...,\r
  52             unverifiable: bool = ..., method: Optional[str] = ...) -> None: ...\r
  53     def get_method(self) -> str: ...\r
  54     def add_header(self, key: str, val: str) -> None: ...\r
  55     def add_unredirected_header(self, key: str, val: str) -> None: ...\r
  56     def has_header(self, header_name: str) -> bool: ...\r
  57     def remove_header(self, header_name: str) -> None: ...\r
  58     def get_full_url(self) -> str: ...\r
  59     def set_proxy(self, host: str, type: str) -> None: ...\r
  60     @overload\r
  61     def get_header(self, header_name: str) -> Optional[str]: ...\r
  62     @overload\r
  63     def get_header(self, header_name: str, default: _T) -> Union[str, _T]: ...\r
  64     def header_items(self) -> List[Tuple[str, str]]: ...\r
  65 \r
  66 class OpenerDirector:\r
  67     addheaders: List[Tuple[str, str]]\r
  68     def add_handler(self, handler: BaseHandler) -> None: ...\r
  69     def open(self, url: Union[str, Request], data: Optional[bytes] = ...,\r
  70              timeout: float = ...) -> _UrlopenRet: ...\r
  71     def error(self, proto: str, *args: Any) -> _UrlopenRet: ...\r
  72 \r
  73 \r
  74 class BaseHandler:\r
  75     handler_order: ClassVar[int]\r
  76     parent: OpenerDirector\r
  77     def add_parent(self, parent: OpenerDirector) -> None: ...\r
  78     def close(self) -> None: ...\r
  79     def http_error_nnn(self, req: Request, fp: IO[str], code: int, msg: int,\r
  80                        hdrs: Mapping[str, str]) -> _UrlopenRet: ...\r
  81 \r
  82 class HTTPDefaultErrorHandler(BaseHandler): ...\r
  83 \r
  84 class HTTPRedirectHandler(BaseHandler):\r
  85     def redirect_request(self, req: Request, fp: IO[str], code: int, msg: int,\r
  86                          hdrs: Mapping[str, str],\r
  87                          newurl: str) -> Optional[Request]: ...\r
  88     def http_error_301(self, req: Request, fp: IO[str], code: int, msg: int,\r
  89                        hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...\r
  90     def http_error_302(self, req: Request, fp: IO[str], code: int, msg: int,\r
  91                        hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...\r
  92     def http_error_303(self, req: Request, fp: IO[str], code: int, msg: int,\r
  93                        hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...\r
  94     def http_error_307(self, req: Request, fp: IO[str], code: int, msg: int,\r
  95                        hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...\r
  96 \r
  97 class HTTPCookieProcessor(BaseHandler):\r
  98     cookiejar: CookieJar\r
  99     def __init__(self, cookiejar: Optional[CookieJar] = ...) -> None: ...\r
 100 \r
 101 class ProxyHandler(BaseHandler):\r
 102     def __init__(self, proxies: Optional[Dict[str, str]] = ...) -> None: ...\r
 103     # TODO add a method for every (common) proxy protocol\r
 104 \r
 105 class HTTPPasswordMgr:\r
 106     def add_password(self, realm: str, uri: Union[str, Sequence[str]],\r
 107                      user: str, passwd: str) -> None: ...\r
 108     def find_user_password(self, realm: str, authuri: str) -> Tuple[Optional[str], Optional[str]]: ...\r
 109 \r
 110 class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr):\r
 111     def add_password(self, realm: str, uri: Union[str, Sequence[str]],\r
 112                      user: str, passwd: str) -> None: ...\r
 113     def find_user_password(self, realm: str, authuri: str) -> Tuple[Optional[str], Optional[str]]: ...\r
 114 \r
 115 if sys.version_info >= (3, 5):\r
 116     class HTTPPasswordMgrWithPriorAuth(HTTPPasswordMgrWithDefaultRealm):\r
 117         def add_password(self, realm: str, uri: Union[str, Sequence[str]],\r
 118                          user: str, passwd: str,\r
 119                          is_authenticated: bool = ...) -> None: ...\r
 120         def update_authenticated(self, uri: Union[str, Sequence[str]],\r
 121                                  is_authenticated: bool = ...) -> None: ...\r
 122         def is_authenticated(self, authuri: str) -> bool: ...\r
 123 \r
 124 class AbstractBasicAuthHandler:\r
 125     def __init__(self,\r
 126                  password_mgr: Optional[HTTPPasswordMgr] = ...) -> None: ...\r
 127     def http_error_auth_reqed(self, authreq: str, host: str, req: Request,\r
 128                               headers: Mapping[str, str]) -> None: ...\r
 129 \r
 130 class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):\r
 131     def http_error_401(self, req: Request, fp: IO[str], code: int, msg: int,\r
 132                        hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...\r
 133 \r
 134 class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):\r
 135     def http_error_407(self, req: Request, fp: IO[str], code: int, msg: int,\r
 136                        hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...\r
 137 \r
 138 class AbstractDigestAuthHandler:\r
 139     def __init__(self, passwd: Optional[HTTPPasswordMgr] = ...) -> None: ...\r
 140     def reset_retry_count(self) -> None: ...\r
 141     def http_error_auth_reqed(self, auth_header: str, host: str, req: Request,\r
 142                               headers: Mapping[str, str]) -> None: ...\r
 143     def retry_http_digest_auth(self, req: Request, auth: str) -> Optional[_UrlopenRet]: ...\r
 144     def get_cnonce(self, nonce: str) -> str: ...\r
 145     def get_authorization(self, req: Request, chal: Mapping[str, str]) -> str: ...\r
 146     def get_algorithm_impls(self, algorithm: str) -> Tuple[Callable[[str], str], Callable[[str, str], str]]: ...\r
 147     def get_entity_digest(self, data: Optional[bytes], chal: Mapping[str, str]) -> Optional[str]: ...\r
 148 \r
 149 class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):\r
 150     def http_error_401(self, req: Request, fp: IO[str], code: int, msg: int,\r
 151                        hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...\r
 152 \r
 153 class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):\r
 154     def http_error_407(self, req: Request, fp: IO[str], code: int, msg: int,\r
 155                        hdrs: Mapping[str, str]) -> Optional[_UrlopenRet]: ...\r
 156 \r
 157 class HTTPHandler(BaseHandler):\r
 158     def http_open(self, req: Request) -> _UrlopenRet: ...\r
 159 \r
 160 class HTTPSHandler(BaseHandler):\r
 161     def __init__(self, debuglevel: int = ...,\r
 162                  context: Optional[ssl.SSLContext] = ...,\r
 163                  check_hostname: bool = ...) -> None: ...\r
 164     def https_open(self, req: Request) -> _UrlopenRet: ...\r
 165 \r
 166 class FileHandler(BaseHandler):\r
 167     def file_open(self, req: Request) -> _UrlopenRet: ...\r
 168 \r
 169 class DataHandler(BaseHandler):\r
 170     def data_open(self, req: Request) -> _UrlopenRet: ...\r
 171 \r
 172 class FTPHandler(BaseHandler):\r
 173     def ftp_open(self, req: Request) -> _UrlopenRet: ...\r
 174 \r
 175 class CacheFTPHandler(FTPHandler):\r
 176     def setTimeout(self, t: float) -> None: ...\r
 177     def setMaxConns(self, m: int) -> None: ...\r
 178 \r
 179 class UnknownHandler(BaseHandler):\r
 180     def unknown_open(self, req: Request) -> _UrlopenRet: ...\r
 181 \r
 182 class HTTPErrorProcessor(BaseHandler):\r
 183     def http_response(self) -> _UrlopenRet: ...\r
 184     def https_response(self) -> _UrlopenRet: ...\r
 185 \r
 186 if sys.version_info >= (3, 6):\r
 187     def urlretrieve(url: str, filename: Optional[Union[str, os.PathLike]] = ...,\r
 188                     reporthook: Optional[Callable[[int, int, int], None]] = ...,\r
 189                     data: Optional[bytes] = ...) -> Tuple[str, HTTPMessage]: ...\r
 190 else:\r
 191     def urlretrieve(url: str, filename: Optional[str] = ...,\r
 192                     reporthook: Optional[Callable[[int, int, int], None]] = ...,\r
 193                     data: Optional[bytes] = ...) -> Tuple[str, HTTPMessage]: ...\r
 194 def urlcleanup() -> None: ...\r
 195 \r
 196 class URLopener:\r
 197     version: ClassVar[str]\r
 198     def __init__(self, proxies: Optional[Dict[str, str]] = ...,\r
 199                  **x509: str) -> None: ...\r
 200     def open(self, fullurl: str, data: Optional[bytes] = ...) -> _UrlopenRet: ...\r
 201     def open_unknown(self, fullurl: str,\r
 202                      data: Optional[bytes] = ...) -> _UrlopenRet: ...\r
 203     def retrieve(self, url: str, filename: Optional[str] = ...,\r
 204                  reporthook: Optional[Callable[[int, int, int], None]] = ...,\r
 205                  data: Optional[bytes] = ...) -> Tuple[str, Optional[Message]]: ...\r
 206 \r
 207 class FancyURLopener(URLopener):\r
 208     def prompt_user_passwd(self, host: str, realm: str) -> Tuple[str, str]: ...\r