Download MINI-ARC/flask/lib/python3.10/site-packages/werkzeug/datastructures.pyi from Alignment-Lab-AI/ARC-stuff: direct link, hf CLI and curl.
- Browser
- Download file 34.5 kB
-
https://huggingface.co/datasets/Alignment-Lab-AI/ARC-stuff/resolve/main/MINI-ARC/flask/lib/python3.10/site-packages/werkzeug/datastructures.pyi
- Command line
-
hf download hf://datasets/Alignment-Lab-AI/ARC-stuff/MINI-ARC/flask/lib/python3.10/site-packages/werkzeug/datastructures.pyi
-
curl -L -o datastructures.pyi https://huggingface.co/datasets/Alignment-Lab-AI/ARC-stuff/resolve/main/MINI-ARC/flask/lib/python3.10/site-packages/werkzeug/datastructures.pyi
34.5 kB
| from datetime import datetime | |
| from os import PathLike | |
| from typing import Any | |
| from typing import Callable | |
| from typing import Collection | |
| from typing import Dict | |
| from typing import FrozenSet | |
| from typing import Generic | |
| from typing import Hashable | |
| from typing import IO | |
| from typing import Iterable | |
| from typing import Iterator | |
| from typing import List | |
| from typing import Mapping | |
| from typing import NoReturn | |
| from typing import Optional | |
| from typing import overload | |
| from typing import Set | |
| from typing import Tuple | |
| from typing import Type | |
| from typing import TypeVar | |
| from typing import Union | |
| from _typeshed import SupportsKeysAndGetItem | |
| from _typeshed.wsgi import WSGIEnvironment | |
| from typing_extensions import Literal | |
| from typing_extensions import SupportsIndex | |
| K = TypeVar("K") | |
| V = TypeVar("V") | |
| T = TypeVar("T") | |
| D = TypeVar("D") | |
| _CD = TypeVar("_CD", bound="CallbackDict") | |
| def is_immutable(self: object) -> NoReturn: ... | |
| def iter_multi_items( | |
| mapping: Union[Mapping[K, Union[V, Iterable[V]]], Iterable[Tuple[K, V]]] | |
| ) -> Iterator[Tuple[K, V]]: ... | |
| class ImmutableListMixin(List[V]): | |
| _hash_cache: Optional[int] | |
| def __hash__(self) -> int: ... # type: ignore | |
| def __delitem__(self, key: Union[SupportsIndex, slice]) -> NoReturn: ... | |
| def __iadd__(self, other: t.Any) -> NoReturn: ... # type: ignore | |
| def __imul__(self, other: SupportsIndex) -> NoReturn: ... | |
| def __setitem__( # type: ignore | |
| self, key: Union[int, slice], value: V | |
| ) -> NoReturn: ... | |
| def append(self, value: V) -> NoReturn: ... | |
| def remove(self, value: V) -> NoReturn: ... | |
| def extend(self, values: Iterable[V]) -> NoReturn: ... | |
| def insert(self, pos: SupportsIndex, value: V) -> NoReturn: ... | |
| def pop(self, index: SupportsIndex = -1) -> NoReturn: ... | |
| def reverse(self) -> NoReturn: ... | |
| def sort( | |
| self, key: Optional[Callable[[V], Any]] = None, reverse: bool = False | |
| ) -> NoReturn: ... | |
| class ImmutableList(ImmutableListMixin[V]): ... | |
| class ImmutableDictMixin(Dict[K, V]): | |
| _hash_cache: Optional[int] | |
| def fromkeys( # type: ignore | |
| cls, keys: Iterable[K], value: Optional[V] = None | |
| ) -> ImmutableDictMixin[K, V]: ... | |
| def _iter_hashitems(self) -> Iterable[Hashable]: ... | |
| def __hash__(self) -> int: ... # type: ignore | |
| def setdefault(self, key: K, default: Optional[V] = None) -> NoReturn: ... | |
| def update(self, *args: Any, **kwargs: V) -> NoReturn: ... | |
| def pop(self, key: K, default: Optional[V] = None) -> NoReturn: ... # type: ignore | |
| def popitem(self) -> NoReturn: ... | |
| def __setitem__(self, key: K, value: V) -> NoReturn: ... | |
| def __delitem__(self, key: K) -> NoReturn: ... | |
| def clear(self) -> NoReturn: ... | |
| class ImmutableMultiDictMixin(ImmutableDictMixin[K, V]): | |
| def _iter_hashitems(self) -> Iterable[Hashable]: ... | |
| def add(self, key: K, value: V) -> NoReturn: ... | |
| def popitemlist(self) -> NoReturn: ... | |
| def poplist(self, key: K) -> NoReturn: ... | |
| def setlist(self, key: K, new_list: Iterable[V]) -> NoReturn: ... | |
| def setlistdefault( | |
| self, key: K, default_list: Optional[Iterable[V]] = None | |
| ) -> NoReturn: ... | |
| def _calls_update(name: str) -> Callable[[UpdateDictMixin[K, V]], Any]: ... | |
| class UpdateDictMixin(Dict[K, V]): | |
| on_update: Optional[Callable[[UpdateDictMixin[K, V]], None]] | |
| def setdefault(self, key: K, default: Optional[V] = None) -> V: ... | |
| def pop(self, key: K) -> V: ... | |
| def pop(self, key: K, default: Union[V, T] = ...) -> Union[V, T]: ... | |
| def __setitem__(self, key: K, value: V) -> None: ... | |
| def __delitem__(self, key: K) -> None: ... | |
| def clear(self) -> None: ... | |
| def popitem(self) -> Tuple[K, V]: ... | |
| def update(self, __m: SupportsKeysAndGetItem[K, V], **kwargs: V) -> None: ... | |
| def update(self, __m: Iterable[Tuple[K, V]], **kwargs: V) -> None: ... | |
| def update(self, **kwargs: V) -> None: ... | |
| class TypeConversionDict(Dict[K, V]): | |
| def get(self, key: K, default: None = ..., type: None = ...) -> Optional[V]: ... | |
| def get(self, key: K, default: D, type: None = ...) -> Union[D, V]: ... | |
| def get(self, key: K, default: D, type: Callable[[V], T]) -> Union[D, T]: ... | |
| def get(self, key: K, type: Callable[[V], T]) -> Optional[T]: ... | |
| class ImmutableTypeConversionDict(ImmutableDictMixin[K, V], TypeConversionDict[K, V]): | |
| def copy(self) -> TypeConversionDict[K, V]: ... | |
| def __copy__(self) -> ImmutableTypeConversionDict: ... | |
| class MultiDict(TypeConversionDict[K, V]): | |
| def __init__( | |
| self, | |
| mapping: Optional[ | |
| Union[Mapping[K, Union[Iterable[V], V]], Iterable[Tuple[K, V]]] | |
| ] = None, | |
| ) -> None: ... | |
| def __getitem__(self, item: K) -> V: ... | |
| def __setitem__(self, key: K, value: V) -> None: ... | |
| def add(self, key: K, value: V) -> None: ... | |
| def getlist(self, key: K) -> List[V]: ... | |
| def getlist(self, key: K, type: Callable[[V], T] = ...) -> List[T]: ... | |
| def setlist(self, key: K, new_list: Iterable[V]) -> None: ... | |
| def setdefault(self, key: K, default: Optional[V] = None) -> V: ... | |
| def setlistdefault( | |
| self, key: K, default_list: Optional[Iterable[V]] = None | |
| ) -> List[V]: ... | |
| def items(self, multi: bool = False) -> Iterator[Tuple[K, V]]: ... # type: ignore | |
| def lists(self) -> Iterator[Tuple[K, List[V]]]: ... | |
| def values(self) -> Iterator[V]: ... # type: ignore | |
| def listvalues(self) -> Iterator[List[V]]: ... | |
| def copy(self) -> MultiDict[K, V]: ... | |
| def deepcopy(self, memo: Any = None) -> MultiDict[K, V]: ... | |
| def to_dict(self) -> Dict[K, V]: ... | |
| def to_dict(self, flat: Literal[False]) -> Dict[K, List[V]]: ... | |
| def update( # type: ignore | |
| self, mapping: Union[Mapping[K, Union[Iterable[V], V]], Iterable[Tuple[K, V]]] | |
| ) -> None: ... | |
| def pop(self, key: K) -> V: ... | |
| def pop(self, key: K, default: Union[V, T] = ...) -> Union[V, T]: ... | |
| def popitem(self) -> Tuple[K, V]: ... | |
| def poplist(self, key: K) -> List[V]: ... | |
| def popitemlist(self) -> Tuple[K, List[V]]: ... | |
| def __copy__(self) -> MultiDict[K, V]: ... | |
| def __deepcopy__(self, memo: Any) -> MultiDict[K, V]: ... | |
| class _omd_bucket(Generic[K, V]): | |
| prev: Optional[_omd_bucket] | |
| next: Optional[_omd_bucket] | |
| key: K | |
| value: V | |
| def __init__(self, omd: OrderedMultiDict, key: K, value: V) -> None: ... | |
| def unlink(self, omd: OrderedMultiDict) -> None: ... | |
| class OrderedMultiDict(MultiDict[K, V]): | |
| _first_bucket: Optional[_omd_bucket] | |
| _last_bucket: Optional[_omd_bucket] | |
| def __init__(self, mapping: Optional[Mapping[K, V]] = None) -> None: ... | |
| def __eq__(self, other: object) -> bool: ... | |
| def __getitem__(self, key: K) -> V: ... | |
| def __setitem__(self, key: K, value: V) -> None: ... | |
| def __delitem__(self, key: K) -> None: ... | |
| def keys(self) -> Iterator[K]: ... # type: ignore | |
| def __iter__(self) -> Iterator[K]: ... | |
| def values(self) -> Iterator[V]: ... # type: ignore | |
| def items(self, multi: bool = False) -> Iterator[Tuple[K, V]]: ... # type: ignore | |
| def lists(self) -> Iterator[Tuple[K, List[V]]]: ... | |
| def listvalues(self) -> Iterator[List[V]]: ... | |
| def add(self, key: K, value: V) -> None: ... | |
| def getlist(self, key: K) -> List[V]: ... | |
| def getlist(self, key: K, type: Callable[[V], T] = ...) -> List[T]: ... | |
| def setlist(self, key: K, new_list: Iterable[V]) -> None: ... | |
| def setlistdefault( | |
| self, key: K, default_list: Optional[Iterable[V]] = None | |
| ) -> List[V]: ... | |
| def update( # type: ignore | |
| self, mapping: Union[Mapping[K, V], Iterable[Tuple[K, V]]] | |
| ) -> None: ... | |
| def poplist(self, key: K) -> List[V]: ... | |
| def pop(self, key: K) -> V: ... | |
| def pop(self, key: K, default: Union[V, T] = ...) -> Union[V, T]: ... | |
| def popitem(self) -> Tuple[K, V]: ... | |
| def popitemlist(self) -> Tuple[K, List[V]]: ... | |
| def _options_header_vkw( | |
| value: str, kw: Mapping[str, Optional[Union[str, int]]] | |
| ) -> str: ... | |
| def _unicodify_header_value(value: Union[str, int]) -> str: ... | |
| HV = Union[str, int] | |
| class Headers(Dict[str, str]): | |
| _list: List[Tuple[str, str]] | |
| def __init__( | |
| self, | |
| defaults: Optional[ | |
| Union[Mapping[str, Union[HV, Iterable[HV]]], Iterable[Tuple[str, HV]]] | |
| ] = None, | |
| ) -> None: ... | |
| def __getitem__(self, key: str) -> str: ... | |
| def __getitem__(self, key: int) -> Tuple[str, str]: ... | |
| def __getitem__(self, key: slice) -> Headers: ... | |
| def __getitem__(self, key: str, _get_mode: Literal[True] = ...) -> str: ... | |
| def __eq__(self, other: object) -> bool: ... | |
| # type: ignore | |
| def get(self, key: str, default: str) -> str: ... | |
| def get(self, key: str, default: Optional[str] = None) -> Optional[str]: ... | |
| def get( | |
| self, key: str, default: Optional[T] = None, type: Callable[[str], T] = ... | |
| ) -> Optional[T]: ... | |
| def getlist(self, key: str) -> List[str]: ... | |
| def getlist(self, key: str, type: Callable[[str], T]) -> List[T]: ... | |
| def get_all(self, name: str) -> List[str]: ... | |
| def items( # type: ignore | |
| self, lower: bool = False | |
| ) -> Iterator[Tuple[str, str]]: ... | |
| def keys(self, lower: bool = False) -> Iterator[str]: ... # type: ignore | |
| def values(self) -> Iterator[str]: ... # type: ignore | |
| def extend( | |
| self, | |
| *args: Union[Mapping[str, Union[HV, Iterable[HV]]], Iterable[Tuple[str, HV]]], | |
| **kwargs: Union[HV, Iterable[HV]], | |
| ) -> None: ... | |
| def __delitem__(self, key: Union[str, int, slice]) -> None: ... | |
| def __delitem__(self, key: str, _index_operation: Literal[False]) -> None: ... | |
| def remove(self, key: str) -> None: ... | |
| # type: ignore | |
| def pop(self, key: str, default: Optional[str] = None) -> str: ... | |
| def pop( | |
| self, key: Optional[int] = None, default: Optional[Tuple[str, str]] = None | |
| ) -> Tuple[str, str]: ... | |
| def popitem(self) -> Tuple[str, str]: ... | |
| def __contains__(self, key: str) -> bool: ... # type: ignore | |
| def has_key(self, key: str) -> bool: ... | |
| def __iter__(self) -> Iterator[Tuple[str, str]]: ... # type: ignore | |
| def add(self, _key: str, _value: HV, **kw: HV) -> None: ... | |
| def _validate_value(self, value: str) -> None: ... | |
| def add_header(self, _key: str, _value: HV, **_kw: HV) -> None: ... | |
| def clear(self) -> None: ... | |
| def set(self, _key: str, _value: HV, **kw: HV) -> None: ... | |
| def setlist(self, key: str, values: Iterable[HV]) -> None: ... | |
| def setdefault(self, key: str, default: HV) -> str: ... # type: ignore | |
| def setlistdefault(self, key: str, default: Iterable[HV]) -> None: ... | |
| def __setitem__(self, key: str, value: HV) -> None: ... | |
| def __setitem__(self, key: int, value: Tuple[str, HV]) -> None: ... | |
| def __setitem__(self, key: slice, value: Iterable[Tuple[str, HV]]) -> None: ... | |
| def update( | |
| self, __m: SupportsKeysAndGetItem[str, HV], **kwargs: Union[HV, Iterable[HV]] | |
| ) -> None: ... | |
| def update( | |
| self, __m: Iterable[Tuple[str, HV]], **kwargs: Union[HV, Iterable[HV]] | |
| ) -> None: ... | |
| def update(self, **kwargs: Union[HV, Iterable[HV]]) -> None: ... | |
| def to_wsgi_list(self) -> List[Tuple[str, str]]: ... | |
| def copy(self) -> Headers: ... | |
| def __copy__(self) -> Headers: ... | |
| class ImmutableHeadersMixin(Headers): | |
| def __delitem__(self, key: Any, _index_operation: bool = True) -> NoReturn: ... | |
| def __setitem__(self, key: Any, value: Any) -> NoReturn: ... | |
| def set(self, _key: Any, _value: Any, **kw: Any) -> NoReturn: ... | |
| def setlist(self, key: Any, values: Any) -> NoReturn: ... | |
| def add(self, _key: Any, _value: Any, **kw: Any) -> NoReturn: ... | |
| def add_header(self, _key: Any, _value: Any, **_kw: Any) -> NoReturn: ... | |
| def remove(self, key: Any) -> NoReturn: ... | |
| def extend(self, *args: Any, **kwargs: Any) -> NoReturn: ... | |
| def update(self, *args: Any, **kwargs: Any) -> NoReturn: ... | |
| def insert(self, pos: Any, value: Any) -> NoReturn: ... | |
| def pop(self, key: Any = None, default: Any = ...) -> NoReturn: ... | |
| def popitem(self) -> NoReturn: ... | |
| def setdefault(self, key: Any, default: Any) -> NoReturn: ... # type: ignore | |
| def setlistdefault(self, key: Any, default: Any) -> NoReturn: ... | |
| class EnvironHeaders(ImmutableHeadersMixin, Headers): | |
| environ: WSGIEnvironment | |
| def __init__(self, environ: WSGIEnvironment) -> None: ... | |
| def __eq__(self, other: object) -> bool: ... | |
| def __getitem__( # type: ignore | |
| self, key: str, _get_mode: Literal[False] = False | |
| ) -> str: ... | |
| def __iter__(self) -> Iterator[Tuple[str, str]]: ... # type: ignore | |
| def copy(self) -> NoReturn: ... | |
| class CombinedMultiDict(ImmutableMultiDictMixin[K, V], MultiDict[K, V]): # type: ignore | |
| dicts: List[MultiDict[K, V]] | |
| def __init__(self, dicts: Optional[Iterable[MultiDict[K, V]]]) -> None: ... | |
| def fromkeys(cls, keys: Any, value: Any = None) -> NoReturn: ... | |
| def __getitem__(self, key: K) -> V: ... | |
| # type: ignore | |
| def get(self, key: K) -> Optional[V]: ... | |
| def get(self, key: K, default: Union[V, T] = ...) -> Union[V, T]: ... | |
| def get( | |
| self, key: K, default: Optional[T] = None, type: Callable[[V], T] = ... | |
| ) -> Optional[T]: ... | |
| def getlist(self, key: K) -> List[V]: ... | |
| def getlist(self, key: K, type: Callable[[V], T] = ...) -> List[T]: ... | |
| def _keys_impl(self) -> Set[K]: ... | |
| def keys(self) -> Set[K]: ... # type: ignore | |
| def __iter__(self) -> Set[K]: ... # type: ignore | |
| def items(self, multi: bool = False) -> Iterator[Tuple[K, V]]: ... # type: ignore | |
| def values(self) -> Iterator[V]: ... # type: ignore | |
| def lists(self) -> Iterator[Tuple[K, List[V]]]: ... | |
| def listvalues(self) -> Iterator[List[V]]: ... | |
| def copy(self) -> MultiDict[K, V]: ... | |
| def to_dict(self) -> Dict[K, V]: ... | |
| def to_dict(self, flat: Literal[False]) -> Dict[K, List[V]]: ... | |
| def __contains__(self, key: K) -> bool: ... # type: ignore | |
| def has_key(self, key: K) -> bool: ... | |
| class FileMultiDict(MultiDict[str, "FileStorage"]): | |
| def add_file( | |
| self, | |
| name: str, | |
| file: Union[FileStorage, str, IO[bytes]], | |
| filename: Optional[str] = None, | |
| content_type: Optional[str] = None, | |
| ) -> None: ... | |
| class ImmutableDict(ImmutableDictMixin[K, V], Dict[K, V]): | |
| def copy(self) -> Dict[K, V]: ... | |
| def __copy__(self) -> ImmutableDict[K, V]: ... | |
| class ImmutableMultiDict( # type: ignore | |
| ImmutableMultiDictMixin[K, V], MultiDict[K, V] | |
| ): | |
| def copy(self) -> MultiDict[K, V]: ... | |
| def __copy__(self) -> ImmutableMultiDict[K, V]: ... | |
| class ImmutableOrderedMultiDict( # type: ignore | |
| ImmutableMultiDictMixin[K, V], OrderedMultiDict[K, V] | |
| ): | |
| def _iter_hashitems(self) -> Iterator[Tuple[int, Tuple[K, V]]]: ... | |
| def copy(self) -> OrderedMultiDict[K, V]: ... | |
| def __copy__(self) -> ImmutableOrderedMultiDict[K, V]: ... | |
| class Accept(ImmutableList[Tuple[str, int]]): | |
| provided: bool | |
| def __init__( | |
| self, values: Optional[Union[Accept, Iterable[Tuple[str, float]]]] = None | |
| ) -> None: ... | |
| def _specificity(self, value: str) -> Tuple[bool, ...]: ... | |
| def _value_matches(self, value: str, item: str) -> bool: ... | |
| # type: ignore | |
| def __getitem__(self, key: str) -> int: ... | |
| def __getitem__(self, key: int) -> Tuple[str, int]: ... | |
| def __getitem__(self, key: slice) -> Iterable[Tuple[str, int]]: ... | |
| def quality(self, key: str) -> int: ... | |
| def __contains__(self, value: str) -> bool: ... # type: ignore | |
| def index(self, key: str) -> int: ... # type: ignore | |
| def find(self, key: str) -> int: ... | |
| def values(self) -> Iterator[str]: ... | |
| def to_header(self) -> str: ... | |
| def _best_single_match(self, match: str) -> Optional[Tuple[str, int]]: ... | |
| def best_match( | |
| self, matches: Iterable[str], default: Optional[str] = None | |
| ) -> Optional[str]: ... | |
| def best(self) -> str: ... | |
| def _normalize_mime(value: str) -> List[str]: ... | |
| class MIMEAccept(Accept): | |
| def _specificity(self, value: str) -> Tuple[bool, ...]: ... | |
| def _value_matches(self, value: str, item: str) -> bool: ... | |
| def accept_html(self) -> bool: ... | |
| def accept_xhtml(self) -> bool: ... | |
| def accept_json(self) -> bool: ... | |
| def _normalize_lang(value: str) -> List[str]: ... | |
| class LanguageAccept(Accept): | |
| def _value_matches(self, value: str, item: str) -> bool: ... | |
| def best_match( | |
| self, matches: Iterable[str], default: Optional[str] = None | |
| ) -> Optional[str]: ... | |
| class CharsetAccept(Accept): | |
| def _value_matches(self, value: str, item: str) -> bool: ... | |
| _CPT = TypeVar("_CPT", str, int, bool) | |
| _OptCPT = Optional[_CPT] | |
| def cache_control_property(key: str, empty: _OptCPT, type: Type[_CPT]) -> property: ... | |
| class _CacheControl(UpdateDictMixin[str, _OptCPT], Dict[str, _OptCPT]): | |
| provided: bool | |
| def __init__( | |
| self, | |
| values: Union[Mapping[str, _OptCPT], Iterable[Tuple[str, _OptCPT]]] = (), | |
| on_update: Optional[Callable[[_CacheControl], None]] = None, | |
| ) -> None: ... | |
| def no_cache(self) -> Optional[bool]: ... | |
| def no_cache(self, value: Optional[bool]) -> None: ... | |
| def no_cache(self) -> None: ... | |
| def no_store(self) -> Optional[bool]: ... | |
| def no_store(self, value: Optional[bool]) -> None: ... | |
| def no_store(self) -> None: ... | |
| def max_age(self) -> Optional[int]: ... | |
| def max_age(self, value: Optional[int]) -> None: ... | |
| def max_age(self) -> None: ... | |
| def no_transform(self) -> Optional[bool]: ... | |
| def no_transform(self, value: Optional[bool]) -> None: ... | |
| def no_transform(self) -> None: ... | |
| def _get_cache_value(self, key: str, empty: Optional[T], type: Type[T]) -> T: ... | |
| def _set_cache_value(self, key: str, value: Optional[T], type: Type[T]) -> None: ... | |
| def _del_cache_value(self, key: str) -> None: ... | |
| def to_header(self) -> str: ... | |
| def cache_property(key: str, empty: _OptCPT, type: Type[_CPT]) -> property: ... | |
| class RequestCacheControl(ImmutableDictMixin[str, _OptCPT], _CacheControl): | |
| def max_stale(self) -> Optional[int]: ... | |
| def max_stale(self, value: Optional[int]) -> None: ... | |
| def max_stale(self) -> None: ... | |
| def min_fresh(self) -> Optional[int]: ... | |
| def min_fresh(self, value: Optional[int]) -> None: ... | |
| def min_fresh(self) -> None: ... | |
| def only_if_cached(self) -> Optional[bool]: ... | |
| def only_if_cached(self, value: Optional[bool]) -> None: ... | |
| def only_if_cached(self) -> None: ... | |
| class ResponseCacheControl(_CacheControl): | |
| def public(self) -> Optional[bool]: ... | |
| def public(self, value: Optional[bool]) -> None: ... | |
| def public(self) -> None: ... | |
| def private(self) -> Optional[bool]: ... | |
| def private(self, value: Optional[bool]) -> None: ... | |
| def private(self) -> None: ... | |
| def must_revalidate(self) -> Optional[bool]: ... | |
| def must_revalidate(self, value: Optional[bool]) -> None: ... | |
| def must_revalidate(self) -> None: ... | |
| def proxy_revalidate(self) -> Optional[bool]: ... | |
| def proxy_revalidate(self, value: Optional[bool]) -> None: ... | |
| def proxy_revalidate(self) -> None: ... | |
| def s_maxage(self) -> Optional[int]: ... | |
| def s_maxage(self, value: Optional[int]) -> None: ... | |
| def s_maxage(self) -> None: ... | |
| def immutable(self) -> Optional[bool]: ... | |
| def immutable(self, value: Optional[bool]) -> None: ... | |
| def immutable(self) -> None: ... | |
| def csp_property(key: str) -> property: ... | |
| class ContentSecurityPolicy(UpdateDictMixin[str, str], Dict[str, str]): | |
| def base_uri(self) -> Optional[str]: ... | |
| def base_uri(self, value: Optional[str]) -> None: ... | |
| def base_uri(self) -> None: ... | |
| def child_src(self) -> Optional[str]: ... | |
| def child_src(self, value: Optional[str]) -> None: ... | |
| def child_src(self) -> None: ... | |
| def connect_src(self) -> Optional[str]: ... | |
| def connect_src(self, value: Optional[str]) -> None: ... | |
| def connect_src(self) -> None: ... | |
| def default_src(self) -> Optional[str]: ... | |
| def default_src(self, value: Optional[str]) -> None: ... | |
| def default_src(self) -> None: ... | |
| def font_src(self) -> Optional[str]: ... | |
| def font_src(self, value: Optional[str]) -> None: ... | |
| def font_src(self) -> None: ... | |
| def form_action(self) -> Optional[str]: ... | |
| def form_action(self, value: Optional[str]) -> None: ... | |
| def form_action(self) -> None: ... | |
| def frame_ancestors(self) -> Optional[str]: ... | |
| def frame_ancestors(self, value: Optional[str]) -> None: ... | |
| def frame_ancestors(self) -> None: ... | |
| def frame_src(self) -> Optional[str]: ... | |
| def frame_src(self, value: Optional[str]) -> None: ... | |
| def frame_src(self) -> None: ... | |
| def img_src(self) -> Optional[str]: ... | |
| def img_src(self, value: Optional[str]) -> None: ... | |
| def img_src(self) -> None: ... | |
| def manifest_src(self) -> Optional[str]: ... | |
| def manifest_src(self, value: Optional[str]) -> None: ... | |
| def manifest_src(self) -> None: ... | |
| def media_src(self) -> Optional[str]: ... | |
| def media_src(self, value: Optional[str]) -> None: ... | |
| def media_src(self) -> None: ... | |
| def navigate_to(self) -> Optional[str]: ... | |
| def navigate_to(self, value: Optional[str]) -> None: ... | |
| def navigate_to(self) -> None: ... | |
| def object_src(self) -> Optional[str]: ... | |
| def object_src(self, value: Optional[str]) -> None: ... | |
| def object_src(self) -> None: ... | |
| def prefetch_src(self) -> Optional[str]: ... | |
| def prefetch_src(self, value: Optional[str]) -> None: ... | |
| def prefetch_src(self) -> None: ... | |
| def plugin_types(self) -> Optional[str]: ... | |
| def plugin_types(self, value: Optional[str]) -> None: ... | |
| def plugin_types(self) -> None: ... | |
| def report_to(self) -> Optional[str]: ... | |
| def report_to(self, value: Optional[str]) -> None: ... | |
| def report_to(self) -> None: ... | |
| def report_uri(self) -> Optional[str]: ... | |
| def report_uri(self, value: Optional[str]) -> None: ... | |
| def report_uri(self) -> None: ... | |
| def sandbox(self) -> Optional[str]: ... | |
| def sandbox(self, value: Optional[str]) -> None: ... | |
| def sandbox(self) -> None: ... | |
| def script_src(self) -> Optional[str]: ... | |
| def script_src(self, value: Optional[str]) -> None: ... | |
| def script_src(self) -> None: ... | |
| def script_src_attr(self) -> Optional[str]: ... | |
| def script_src_attr(self, value: Optional[str]) -> None: ... | |
| def script_src_attr(self) -> None: ... | |
| def script_src_elem(self) -> Optional[str]: ... | |
| def script_src_elem(self, value: Optional[str]) -> None: ... | |
| def script_src_elem(self) -> None: ... | |
| def style_src(self) -> Optional[str]: ... | |
| def style_src(self, value: Optional[str]) -> None: ... | |
| def style_src(self) -> None: ... | |
| def style_src_attr(self) -> Optional[str]: ... | |
| def style_src_attr(self, value: Optional[str]) -> None: ... | |
| def style_src_attr(self) -> None: ... | |
| def style_src_elem(self) -> Optional[str]: ... | |
| def style_src_elem(self, value: Optional[str]) -> None: ... | |
| def style_src_elem(self) -> None: ... | |
| def worker_src(self) -> Optional[str]: ... | |
| def worker_src(self, value: Optional[str]) -> None: ... | |
| def worker_src(self) -> None: ... | |
| provided: bool | |
| def __init__( | |
| self, | |
| values: Union[Mapping[str, str], Iterable[Tuple[str, str]]] = (), | |
| on_update: Optional[Callable[[ContentSecurityPolicy], None]] = None, | |
| ) -> None: ... | |
| def _get_value(self, key: str) -> Optional[str]: ... | |
| def _set_value(self, key: str, value: str) -> None: ... | |
| def _del_value(self, key: str) -> None: ... | |
| def to_header(self) -> str: ... | |
| class CallbackDict(UpdateDictMixin[K, V], Dict[K, V]): | |
| def __init__( | |
| self, | |
| initial: Optional[Union[Mapping[K, V], Iterable[Tuple[K, V]]]] = None, | |
| on_update: Optional[Callable[[_CD], None]] = None, | |
| ) -> None: ... | |
| class HeaderSet(Set[str]): | |
| _headers: List[str] | |
| _set: Set[str] | |
| on_update: Optional[Callable[[HeaderSet], None]] | |
| def __init__( | |
| self, | |
| headers: Optional[Iterable[str]] = None, | |
| on_update: Optional[Callable[[HeaderSet], None]] = None, | |
| ) -> None: ... | |
| def add(self, header: str) -> None: ... | |
| def remove(self, header: str) -> None: ... | |
| def update(self, iterable: Iterable[str]) -> None: ... # type: ignore | |
| def discard(self, header: str) -> None: ... | |
| def find(self, header: str) -> int: ... | |
| def index(self, header: str) -> int: ... | |
| def clear(self) -> None: ... | |
| def as_set(self, preserve_casing: bool = False) -> Set[str]: ... | |
| def to_header(self) -> str: ... | |
| def __getitem__(self, idx: int) -> str: ... | |
| def __delitem__(self, idx: int) -> None: ... | |
| def __setitem__(self, idx: int, value: str) -> None: ... | |
| def __contains__(self, header: str) -> bool: ... # type: ignore | |
| def __len__(self) -> int: ... | |
| def __iter__(self) -> Iterator[str]: ... | |
| class ETags(Collection[str]): | |
| _strong: FrozenSet[str] | |
| _weak: FrozenSet[str] | |
| star_tag: bool | |
| def __init__( | |
| self, | |
| strong_etags: Optional[Iterable[str]] = None, | |
| weak_etags: Optional[Iterable[str]] = None, | |
| star_tag: bool = False, | |
| ) -> None: ... | |
| def as_set(self, include_weak: bool = False) -> Set[str]: ... | |
| def is_weak(self, etag: str) -> bool: ... | |
| def is_strong(self, etag: str) -> bool: ... | |
| def contains_weak(self, etag: str) -> bool: ... | |
| def contains(self, etag: str) -> bool: ... | |
| def contains_raw(self, etag: str) -> bool: ... | |
| def to_header(self) -> str: ... | |
| def __call__( | |
| self, | |
| etag: Optional[str] = None, | |
| data: Optional[bytes] = None, | |
| include_weak: bool = False, | |
| ) -> bool: ... | |
| def __len__(self) -> int: ... | |
| def __iter__(self) -> Iterator[str]: ... | |
| def __contains__(self, item: str) -> bool: ... # type: ignore | |
| class IfRange: | |
| etag: Optional[str] | |
| date: Optional[datetime] | |
| def __init__( | |
| self, etag: Optional[str] = None, date: Optional[datetime] = None | |
| ) -> None: ... | |
| def to_header(self) -> str: ... | |
| class Range: | |
| units: str | |
| ranges: List[Tuple[int, Optional[int]]] | |
| def __init__(self, units: str, ranges: List[Tuple[int, Optional[int]]]) -> None: ... | |
| def range_for_length(self, length: Optional[int]) -> Optional[Tuple[int, int]]: ... | |
| def make_content_range(self, length: Optional[int]) -> Optional[ContentRange]: ... | |
| def to_header(self) -> str: ... | |
| def to_content_range_header(self, length: Optional[int]) -> Optional[str]: ... | |
| def _callback_property(name: str) -> property: ... | |
| class ContentRange: | |
| on_update: Optional[Callable[[ContentRange], None]] | |
| def __init__( | |
| self, | |
| units: Optional[str], | |
| start: Optional[int], | |
| stop: Optional[int], | |
| length: Optional[int] = None, | |
| on_update: Optional[Callable[[ContentRange], None]] = None, | |
| ) -> None: ... | |
| def units(self) -> Optional[str]: ... | |
| def units(self, value: Optional[str]) -> None: ... | |
| def start(self) -> Optional[int]: ... | |
| def start(self, value: Optional[int]) -> None: ... | |
| def stop(self) -> Optional[int]: ... | |
| def stop(self, value: Optional[int]) -> None: ... | |
| def length(self) -> Optional[int]: ... | |
| def length(self, value: Optional[int]) -> None: ... | |
| def set( | |
| self, | |
| start: Optional[int], | |
| stop: Optional[int], | |
| length: Optional[int] = None, | |
| units: Optional[str] = "bytes", | |
| ) -> None: ... | |
| def unset(self) -> None: ... | |
| def to_header(self) -> str: ... | |
| class Authorization(ImmutableDictMixin[str, str], Dict[str, str]): | |
| type: str | |
| def __init__( | |
| self, | |
| auth_type: str, | |
| data: Optional[Union[Mapping[str, str], Iterable[Tuple[str, str]]]] = None, | |
| ) -> None: ... | |
| def username(self) -> Optional[str]: ... | |
| def password(self) -> Optional[str]: ... | |
| def realm(self) -> Optional[str]: ... | |
| def nonce(self) -> Optional[str]: ... | |
| def uri(self) -> Optional[str]: ... | |
| def nc(self) -> Optional[str]: ... | |
| def cnonce(self) -> Optional[str]: ... | |
| def response(self) -> Optional[str]: ... | |
| def opaque(self) -> Optional[str]: ... | |
| def qop(self) -> Optional[str]: ... | |
| def to_header(self) -> str: ... | |
| def auth_property(name: str, doc: Optional[str] = None) -> property: ... | |
| def _set_property(name: str, doc: Optional[str] = None) -> property: ... | |
| class WWWAuthenticate(UpdateDictMixin[str, str], Dict[str, str]): | |
| _require_quoting: FrozenSet[str] | |
| def __init__( | |
| self, | |
| auth_type: Optional[str] = None, | |
| values: Optional[Union[Mapping[str, str], Iterable[Tuple[str, str]]]] = None, | |
| on_update: Optional[Callable[[WWWAuthenticate], None]] = None, | |
| ) -> None: ... | |
| def set_basic(self, realm: str = ...) -> None: ... | |
| def set_digest( | |
| self, | |
| realm: str, | |
| nonce: str, | |
| qop: Iterable[str] = ("auth",), | |
| opaque: Optional[str] = None, | |
| algorithm: Optional[str] = None, | |
| stale: bool = False, | |
| ) -> None: ... | |
| def to_header(self) -> str: ... | |
| def type(self) -> Optional[str]: ... | |
| def type(self, value: Optional[str]) -> None: ... | |
| def realm(self) -> Optional[str]: ... | |
| def realm(self, value: Optional[str]) -> None: ... | |
| def domain(self) -> HeaderSet: ... | |
| def nonce(self) -> Optional[str]: ... | |
| def nonce(self, value: Optional[str]) -> None: ... | |
| def opaque(self) -> Optional[str]: ... | |
| def opaque(self, value: Optional[str]) -> None: ... | |
| def algorithm(self) -> Optional[str]: ... | |
| def algorithm(self, value: Optional[str]) -> None: ... | |
| def qop(self) -> HeaderSet: ... | |
| def stale(self) -> Optional[bool]: ... | |
| def stale(self, value: Optional[bool]) -> None: ... | |
| def auth_property(name: str, doc: Optional[str] = None) -> property: ... | |
| class FileStorage: | |
| name: Optional[str] | |
| stream: IO[bytes] | |
| filename: Optional[str] | |
| headers: Headers | |
| _parsed_content_type: Tuple[str, Dict[str, str]] | |
| def __init__( | |
| self, | |
| stream: Optional[IO[bytes]] = None, | |
| filename: Union[str, PathLike, None] = None, | |
| name: Optional[str] = None, | |
| content_type: Optional[str] = None, | |
| content_length: Optional[int] = None, | |
| headers: Optional[Headers] = None, | |
| ) -> None: ... | |
| def _parse_content_type(self) -> None: ... | |
| def content_type(self) -> str: ... | |
| def content_length(self) -> int: ... | |
| def mimetype(self) -> str: ... | |
| def mimetype_params(self) -> Dict[str, str]: ... | |
| def save( | |
| self, dst: Union[str, PathLike, IO[bytes]], buffer_size: int = ... | |
| ) -> None: ... | |
| def close(self) -> None: ... | |
| def __bool__(self) -> bool: ... | |
| def __getattr__(self, name: str) -> Any: ... | |
| def __iter__(self) -> Iterator[bytes]: ... | |
| def __repr__(self) -> str: ... | |