.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/third_party/2/itsdangerous.pyi

   1 from datetime import datetime\r
   2 from itertools import izip\r
   3 from typing import Any, Callable, IO, MutableMapping, Optional, Text, Tuple, Union\r
   4 \r
   5 PY2 = ...  # type: bool\r
   6 text_type = unicode\r
   7 int_to_byte = chr\r
   8 number_types = (int, long, float)\r
   9 _serializer = Any  # must be an object that has "dumps" and "loads" attributes (e.g. the json module)\r
  10 \r
  11 bytes_like = Union[bytearray, str]\r
  12 \r
  13 class _CompactJSON:\r
  14     def loads(self, payload: Text) -> Any: ...\r
  15     def dumps(self, obj: Any) -> Text: ...\r
  16 \r
  17 compact_json = _CompactJSON\r
  18 EPOCH = ...  # type: int\r
  19 \r
  20 def want_bytes(s: str, encoding: str = ..., errors: str = ...) -> bytes: ...\r
  21 def is_text_serializer(serializer: Any) -> bool: ...\r
  22 def constant_time_compare(val1: bytes_like, val2: bytes_like) -> bool: ...\r
  23 \r
  24 class BadData(Exception):\r
  25     message = ...  # type: str\r
  26     def __init__(self, message: str) -> None: ...\r
  27 \r
  28 class BadPayload(BadData):\r
  29     original_error = ...  # type: Optional[Exception]\r
  30     def __init__(self, message: str, original_error: Optional[Exception] = ...) -> None: ...\r
  31 \r
  32 class BadSignature(BadData):\r
  33     payload = ...  # type: Optional[Any]\r
  34     def __init__(self, message: str, payload: Optional[Any] = ...) -> None: ...\r
  35 \r
  36 class BadTimeSignature(BadSignature):\r
  37     date_signed = ...  # type: Optional[int]\r
  38     def __init__(self, message, payload: Optional[Any] = ..., date_signed: Optional[int] = ...) -> None: ...\r
  39 \r
  40 class BadHeader(BadSignature):\r
  41     header = ...  # type: Any\r
  42     original_error = ...  # type: Any\r
  43     def __init__(self, message, payload=None, header=None, original_error=None) -> None: ...\r
  44 \r
  45 class SignatureExpired(BadTimeSignature): ...\r
  46 \r
  47 def base64_encode(string: bytes_like) -> bytes: ...\r
  48 def base64_decode(string: bytes_like) -> bytes: ...\r
  49 def int_to_bytes(num: int) -> bytes: ...\r
  50 def bytes_to_int(bytestr: bytes_like) -> bytes: ...\r
  51 \r
  52 class SigningAlgorithm:\r
  53     def get_signature(self, key: bytes_like, value: bytes_like) -> bytes: ...\r
  54     def verify_signature(self, key: bytes_like, value: bytes_like, sig: bytes_like) -> bool: ...\r
  55 \r
  56 class NoneAlgorithm(SigningAlgorithm):\r
  57     def get_signature(self, key: bytes_like, value: bytes_like) -> str: ...\r
  58 \r
  59 class HMACAlgorithm(SigningAlgorithm):\r
  60     default_digest_method = ...  # type: Callable\r
  61     digest_method = ...  # type: Callable\r
  62     def __init__(self, digest_method: Optional[Callable] = ...) -> None: ...\r
  63     def get_signature(self, key: bytes_like, value: bytes_like) -> bytes: ...\r
  64 \r
  65 class Signer:\r
  66     default_digest_method = ...  # type: Callable\r
  67     default_key_derivation = ...  # type: str\r
  68     secret_key = ...  # type: bytes_like\r
  69     sep = ...  # type: str\r
  70     salt = ...  # type: bytes_like\r
  71     key_derivation = ...  # type: str\r
  72     digest_method = ...  # type: Callable\r
  73     algorithm = ...  # type: SigningAlgorithm\r
  74     def __init__(self, secret_key: bytes_like, salt: Optional[bytes_like] = ..., sep: Optional[str] = ...,\r
  75                  key_derivation: Optional[str] = ...,\r
  76                  digest_method: Optional[Callable] = ...,\r
  77                  algorithm: Optional[SigningAlgorithm] = ...) -> None: ...\r
  78     def derive_key(self) -> bytes: ...\r
  79     def get_signature(self, value: bytes_like) -> bytes: ...\r
  80     def sign(self, value: bytes_like) -> bytes: ...\r
  81     def verify_signature(self, value: bytes_like, sig: bytes_like) -> bool: ...\r
  82     def unsign(self, signed_value: str) -> str: ...\r
  83     def validate(self, signed_value: str) -> bool: ...\r
  84 \r
  85 class TimestampSigner(Signer):\r
  86     def get_timestamp(self) -> int: ...\r
  87     def timestamp_to_datetime(self, ts: int) -> datetime: ...\r
  88     def sign(self, value: bytes_like) -> bytes: ...\r
  89     def unsign(self, value: str, max_age: Optional[int] = ..., return_timestamp: bool = ...) -> Any: ...\r
  90     def validate(self, signed_value: str, max_age: Optional[int] = ...) -> bool: ...\r
  91 \r
  92 class Serializer:\r
  93     default_serializer = ...  # type: _serializer\r
  94     default_signer = ...  # type: Callable[..., Signer]\r
  95     secret_key = ...  # type: Any\r
  96     salt = ...  # type: bytes_like\r
  97     serializer = ...  # type: _serializer\r
  98     is_text_serializer = ...  # type: bool\r
  99     signer = ...  # type: Signer\r
 100     signer_kwargs = ...  # type: MutableMapping\r
 101     def __init__(self, secret_key: bytes_like, salt: Optional[bytes_like] = ..., serializer: Optional[_serializer] = ..., signer: Optional[Callable[..., Signer]] = ..., signer_kwargs: Optional[MutableMapping] = ...) -> None: ...\r
 102     def load_payload(self, payload: Any, serializer: Optional[_serializer] = ...) -> Any: ...\r
 103     def dump_payload(self, *args, **kwargs) -> str: ...\r
 104     def make_signer(self, salt: Optional[bytes_like] = ...) -> Signer: ...\r
 105     def dumps(self, obj: Any, salt: Optional[bytes_like] = ...) -> str: ...\r
 106     def dump(self, obj: Any, f: IO[str], salt: Optional[bytes_like] = ...) -> None: ...\r
 107     def loads(self, s: str, salt: Optional[bytes_like] = ...) -> Any: ...\r
 108     def load(self, f: IO[str], salt: Optional[bytes_like] = ...): ...\r
 109     def loads_unsafe(self, s, salt: Optional[bytes_like] = ...) -> Tuple[bool, Any]: ...\r
 110     def load_unsafe(self, f: IO[str], *args, **kwargs) -> Tuple[bool, Any]: ...\r
 111 \r
 112 class TimedSerializer(Serializer):\r
 113     default_signer = ...  # type: Callable[..., TimestampSigner]\r
 114     def loads(self, s: str, salt: Optional[bytes_like] = ..., max_age: Optional[int] = ..., return_timestamp: bool = ...) -> Any: ...\r
 115     def loads_unsafe(self, s: str, salt: Optional[bytes_like] = ..., max_age: Optional[int] = ...) -> Tuple[bool, Any]: ...\r
 116 \r
 117 class JSONWebSignatureSerializer(Serializer):\r
 118     jws_algorithms = ...  # type: MutableMapping[str, SigningAlgorithm]\r
 119     default_algorithm = ...  # type: str\r
 120     default_serializer = ...  # type: Any\r
 121     algorithm_name = ...  # type: str\r
 122     algorithm = ...  # type: Any\r
 123     def __init__(self, secret_key: bytes_like, salt: Optional[bytes_like] = ..., serializer: Optional[_serializer] = ..., signer: Optional[Callable[..., Signer]] = ..., signer_kwargs: Optional[MutableMapping] = ..., algorithm_name: Optional[str] = ...) -> None: ...\r
 124     def load_payload(self, payload: Any, serializer: Optional[_serializer] = ..., return_header: bool = ...) -> Any: ...\r
 125     def dump_payload(self, *args, **kwargs) -> bytes: ...\r
 126     def make_algorithm(self, algorithm_name: str) -> SigningAlgorithm: ...\r
 127     def make_signer(self, salt: Optional[bytes_like] = ..., algorithm_name: Optional[str] = ...) -> Signer: ...\r
 128     def make_header(self, header_fields: Optional[MutableMapping] = ...) -> MutableMapping: ...\r
 129     def dumps(self, obj: Any, salt: Optional[bytes_like] = ..., header_fields: Optional[MutableMapping] = ...) -> str: ...\r
 130     def loads(self, s: str, salt: Optional[bytes_like] = ..., return_header: bool = ...) -> Any: ...\r
 131     def loads_unsafe(self, s, salt: Optional[bytes_like] = ..., return_header: bool = ...) -> Tuple[bool, Any]: ...\r
 132 \r
 133 class TimedJSONWebSignatureSerializer(JSONWebSignatureSerializer):\r
 134     DEFAULT_EXPIRES_IN = ...  # type: int\r
 135     expires_in = ...  # type: int\r
 136     def __init__(self, secret_key: bytes_like, expires_in: Optional[int] = ..., **kwargs) -> None: ...\r
 137     def make_header(self, header_fields=Optional[MutableMapping]) -> MutableMapping: ...\r
 138     def loads(self, s: str, salt: Optional[bytes_like] = ..., return_header: bool = ...) -> Any: ...\r
 139     def get_issue_date(self, header: MutableMapping) -> Optional[datetime]: ...\r
 140     def now(self) -> int: ...\r
 141 \r
 142 class URLSafeSerializerMixin:\r
 143     def load_payload(self, payload: Any, serializer=None, return_header=False, **kwargs) -> Any: ...  # FIXME: This is invalid but works around https://github.com/pallets/itsdangerous/issues/74\r
 144     def dump_payload(self, *args, **kwargs) -> str: ...\r
 145 \r
 146 class URLSafeSerializer(URLSafeSerializerMixin, Serializer):\r
 147     default_serializer = ...  # type: Any\r
 148 \r
 149 class URLSafeTimedSerializer(URLSafeSerializerMixin, TimedSerializer):\r
 150     default_serializer = ...  # type: Any\r