add code for analysis of data

1 files changed, 206 insertions, 0 deletions

diff --git a/venv/lib/python3.8/site-packages/werkzeug/datastructures/structures.pyi b/venv/lib/python3.8/site-packages/werkzeug/datastructures/structures.pyi
new file mode 100644
index 0000000..7086dda
--- /dev/null
+++ b/venv/lib/python3.8/site-packages/werkzeug/datastructures/structures.pyi
@@ -0,0 +1,206 @@
+from collections.abc import Callable
+from collections.abc import Iterable
+from collections.abc import Iterator
+from collections.abc import Mapping
+from typing import Any
+from typing import Generic
+from typing import Literal
+from typing import NoReturn
+from typing import overload
+from typing import TypeVar
+
+from .mixins import ImmutableDictMixin
+from .mixins import ImmutableListMixin
+from .mixins import ImmutableMultiDictMixin
+from .mixins import UpdateDictMixin
+
+D = TypeVar("D")
+K = TypeVar("K")
+T = TypeVar("T")
+V = TypeVar("V")
+_CD = TypeVar("_CD", bound="CallbackDict[Any, Any]")
+
+def is_immutable(self: object) -> NoReturn: ...
+def iter_multi_items(
+    mapping: Mapping[K, V | Iterable[V]] | Iterable[tuple[K, V]],
+) -> Iterator[tuple[K, V]]: ...
+
+class ImmutableList(ImmutableListMixin[V]): ...
+
+class TypeConversionDict(dict[K, V]):
+    @overload
+    def get(self, key: K, default: None = ..., type: None = ...) -> V | None: ...
+    @overload
+    def get(self, key: K, default: D, type: None = ...) -> D | V: ...
+    @overload
+    def get(self, key: K, default: D, type: Callable[[V], T]) -> D | T: ...
+    @overload
+    def get(self, key: K, type: Callable[[V], T]) -> T | None: ...
+
+class ImmutableTypeConversionDict(ImmutableDictMixin[K, V], TypeConversionDict[K, V]):
+    def copy(self) -> TypeConversionDict[K, V]: ...
+    def __copy__(self) -> ImmutableTypeConversionDict[K, V]: ...
+
+class MultiDict(TypeConversionDict[K, V]):
+    def __init__(
+        self,
+        mapping: Mapping[K, Iterable[V] | V] | Iterable[tuple[K, V]] | None = 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: V | None = None) -> V: ...
+    def setlistdefault(
+        self, key: K, default_list: Iterable[V] | None = 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: Mapping[K, Iterable[V] | V] | Iterable[tuple[K, V]]
+    ) -> None: ...
+    @overload
+    def pop(self, key: K) -> V: ...
+    @overload
+    def pop(self, key: K, default: V | T = ...) -> 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: _omd_bucket[K, V] | None
+    next: _omd_bucket[K, V] | None
+    key: K
+    value: V
+    def __init__(self, omd: OrderedMultiDict[K, V], key: K, value: V) -> None: ...
+    def unlink(self, omd: OrderedMultiDict[K, V]) -> None: ...
+
+class OrderedMultiDict(MultiDict[K, V]):
+    _first_bucket: _omd_bucket[K, V] | None
+    _last_bucket: _omd_bucket[K, V] | None
+    def __init__(self, mapping: Mapping[K, V] | None = 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: Iterable[V] | None = None
+    ) -> list[V]: ...
+    def update(  # type: ignore
+        self, mapping: 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: V | T = ...) -> V | T: ...
+    def popitem(self) -> tuple[K, V]: ...
+    def popitemlist(self) -> tuple[K, list[V]]: ...
+
+class CombinedMultiDict(ImmutableMultiDictMixin[K, V], MultiDict[K, V]):  # type: ignore
+    dicts: list[MultiDict[K, V]]
+    def __init__(self, dicts: Iterable[MultiDict[K, V]] | None) -> 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) -> V | None: ...
+    @overload
+    def get(self, key: K, default: V | T = ...) -> V | T: ...
+    @overload
+    def get(
+        self, key: K, default: T | None = None, type: Callable[[V], T] = ...
+    ) -> T | None: ...
+    @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 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 CallbackDict(UpdateDictMixin[K, V], dict[K, V]):
+    def __init__(
+        self,
+        initial: Mapping[K, V] | Iterable[tuple[K, V]] | None = None,
+        on_update: Callable[[_CD], None] | None = None,
+    ) -> None: ...
+
+class HeaderSet(set[str]):
+    _headers: list[str]
+    _set: set[str]
+    on_update: Callable[[HeaderSet], None] | None
+    def __init__(
+        self,
+        headers: Iterable[str] | None = None,
+        on_update: Callable[[HeaderSet], None] | 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]: ...