Upload folder using huggingface_hub

d5bfab8 verified almost 2 years ago

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]
	@classmethod
	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: ...
	@overload
	def pop(self, key: K) -> V: ...
	@overload
	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]: ...
	@overload
	def update(self, __m: SupportsKeysAndGetItem[K, V], **kwargs: V) -> None: ...
	@overload
	def update(self, __m: Iterable[Tuple[K, V]], **kwargs: V) -> None: ...
	@overload
	def update(self, **kwargs: V) -> None: ...

	class TypeConversionDict(Dict[K, V]):
	@overload
	def get(self, key: K, default: None = ..., type: None = ...) -> Optional[V]: ...
	@overload
	def get(self, key: K, default: D, type: None = ...) -> Union[D, V]: ...
	@overload
	def get(self, key: K, default: D, type: Callable[[V], T]) -> Union[D, T]: ...
	@overload
	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: ...
	@overload
	def getlist(self, key: K) -> List[V]: ...
	@overload
	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]: ...
	@overload
	def to_dict(self) -> Dict[K, V]: ...
	@overload
	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: ...
	@overload
	def pop(self, key: K) -> V: ...
	@overload
	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: ...
	@overload
	def getlist(self, key: K) -> List[V]: ...
	@overload
	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]: ...
	@overload
	def pop(self, key: K) -> V: ...
	@overload
	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: ...
	@overload
	def __getitem__(self, key: str) -> str: ...
	@overload
	def __getitem__(self, key: int) -> Tuple[str, str]: ...
	@overload
	def __getitem__(self, key: slice) -> Headers: ...
	@overload
	def __getitem__(self, key: str, _get_mode: Literal[True] = ...) -> str: ...
	def __eq__(self, other: object) -> bool: ...
	@overload # type: ignore
	def get(self, key: str, default: str) -> str: ...
	@overload
	def get(self, key: str, default: Optional[str] = None) -> Optional[str]: ...
	@overload
	def get(
	self, key: str, default: Optional[T] = None, type: Callable[[str], T] = ...
	) -> Optional[T]: ...
	@overload
	def getlist(self, key: str) -> List[str]: ...
	@overload
	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: ...
	@overload
	def __delitem__(self, key: Union[str, int, slice]) -> None: ...
	@overload
	def __delitem__(self, key: str, _index_operation: Literal[False]) -> None: ...
	def remove(self, key: str) -> None: ...
	@overload # type: ignore
	def pop(self, key: str, default: Optional[str] = None) -> str: ...
	@overload
	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: ...
	@overload
	def __setitem__(self, key: str, value: HV) -> None: ...
	@overload
	def __setitem__(self, key: int, value: Tuple[str, HV]) -> None: ...
	@overload
	def __setitem__(self, key: slice, value: Iterable[Tuple[str, HV]]) -> None: ...
	@overload
	def update(
	self, __m: SupportsKeysAndGetItem[str, HV], **kwargs: Union[HV, Iterable[HV]]
	) -> None: ...
	@overload
	def update(
	self, __m: Iterable[Tuple[str, HV]], **kwargs: Union[HV, Iterable[HV]]
	) -> None: ...
	@overload
	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: ...
	@classmethod
	def fromkeys(cls, keys: Any, value: Any = None) -> NoReturn: ...
	def __getitem__(self, key: K) -> V: ...
	@overload # type: ignore
	def get(self, key: K) -> Optional[V]: ...
	@overload
	def get(self, key: K, default: Union[V, T] = ...) -> Union[V, T]: ...
	@overload
	def get(
	self, key: K, default: Optional[T] = None, type: Callable[[V], T] = ...
	) -> Optional[T]: ...
	@overload
	def getlist(self, key: K) -> List[V]: ...
	@overload
	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]: ...
	@overload
	def to_dict(self) -> Dict[K, V]: ...
	@overload
	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: ...
	@overload # type: ignore
	def __getitem__(self, key: str) -> int: ...
	@overload
	def __getitem__(self, key: int) -> Tuple[str, int]: ...
	@overload
	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]: ...
	@property
	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: ...
	@property
	def accept_html(self) -> bool: ...
	@property
	def accept_xhtml(self) -> bool: ...
	@property
	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: ...
	@property
	def no_cache(self) -> Optional[bool]: ...
	@no_cache.setter
	def no_cache(self, value: Optional[bool]) -> None: ...
	@no_cache.deleter
	def no_cache(self) -> None: ...
	@property
	def no_store(self) -> Optional[bool]: ...
	@no_store.setter
	def no_store(self, value: Optional[bool]) -> None: ...
	@no_store.deleter
	def no_store(self) -> None: ...
	@property
	def max_age(self) -> Optional[int]: ...
	@max_age.setter
	def max_age(self, value: Optional[int]) -> None: ...
	@max_age.deleter
	def max_age(self) -> None: ...
	@property
	def no_transform(self) -> Optional[bool]: ...
	@no_transform.setter
	def no_transform(self, value: Optional[bool]) -> None: ...
	@no_transform.deleter
	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: ...
	@staticmethod
	def cache_property(key: str, empty: _OptCPT, type: Type[_CPT]) -> property: ...

	class RequestCacheControl(ImmutableDictMixin[str, _OptCPT], _CacheControl):
	@property
	def max_stale(self) -> Optional[int]: ...
	@max_stale.setter
	def max_stale(self, value: Optional[int]) -> None: ...
	@max_stale.deleter
	def max_stale(self) -> None: ...
	@property
	def min_fresh(self) -> Optional[int]: ...
	@min_fresh.setter
	def min_fresh(self, value: Optional[int]) -> None: ...
	@min_fresh.deleter
	def min_fresh(self) -> None: ...
	@property
	def only_if_cached(self) -> Optional[bool]: ...
	@only_if_cached.setter
	def only_if_cached(self, value: Optional[bool]) -> None: ...
	@only_if_cached.deleter
	def only_if_cached(self) -> None: ...

	class ResponseCacheControl(_CacheControl):
	@property
	def public(self) -> Optional[bool]: ...
	@public.setter
	def public(self, value: Optional[bool]) -> None: ...
	@public.deleter
	def public(self) -> None: ...
	@property
	def private(self) -> Optional[bool]: ...
	@private.setter
	def private(self, value: Optional[bool]) -> None: ...
	@private.deleter
	def private(self) -> None: ...
	@property
	def must_revalidate(self) -> Optional[bool]: ...
	@must_revalidate.setter
	def must_revalidate(self, value: Optional[bool]) -> None: ...
	@must_revalidate.deleter
	def must_revalidate(self) -> None: ...
	@property
	def proxy_revalidate(self) -> Optional[bool]: ...
	@proxy_revalidate.setter
	def proxy_revalidate(self, value: Optional[bool]) -> None: ...
	@proxy_revalidate.deleter
	def proxy_revalidate(self) -> None: ...
	@property
	def s_maxage(self) -> Optional[int]: ...
	@s_maxage.setter
	def s_maxage(self, value: Optional[int]) -> None: ...
	@s_maxage.deleter
	def s_maxage(self) -> None: ...
	@property
	def immutable(self) -> Optional[bool]: ...
	@immutable.setter
	def immutable(self, value: Optional[bool]) -> None: ...
	@immutable.deleter
	def immutable(self) -> None: ...

	def csp_property(key: str) -> property: ...

	class ContentSecurityPolicy(UpdateDictMixin[str, str], Dict[str, str]):
	@property
	def base_uri(self) -> Optional[str]: ...
	@base_uri.setter
	def base_uri(self, value: Optional[str]) -> None: ...
	@base_uri.deleter
	def base_uri(self) -> None: ...
	@property
	def child_src(self) -> Optional[str]: ...
	@child_src.setter
	def child_src(self, value: Optional[str]) -> None: ...
	@child_src.deleter
	def child_src(self) -> None: ...
	@property
	def connect_src(self) -> Optional[str]: ...
	@connect_src.setter
	def connect_src(self, value: Optional[str]) -> None: ...
	@connect_src.deleter
	def connect_src(self) -> None: ...
	@property
	def default_src(self) -> Optional[str]: ...
	@default_src.setter
	def default_src(self, value: Optional[str]) -> None: ...
	@default_src.deleter
	def default_src(self) -> None: ...
	@property
	def font_src(self) -> Optional[str]: ...
	@font_src.setter
	def font_src(self, value: Optional[str]) -> None: ...
	@font_src.deleter
	def font_src(self) -> None: ...
	@property
	def form_action(self) -> Optional[str]: ...
	@form_action.setter
	def form_action(self, value: Optional[str]) -> None: ...
	@form_action.deleter
	def form_action(self) -> None: ...
	@property
	def frame_ancestors(self) -> Optional[str]: ...
	@frame_ancestors.setter
	def frame_ancestors(self, value: Optional[str]) -> None: ...
	@frame_ancestors.deleter
	def frame_ancestors(self) -> None: ...
	@property
	def frame_src(self) -> Optional[str]: ...
	@frame_src.setter
	def frame_src(self, value: Optional[str]) -> None: ...
	@frame_src.deleter
	def frame_src(self) -> None: ...
	@property
	def img_src(self) -> Optional[str]: ...
	@img_src.setter
	def img_src(self, value: Optional[str]) -> None: ...
	@img_src.deleter
	def img_src(self) -> None: ...
	@property
	def manifest_src(self) -> Optional[str]: ...
	@manifest_src.setter
	def manifest_src(self, value: Optional[str]) -> None: ...
	@manifest_src.deleter
	def manifest_src(self) -> None: ...
	@property
	def media_src(self) -> Optional[str]: ...
	@media_src.setter
	def media_src(self, value: Optional[str]) -> None: ...
	@media_src.deleter
	def media_src(self) -> None: ...
	@property
	def navigate_to(self) -> Optional[str]: ...
	@navigate_to.setter
	def navigate_to(self, value: Optional[str]) -> None: ...
	@navigate_to.deleter
	def navigate_to(self) -> None: ...
	@property
	def object_src(self) -> Optional[str]: ...
	@object_src.setter
	def object_src(self, value: Optional[str]) -> None: ...
	@object_src.deleter
	def object_src(self) -> None: ...
	@property
	def prefetch_src(self) -> Optional[str]: ...
	@prefetch_src.setter
	def prefetch_src(self, value: Optional[str]) -> None: ...
	@prefetch_src.deleter
	def prefetch_src(self) -> None: ...
	@property
	def plugin_types(self) -> Optional[str]: ...
	@plugin_types.setter
	def plugin_types(self, value: Optional[str]) -> None: ...
	@plugin_types.deleter
	def plugin_types(self) -> None: ...
	@property
	def report_to(self) -> Optional[str]: ...
	@report_to.setter
	def report_to(self, value: Optional[str]) -> None: ...
	@report_to.deleter
	def report_to(self) -> None: ...
	@property
	def report_uri(self) -> Optional[str]: ...
	@report_uri.setter
	def report_uri(self, value: Optional[str]) -> None: ...
	@report_uri.deleter
	def report_uri(self) -> None: ...
	@property
	def sandbox(self) -> Optional[str]: ...
	@sandbox.setter
	def sandbox(self, value: Optional[str]) -> None: ...
	@sandbox.deleter
	def sandbox(self) -> None: ...
	@property
	def script_src(self) -> Optional[str]: ...
	@script_src.setter
	def script_src(self, value: Optional[str]) -> None: ...
	@script_src.deleter
	def script_src(self) -> None: ...
	@property
	def script_src_attr(self) -> Optional[str]: ...
	@script_src_attr.setter
	def script_src_attr(self, value: Optional[str]) -> None: ...
	@script_src_attr.deleter
	def script_src_attr(self) -> None: ...
	@property
	def script_src_elem(self) -> Optional[str]: ...
	@script_src_elem.setter
	def script_src_elem(self, value: Optional[str]) -> None: ...
	@script_src_elem.deleter
	def script_src_elem(self) -> None: ...
	@property
	def style_src(self) -> Optional[str]: ...
	@style_src.setter
	def style_src(self, value: Optional[str]) -> None: ...
	@style_src.deleter
	def style_src(self) -> None: ...
	@property
	def style_src_attr(self) -> Optional[str]: ...
	@style_src_attr.setter
	def style_src_attr(self, value: Optional[str]) -> None: ...
	@style_src_attr.deleter
	def style_src_attr(self) -> None: ...
	@property
	def style_src_elem(self) -> Optional[str]: ...
	@style_src_elem.setter
	def style_src_elem(self, value: Optional[str]) -> None: ...
	@style_src_elem.deleter
	def style_src_elem(self) -> None: ...
	@property
	def worker_src(self) -> Optional[str]: ...
	@worker_src.setter
	def worker_src(self, value: Optional[str]) -> None: ...
	@worker_src.deleter
	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: ...
	@property
	def units(self) -> Optional[str]: ...
	@units.setter
	def units(self, value: Optional[str]) -> None: ...
	@property
	def start(self) -> Optional[int]: ...
	@start.setter
	def start(self, value: Optional[int]) -> None: ...
	@property
	def stop(self) -> Optional[int]: ...
	@stop.setter
	def stop(self, value: Optional[int]) -> None: ...
	@property
	def length(self) -> Optional[int]: ...
	@length.setter
	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: ...
	@property
	def username(self) -> Optional[str]: ...
	@property
	def password(self) -> Optional[str]: ...
	@property
	def realm(self) -> Optional[str]: ...
	@property
	def nonce(self) -> Optional[str]: ...
	@property
	def uri(self) -> Optional[str]: ...
	@property
	def nc(self) -> Optional[str]: ...
	@property
	def cnonce(self) -> Optional[str]: ...
	@property
	def response(self) -> Optional[str]: ...
	@property
	def opaque(self) -> Optional[str]: ...
	@property
	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: ...
	@property
	def type(self) -> Optional[str]: ...
	@type.setter
	def type(self, value: Optional[str]) -> None: ...
	@property
	def realm(self) -> Optional[str]: ...
	@realm.setter
	def realm(self, value: Optional[str]) -> None: ...
	@property
	def domain(self) -> HeaderSet: ...
	@property
	def nonce(self) -> Optional[str]: ...
	@nonce.setter
	def nonce(self, value: Optional[str]) -> None: ...
	@property
	def opaque(self) -> Optional[str]: ...
	@opaque.setter
	def opaque(self, value: Optional[str]) -> None: ...
	@property
	def algorithm(self) -> Optional[str]: ...
	@algorithm.setter
	def algorithm(self, value: Optional[str]) -> None: ...
	@property
	def qop(self) -> HeaderSet: ...
	@property
	def stale(self) -> Optional[bool]: ...
	@stale.setter
	def stale(self, value: Optional[bool]) -> None: ...
	@staticmethod
	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: ...
	@property
	def content_type(self) -> str: ...
	@property
	def content_length(self) -> int: ...
	@property
	def mimetype(self) -> str: ...
	@property
	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: ...