codekingpro/portable-devtools

1from collections.abc import Callable2from collections.abc import Iterable3from collections.abc import Iterator4from collections.abc import Mapping5from typing import Any6from typing import Generic7from typing import Literal8from typing import NoReturn9from typing import overload10from typing import TypeVar11 12from .mixins import ImmutableDictMixin13from .mixins import ImmutableListMixin14from .mixins import ImmutableMultiDictMixin15from .mixins import UpdateDictMixin16 17D = TypeVar("D")18K = TypeVar("K")19T = TypeVar("T")20V = TypeVar("V")21_CD = TypeVar("_CD", bound="CallbackDict[Any, Any]")22 23def is_immutable(self: object) -> NoReturn: ...24def iter_multi_items(25    mapping: Mapping[K, V | Iterable[V]] | Iterable[tuple[K, V]],26) -> Iterator[tuple[K, V]]: ...27 28class ImmutableList(ImmutableListMixin[V]): ...29 30class TypeConversionDict(dict[K, V]):31    @overload32    def get(self, key: K, default: None = ..., type: None = ...) -> V | None: ...33    @overload34    def get(self, key: K, default: D, type: None = ...) -> D | V: ...35    @overload36    def get(self, key: K, default: D, type: Callable[[V], T]) -> D | T: ...37    @overload38    def get(self, key: K, type: Callable[[V], T]) -> T | None: ...39 40class ImmutableTypeConversionDict(ImmutableDictMixin[K, V], TypeConversionDict[K, V]):41    def copy(self) -> TypeConversionDict[K, V]: ...42    def __copy__(self) -> ImmutableTypeConversionDict[K, V]: ...43 44class MultiDict(TypeConversionDict[K, V]):45    def __init__(46        self,47        mapping: Mapping[K, Iterable[V] | V] | Iterable[tuple[K, V]] | None = None,48    ) -> None: ...49    def __getitem__(self, item: K) -> V: ...50    def __setitem__(self, key: K, value: V) -> None: ...51    def add(self, key: K, value: V) -> None: ...52    @overload53    def getlist(self, key: K) -> list[V]: ...54    @overload55    def getlist(self, key: K, type: Callable[[V], T] = ...) -> list[T]: ...56    def setlist(self, key: K, new_list: Iterable[V]) -> None: ...57    def setdefault(self, key: K, default: V | None = None) -> V: ...58    def setlistdefault(59        self, key: K, default_list: Iterable[V] | None = None60    ) -> list[V]: ...61    def items(self, multi: bool = False) -> Iterator[tuple[K, V]]: ...  # type: ignore62    def lists(self) -> Iterator[tuple[K, list[V]]]: ...63    def values(self) -> Iterator[V]: ...  # type: ignore64    def listvalues(self) -> Iterator[list[V]]: ...65    def copy(self) -> MultiDict[K, V]: ...66    def deepcopy(self, memo: Any = None) -> MultiDict[K, V]: ...67    @overload68    def to_dict(self) -> dict[K, V]: ...69    @overload70    def to_dict(self, flat: Literal[False]) -> dict[K, list[V]]: ...71    def update(  # type: ignore72        self, mapping: Mapping[K, Iterable[V] | V] | Iterable[tuple[K, V]]73    ) -> None: ...74    @overload75    def pop(self, key: K) -> V: ...76    @overload77    def pop(self, key: K, default: V | T = ...) -> V | T: ...78    def popitem(self) -> tuple[K, V]: ...79    def poplist(self, key: K) -> list[V]: ...80    def popitemlist(self) -> tuple[K, list[V]]: ...81    def __copy__(self) -> MultiDict[K, V]: ...82    def __deepcopy__(self, memo: Any) -> MultiDict[K, V]: ...83 84class _omd_bucket(Generic[K, V]):85    prev: _omd_bucket[K, V] | None86    next: _omd_bucket[K, V] | None87    key: K88    value: V89    def __init__(self, omd: OrderedMultiDict[K, V], key: K, value: V) -> None: ...90    def unlink(self, omd: OrderedMultiDict[K, V]) -> None: ...91 92class OrderedMultiDict(MultiDict[K, V]):93    _first_bucket: _omd_bucket[K, V] | None94    _last_bucket: _omd_bucket[K, V] | None95    def __init__(self, mapping: Mapping[K, V] | None = None) -> None: ...96    def __eq__(self, other: object) -> bool: ...97    def __getitem__(self, key: K) -> V: ...98    def __setitem__(self, key: K, value: V) -> None: ...99    def __delitem__(self, key: K) -> None: ...100    def keys(self) -> Iterator[K]: ...  # type: ignore101    def __iter__(self) -> Iterator[K]: ...102    def values(self) -> Iterator[V]: ...  # type: ignore103    def items(self, multi: bool = False) -> Iterator[tuple[K, V]]: ...  # type: ignore104    def lists(self) -> Iterator[tuple[K, list[V]]]: ...105    def listvalues(self) -> Iterator[list[V]]: ...106    def add(self, key: K, value: V) -> None: ...107    @overload108    def getlist(self, key: K) -> list[V]: ...109    @overload110    def getlist(self, key: K, type: Callable[[V], T] = ...) -> list[T]: ...111    def setlist(self, key: K, new_list: Iterable[V]) -> None: ...112    def setlistdefault(113        self, key: K, default_list: Iterable[V] | None = None114    ) -> list[V]: ...115    def update(  # type: ignore116        self, mapping: Mapping[K, V] | Iterable[tuple[K, V]]117    ) -> None: ...118    def poplist(self, key: K) -> list[V]: ...119    @overload120    def pop(self, key: K) -> V: ...121    @overload122    def pop(self, key: K, default: V | T = ...) -> V | T: ...123    def popitem(self) -> tuple[K, V]: ...124    def popitemlist(self) -> tuple[K, list[V]]: ...125 126class CombinedMultiDict(ImmutableMultiDictMixin[K, V], MultiDict[K, V]):  # type: ignore127    dicts: list[MultiDict[K, V]]128    def __init__(self, dicts: Iterable[MultiDict[K, V]] | None) -> None: ...129    @classmethod130    def fromkeys(cls, keys: Any, value: Any = None) -> NoReturn: ...131    def __getitem__(self, key: K) -> V: ...132    @overload  # type: ignore133    def get(self, key: K) -> V | None: ...134    @overload135    def get(self, key: K, default: V | T = ...) -> V | T: ...136    @overload137    def get(138        self, key: K, default: T | None = None, type: Callable[[V], T] = ...139    ) -> T | None: ...140    @overload141    def getlist(self, key: K) -> list[V]: ...142    @overload143    def getlist(self, key: K, type: Callable[[V], T] = ...) -> list[T]: ...144    def _keys_impl(self) -> set[K]: ...145    def keys(self) -> set[K]: ...  # type: ignore146    def __iter__(self) -> set[K]: ...  # type: ignore147    def items(self, multi: bool = False) -> Iterator[tuple[K, V]]: ...  # type: ignore148    def values(self) -> Iterator[V]: ...  # type: ignore149    def lists(self) -> Iterator[tuple[K, list[V]]]: ...150    def listvalues(self) -> Iterator[list[V]]: ...151    def copy(self) -> MultiDict[K, V]: ...152    @overload153    def to_dict(self) -> dict[K, V]: ...154    @overload155    def to_dict(self, flat: Literal[False]) -> dict[K, list[V]]: ...156    def __contains__(self, key: K) -> bool: ...  # type: ignore157    def has_key(self, key: K) -> bool: ...158 159class ImmutableDict(ImmutableDictMixin[K, V], dict[K, V]):160    def copy(self) -> dict[K, V]: ...161    def __copy__(self) -> ImmutableDict[K, V]: ...162 163class ImmutableMultiDict(  # type: ignore164    ImmutableMultiDictMixin[K, V], MultiDict[K, V]165):166    def copy(self) -> MultiDict[K, V]: ...167    def __copy__(self) -> ImmutableMultiDict[K, V]: ...168 169class ImmutableOrderedMultiDict(  # type: ignore170    ImmutableMultiDictMixin[K, V], OrderedMultiDict[K, V]171):172    def _iter_hashitems(self) -> Iterator[tuple[int, tuple[K, V]]]: ...173    def copy(self) -> OrderedMultiDict[K, V]: ...174    def __copy__(self) -> ImmutableOrderedMultiDict[K, V]: ...175 176class CallbackDict(UpdateDictMixin[K, V], dict[K, V]):177    def __init__(178        self,179        initial: Mapping[K, V] | Iterable[tuple[K, V]] | None = None,180        on_update: Callable[[_CD], None] | None = None,181    ) -> None: ...182 183class HeaderSet(set[str]):184    _headers: list[str]185    _set: set[str]186    on_update: Callable[[HeaderSet], None] | None187    def __init__(188        self,189        headers: Iterable[str] | None = None,190        on_update: Callable[[HeaderSet], None] | None = None,191    ) -> None: ...192    def add(self, header: str) -> None: ...193    def remove(self, header: str) -> None: ...194    def update(self, iterable: Iterable[str]) -> None: ...  # type: ignore195    def discard(self, header: str) -> None: ...196    def find(self, header: str) -> int: ...197    def index(self, header: str) -> int: ...198    def clear(self) -> None: ...199    def as_set(self, preserve_casing: bool = False) -> set[str]: ...200    def to_header(self) -> str: ...201    def __getitem__(self, idx: int) -> str: ...202    def __delitem__(self, idx: int) -> None: ...203    def __setitem__(self, idx: int, value: str) -> None: ...204    def __contains__(self, header: str) -> bool: ...  # type: ignore205    def __len__(self) -> int: ...206    def __iter__(self) -> Iterator[str]: ...207