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

   1 # Stubs for urllib.parse\r
   2 from typing import Any, List, Dict, Tuple, AnyStr, Generic, overload, Sequence, Mapping, Union, NamedTuple, Callable\r
   3 import sys\r
   4 \r
   5 _Str = Union[bytes, str]\r
   6 \r
   7 \r
   8 uses_relative = ...  # type: List[str]\r
   9 uses_netloc = ...  # type: List[str]\r
  10 uses_params = ...  # type: List[str]\r
  11 non_hierarchical = ...  # type: List[str]\r
  12 uses_query = ...  # type: List[str]\r
  13 uses_fragment = ...  # type: List[str]\r
  14 scheme_chars = ...  # type: str\r
  15 MAX_CACHE_SIZE = 0\r
  16 \r
  17 class _ResultMixinBase(Generic[AnyStr]):\r
  18     def geturl(self) -> AnyStr: ...\r
  19 \r
  20 class _ResultMixinStr(_ResultMixinBase[str]):\r
  21     def encode(self, encoding: str = ..., errors: str = ...) -> '_ResultMixinBytes': ...\r
  22 \r
  23 \r
  24 class _ResultMixinBytes(_ResultMixinBase[str]):\r
  25     def decode(self, encoding: str = ..., errors: str = ...) -> '_ResultMixinStr': ...\r
  26 \r
  27 \r
  28 class _NetlocResultMixinBase(Generic[AnyStr]):\r
  29     username = ...  # type: AnyStr\r
  30     password = ...  # type: AnyStr\r
  31     hostname = ...  # type: AnyStr\r
  32     port = ...  # type: int\r
  33 \r
  34 class _NetlocResultMixinStr(_NetlocResultMixinBase[str], _ResultMixinStr): ...\r
  35 \r
  36 \r
  37 class _NetlocResultMixinBytes(_NetlocResultMixinBase[str], _ResultMixinBytes): ...\r
  38 \r
  39 class _DefragResultBase(tuple, Generic[AnyStr]):\r
  40     url = ...  # type: AnyStr\r
  41     fragment = ...  # type: AnyStr\r
  42 \r
  43 \r
  44 _SplitResultBase = NamedTuple(\r
  45     '_SplitResultBase',\r
  46     [\r
  47         ('scheme', str), ('netloc', str), ('path', str), ('query', str), ('fragment', str)\r
  48     ]\r
  49 )\r
  50 _SplitResultBytesBase = NamedTuple(\r
  51     '_SplitResultBytesBase',\r
  52     [\r
  53         ('scheme', bytes), ('netloc', bytes), ('path', bytes), ('query', bytes), ('fragment', bytes)\r
  54     ]\r
  55 )\r
  56 \r
  57 _ParseResultBase = NamedTuple(\r
  58     '_ParseResultBase',\r
  59     [\r
  60         ('scheme', str), ('netloc', str), ('path', str), ('params', str), ('query', str), ('fragment', str)\r
  61     ]\r
  62 )\r
  63 _ParseResultBytesBase = NamedTuple(\r
  64     '_ParseResultBytesBase',\r
  65     [\r
  66         ('scheme', bytes), ('netloc', bytes), ('path', bytes), ('params', bytes), ('query', bytes), ('fragment', bytes)\r
  67     ]\r
  68 )\r
  69 \r
  70 # Structured result objects for string data\r
  71 class DefragResult(_DefragResultBase[str], _ResultMixinStr): ...\r
  72 \r
  73 class SplitResult(_SplitResultBase, _NetlocResultMixinStr): ...\r
  74 \r
  75 class ParseResult(_ParseResultBase, _NetlocResultMixinStr): ...\r
  76 \r
  77 # Structured result objects for bytes data\r
  78 class DefragResultBytes(_DefragResultBase[bytes], _ResultMixinBytes): ...\r
  79 \r
  80 class SplitResultBytes(_SplitResultBytesBase, _NetlocResultMixinBytes): ...\r
  81 \r
  82 class ParseResultBytes(_ParseResultBytesBase, _NetlocResultMixinBytes): ...\r
  83 \r
  84 \r
  85 def parse_qs(qs: AnyStr, keep_blank_values: bool = ..., strict_parsing: bool = ..., encoding: str = ..., errors: str = ...) -> Dict[AnyStr, List[AnyStr]]: ...\r
  86 \r
  87 def parse_qsl(qs: AnyStr, keep_blank_values: bool = ..., strict_parsing: bool = ..., encoding: str = ..., errors: str = ...) -> List[Tuple[AnyStr, AnyStr]]: ...\r
  88 \r
  89 \r
  90 @overload\r
  91 def quote(string: str, safe: _Str = ..., encoding: str = ..., errors: str = ...) -> str: ...\r
  92 @overload\r
  93 def quote(string: bytes, safe: _Str = ...) -> str: ...\r
  94 \r
  95 def quote_from_bytes(bs: bytes, safe: _Str = ...) -> str: ...\r
  96 \r
  97 @overload\r
  98 def quote_plus(string: str, safe: _Str = ..., encoding: str = ..., errors: str = ...) -> str: ...\r
  99 @overload\r
 100 def quote_plus(string: bytes, safe: _Str = ...) -> str: ...\r
 101 \r
 102 def unquote(string: str, encoding: str = ..., errors: str = ...) -> str: ...\r
 103 \r
 104 def unquote_to_bytes(string: _Str) -> bytes: ...\r
 105 \r
 106 def unquote_plus(string: str, encoding: str = ..., errors: str = ...) -> str: ...\r
 107 \r
 108 @overload\r
 109 def urldefrag(url: str) -> DefragResult: ...\r
 110 @overload\r
 111 def urldefrag(url: bytes) -> DefragResultBytes: ...\r
 112 \r
 113 if sys.version_info >= (3, 5):\r
 114     def urlencode(query: Union[Mapping[Any, Any],\r
 115                                Mapping[Any, Sequence[Any]],\r
 116                                Sequence[Tuple[Any, Any]],\r
 117                                Sequence[Tuple[Any, Sequence[Any]]]],\r
 118                   doseq: bool = ..., safe: AnyStr = ..., encoding: str = ..., errors: str = ...,\r
 119                   quote_via: Callable[[str, AnyStr, str, str], str] = ...) -> str: ...\r
 120 else:\r
 121     def urlencode(query: Union[Mapping[Any, Any],\r
 122                                Mapping[Any, Sequence[Any]],\r
 123                                Sequence[Tuple[Any, Any]],\r
 124                                Sequence[Tuple[Any, Sequence[Any]]]],\r
 125                   doseq: bool = ..., safe: AnyStr = ..., encoding: str = ..., errors: str = ...) -> str: ...\r
 126 \r
 127 def urljoin(base: AnyStr, url: AnyStr, allow_fragments: bool = ...) -> AnyStr: ...\r
 128 \r
 129 @overload\r
 130 def urlparse(url: str, scheme: str = ..., allow_fragments: bool = ...) -> ParseResult: ...\r
 131 @overload\r
 132 def urlparse(url: bytes, scheme: bytes = ..., allow_fragments: bool = ...) -> ParseResultBytes: ...\r
 133 \r
 134 @overload\r
 135 def urlsplit(url: str, scheme: str = ..., allow_fragments: bool = ...) -> SplitResult: ...\r
 136 @overload\r
 137 def urlsplit(url: bytes, scheme: bytes = ..., allow_fragments: bool = ...) -> SplitResultBytes: ...\r
 138 \r
 139 @overload\r
 140 def urlunparse(components: Tuple[AnyStr, AnyStr, AnyStr, AnyStr, AnyStr, AnyStr]) -> AnyStr: ...\r
 141 @overload\r
 142 def urlunparse(components: Sequence[AnyStr]) -> AnyStr: ...\r
 143 \r
 144 @overload\r
 145 def urlunsplit(components: Tuple[AnyStr, AnyStr, AnyStr, AnyStr, AnyStr]) -> AnyStr: ...\r
 146 @overload\r
 147 def urlunsplit(components: Sequence[AnyStr]) -> AnyStr: ...\r