Add files using upload-large-folder tool

.gitattributes

@@ -483,3 +483,6 @@ material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/matplotlib/m
 material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pip/_vendor/html5lib/__pycache__/constants.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pillow.libs/liblzma-64b7ab39.so.5.8.1 filter=lfs diff=lfs merge=lfs -text
 material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans-BoldOblique.ttf filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected_4Classes/1908314_cm.tif filter=lfs diff=lfs merge=lfs -text

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/BaseHTTPServer.pyi

@@ -0,0 +1,41 @@
+import mimetools
+import SocketServer
+from typing import Any, BinaryIO, Callable, Mapping, Optional, Tuple, Union
+
+class HTTPServer(SocketServer.TCPServer):
+    server_name: str
+    server_port: int
+    def __init__(self, server_address: Tuple[str, int], RequestHandlerClass: Callable[..., BaseHTTPRequestHandler]) -> None: ...
+
+class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
+    client_address: Tuple[str, int]
+    server: SocketServer.BaseServer
+    close_connection: bool
+    command: str
+    path: str
+    request_version: str
+    headers: mimetools.Message
+    rfile: BinaryIO
+    wfile: BinaryIO
+    server_version: str
+    sys_version: str
+    error_message_format: str
+    error_content_type: str
+    protocol_version: str
+    MessageClass: type
+    responses: Mapping[int, Tuple[str, str]]
+    def __init__(self, request: bytes, client_address: Tuple[str, int], server: SocketServer.BaseServer) -> None: ...
+    def handle(self) -> None: ...
+    def handle_one_request(self) -> None: ...
+    def send_error(self, code: int, message: Optional[str] = ...) -> None: ...
+    def send_response(self, code: int, message: Optional[str] = ...) -> None: ...
+    def send_header(self, keyword: str, value: str) -> None: ...
+    def end_headers(self) -> None: ...
+    def flush_headers(self) -> None: ...
+    def log_request(self, code: Union[int, str] = ..., size: Union[int, str] = ...) -> None: ...
+    def log_error(self, format: str, *args: Any) -> None: ...
+    def log_message(self, format: str, *args: Any) -> None: ...
+    def version_string(self) -> str: ...
+    def date_time_string(self, timestamp: Optional[int] = ...) -> str: ...
+    def log_date_time_string(self) -> str: ...
+    def address_string(self) -> str: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/ConfigParser.pyi

@@ -0,0 +1,97 @@
+from _typeshed import SupportsNoArgReadline
+from typing import IO, Any, Dict, List, Optional, Sequence, Tuple, Union
+
+DEFAULTSECT: str
+MAX_INTERPOLATION_DEPTH: int
+
+class Error(Exception):
+    message: Any
+    def __init__(self, msg: str = ...) -> None: ...
+    def _get_message(self) -> None: ...
+    def _set_message(self, value: str) -> None: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+
+class NoSectionError(Error):
+    section: str
+    def __init__(self, section: str) -> None: ...
+
+class DuplicateSectionError(Error):
+    section: str
+    def __init__(self, section: str) -> None: ...
+
+class NoOptionError(Error):
+    section: str
+    option: str
+    def __init__(self, option: str, section: str) -> None: ...
+
+class InterpolationError(Error):
+    section: str
+    option: str
+    msg: str
+    def __init__(self, option: str, section: str, msg: str) -> None: ...
+
+class InterpolationMissingOptionError(InterpolationError):
+    reference: str
+    def __init__(self, option: str, section: str, rawval: str, reference: str) -> None: ...
+
+class InterpolationSyntaxError(InterpolationError): ...
+
+class InterpolationDepthError(InterpolationError):
+    def __init__(self, option: str, section: str, rawval: str) -> None: ...
+
+class ParsingError(Error):
+    filename: str
+    errors: List[Tuple[Any, Any]]
+    def __init__(self, filename: str) -> None: ...
+    def append(self, lineno: Any, line: Any) -> None: ...
+
+class MissingSectionHeaderError(ParsingError):
+    lineno: Any
+    line: Any
+    def __init__(self, filename: str, lineno: Any, line: Any) -> None: ...
+
+class RawConfigParser:
+    _dict: Any
+    _sections: Dict[Any, Any]
+    _defaults: Dict[Any, Any]
+    _optcre: Any
+    SECTCRE: Any
+    OPTCRE: Any
+    OPTCRE_NV: Any
+    def __init__(self, defaults: Dict[Any, Any] = ..., dict_type: Any = ..., allow_no_value: bool = ...) -> None: ...
+    def defaults(self) -> Dict[Any, Any]: ...
+    def sections(self) -> List[str]: ...
+    def add_section(self, section: str) -> None: ...
+    def has_section(self, section: str) -> bool: ...
+    def options(self, section: str) -> List[str]: ...
+    def read(self, filenames: Union[str, Sequence[str]]) -> List[str]: ...
+    def readfp(self, fp: SupportsNoArgReadline[str], filename: str = ...) -> None: ...
+    def get(self, section: str, option: str) -> str: ...
+    def items(self, section: str) -> List[Tuple[Any, Any]]: ...
+    def _get(self, section: str, conv: type, option: str) -> Any: ...
+    def getint(self, section: str, option: str) -> int: ...
+    def getfloat(self, section: str, option: str) -> float: ...
+    _boolean_states: Dict[str, bool]
+    def getboolean(self, section: str, option: str) -> bool: ...
+    def optionxform(self, optionstr: str) -> str: ...
+    def has_option(self, section: str, option: str) -> bool: ...
+    def set(self, section: str, option: str, value: Any = ...) -> None: ...
+    def write(self, fp: IO[str]) -> None: ...
+    def remove_option(self, section: str, option: Any) -> bool: ...
+    def remove_section(self, section: str) -> bool: ...
+    def _read(self, fp: IO[str], fpname: str) -> None: ...
+
+class ConfigParser(RawConfigParser):
+    _KEYCRE: Any
+    def get(self, section: str, option: str, raw: bool = ..., vars: Optional[Dict[Any, Any]] = ...) -> Any: ...
+    def items(self, section: str, raw: bool = ..., vars: Optional[Dict[Any, Any]] = ...) -> List[Tuple[str, Any]]: ...
+    def _interpolate(self, section: str, option: str, rawval: Any, vars: Any) -> str: ...
+    def _interpolation_replace(self, match: Any) -> str: ...
+
+class SafeConfigParser(ConfigParser):
+    _interpvar_re: Any
+    def _interpolate(self, section: str, option: str, rawval: Any, vars: Any) -> str: ...
+    def _interpolate_some(
+        self, option: str, accum: List[Any], rest: str, section: str, map: Dict[Any, Any], depth: int
+    ) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/__builtin__.pyi

@@ -0,0 +1,1195 @@
+# True and False are deliberately omitted because they are keywords in
+# Python 3, and stub files conform to Python 3 syntax.
+
+from _typeshed import ReadableBuffer, SupportsKeysAndGetItem, SupportsWrite
+from abc import ABCMeta
+from ast import mod
+from types import CodeType
+from typing import (
+    AbstractSet,
+    Any,
+    AnyStr,
+    BinaryIO,
+    ByteString,
+    Callable,
+    Container,
+    Dict,
+    FrozenSet,
+    Generic,
+    ItemsView,
+    Iterable,
+    Iterator,
+    KeysView,
+    List,
+    Mapping,
+    MutableMapping,
+    MutableSequence,
+    MutableSet,
+    NoReturn,
+    Optional,
+    Protocol,
+    Reversible,
+    Sequence,
+    Set,
+    Sized,
+    SupportsAbs,
+    SupportsComplex,
+    SupportsFloat,
+    SupportsInt,
+    Text,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    ValuesView,
+    overload,
+    runtime_checkable,
+)
+from typing_extensions import Literal
+
+class _SupportsIndex(Protocol):
+    def __index__(self) -> int: ...
+
+class _SupportsTrunc(Protocol):
+    def __trunc__(self) -> int: ...
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+_S = TypeVar("_S")
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+_T4 = TypeVar("_T4")
+_T5 = TypeVar("_T5")
+_TT = TypeVar("_TT", bound="type")
+_TBE = TypeVar("_TBE", bound="BaseException")
+
+class object:
+    __doc__: Optional[str]
+    __dict__: Dict[str, Any]
+    __slots__: Union[Text, Iterable[Text]]
+    __module__: str
+    @property
+    def __class__(self: _T) -> Type[_T]: ...
+    @__class__.setter
+    def __class__(self, __type: Type[object]) -> None: ...  # noqa: F811
+    def __init__(self) -> None: ...
+    def __new__(cls) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+    def __eq__(self, o: object) -> bool: ...
+    def __ne__(self, o: object) -> bool: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __hash__(self) -> int: ...
+    def __format__(self, format_spec: str) -> str: ...
+    def __getattribute__(self, name: str) -> Any: ...
+    def __delattr__(self, name: str) -> None: ...
+    def __sizeof__(self) -> int: ...
+    def __reduce__(self) -> Union[str, Tuple[Any, ...]]: ...
+    def __reduce_ex__(self, protocol: int) -> Union[str, Tuple[Any, ...]]: ...
+
+class staticmethod(object):  # Special, only valid as a decorator.
+    __func__: Callable[..., Any]
+    def __init__(self, f: Callable[..., Any]) -> None: ...
+    def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...
+    def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ...
+
+class classmethod(object):  # Special, only valid as a decorator.
+    __func__: Callable[..., Any]
+    def __init__(self, f: Callable[..., Any]) -> None: ...
+    def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...
+    def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ...
+
+class type(object):
+    __base__: type
+    __bases__: Tuple[type, ...]
+    __basicsize__: int
+    __dict__: Dict[str, Any]
+    __dictoffset__: int
+    __flags__: int
+    __itemsize__: int
+    __module__: str
+    __mro__: Tuple[type, ...]
+    __name__: str
+    __weakrefoffset__: int
+    @overload
+    def __init__(self, o: object) -> None: ...
+    @overload
+    def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ...
+    @overload
+    def __new__(cls, o: object) -> type: ...
+    @overload
+    def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ...
+    def __call__(self, *args: Any, **kwds: Any) -> Any: ...
+    def __subclasses__(self: _TT) -> List[_TT]: ...
+    # Note: the documentation doesnt specify what the return type is, the standard
+    # implementation seems to be returning a list.
+    def mro(self) -> List[type]: ...
+    def __instancecheck__(self, instance: Any) -> bool: ...
+    def __subclasscheck__(self, subclass: type) -> bool: ...
+
+class super(object):
+    @overload
+    def __init__(self, t: Any, obj: Any) -> None: ...
+    @overload
+    def __init__(self, t: Any) -> None: ...
+
+class int:
+    @overload
+    def __new__(cls: Type[_T], x: Union[Text, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc] = ...) -> _T: ...
+    @overload
+    def __new__(cls: Type[_T], x: Union[Text, bytes, bytearray], base: int) -> _T: ...
+    @property
+    def real(self) -> int: ...
+    @property
+    def imag(self) -> int: ...
+    @property
+    def numerator(self) -> int: ...
+    @property
+    def denominator(self) -> int: ...
+    def conjugate(self) -> int: ...
+    def bit_length(self) -> int: ...
+    def __add__(self, x: int) -> int: ...
+    def __sub__(self, x: int) -> int: ...
+    def __mul__(self, x: int) -> int: ...
+    def __floordiv__(self, x: int) -> int: ...
+    def __div__(self, x: int) -> int: ...
+    def __truediv__(self, x: int) -> float: ...
+    def __mod__(self, x: int) -> int: ...
+    def __divmod__(self, x: int) -> Tuple[int, int]: ...
+    def __radd__(self, x: int) -> int: ...
+    def __rsub__(self, x: int) -> int: ...
+    def __rmul__(self, x: int) -> int: ...
+    def __rfloordiv__(self, x: int) -> int: ...
+    def __rdiv__(self, x: int) -> int: ...
+    def __rtruediv__(self, x: int) -> float: ...
+    def __rmod__(self, x: int) -> int: ...
+    def __rdivmod__(self, x: int) -> Tuple[int, int]: ...
+    @overload
+    def __pow__(self, __x: Literal[2], __modulo: Optional[int] = ...) -> int: ...
+    @overload
+    def __pow__(self, __x: int, __modulo: Optional[int] = ...) -> Any: ...  # Return type can be int or float, depending on x.
+    def __rpow__(self, x: int, mod: Optional[int] = ...) -> Any: ...
+    def __and__(self, n: int) -> int: ...
+    def __or__(self, n: int) -> int: ...
+    def __xor__(self, n: int) -> int: ...
+    def __lshift__(self, n: int) -> int: ...
+    def __rshift__(self, n: int) -> int: ...
+    def __rand__(self, n: int) -> int: ...
+    def __ror__(self, n: int) -> int: ...
+    def __rxor__(self, n: int) -> int: ...
+    def __rlshift__(self, n: int) -> int: ...
+    def __rrshift__(self, n: int) -> int: ...
+    def __neg__(self) -> int: ...
+    def __pos__(self) -> int: ...
+    def __invert__(self) -> int: ...
+    def __trunc__(self) -> int: ...
+    def __getnewargs__(self) -> Tuple[int]: ...
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: int) -> bool: ...
+    def __le__(self, x: int) -> bool: ...
+    def __gt__(self, x: int) -> bool: ...
+    def __ge__(self, x: int) -> bool: ...
+    def __str__(self) -> str: ...
+    def __float__(self) -> float: ...
+    def __int__(self) -> int: ...
+    def __abs__(self) -> int: ...
+    def __hash__(self) -> int: ...
+    def __nonzero__(self) -> bool: ...
+    def __index__(self) -> int: ...
+
+class float:
+    def __new__(cls: Type[_T], x: Union[SupportsFloat, _SupportsIndex, Text, bytes, bytearray] = ...) -> _T: ...
+    def as_integer_ratio(self) -> Tuple[int, int]: ...
+    def hex(self) -> str: ...
+    def is_integer(self) -> bool: ...
+    @classmethod
+    def fromhex(cls, __s: str) -> float: ...
+    @property
+    def real(self) -> float: ...
+    @property
+    def imag(self) -> float: ...
+    def conjugate(self) -> float: ...
+    def __add__(self, x: float) -> float: ...
+    def __sub__(self, x: float) -> float: ...
+    def __mul__(self, x: float) -> float: ...
+    def __floordiv__(self, x: float) -> float: ...
+    def __div__(self, x: float) -> float: ...
+    def __truediv__(self, x: float) -> float: ...
+    def __mod__(self, x: float) -> float: ...
+    def __divmod__(self, x: float) -> Tuple[float, float]: ...
+    def __pow__(
+        self, x: float, mod: None = ...
+    ) -> float: ...  # In Python 3, returns complex if self is negative and x is not whole
+    def __radd__(self, x: float) -> float: ...
+    def __rsub__(self, x: float) -> float: ...
+    def __rmul__(self, x: float) -> float: ...
+    def __rfloordiv__(self, x: float) -> float: ...
+    def __rdiv__(self, x: float) -> float: ...
+    def __rtruediv__(self, x: float) -> float: ...
+    def __rmod__(self, x: float) -> float: ...
+    def __rdivmod__(self, x: float) -> Tuple[float, float]: ...
+    def __rpow__(self, x: float, mod: None = ...) -> float: ...
+    def __getnewargs__(self) -> Tuple[float]: ...
+    def __trunc__(self) -> int: ...
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: float) -> bool: ...
+    def __le__(self, x: float) -> bool: ...
+    def __gt__(self, x: float) -> bool: ...
+    def __ge__(self, x: float) -> bool: ...
+    def __neg__(self) -> float: ...
+    def __pos__(self) -> float: ...
+    def __str__(self) -> str: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __abs__(self) -> float: ...
+    def __hash__(self) -> int: ...
+    def __nonzero__(self) -> bool: ...
+
+class complex:
+    @overload
+    def __new__(cls: Type[_T], real: float = ..., imag: float = ...) -> _T: ...
+    @overload
+    def __new__(cls: Type[_T], real: Union[str, SupportsComplex, _SupportsIndex]) -> _T: ...
+    @property
+    def real(self) -> float: ...
+    @property
+    def imag(self) -> float: ...
+    def conjugate(self) -> complex: ...
+    def __add__(self, x: complex) -> complex: ...
+    def __sub__(self, x: complex) -> complex: ...
+    def __mul__(self, x: complex) -> complex: ...
+    def __pow__(self, x: complex, mod: None = ...) -> complex: ...
+    def __div__(self, x: complex) -> complex: ...
+    def __truediv__(self, x: complex) -> complex: ...
+    def __radd__(self, x: complex) -> complex: ...
+    def __rsub__(self, x: complex) -> complex: ...
+    def __rmul__(self, x: complex) -> complex: ...
+    def __rpow__(self, x: complex, mod: None = ...) -> complex: ...
+    def __rdiv__(self, x: complex) -> complex: ...
+    def __rtruediv__(self, x: complex) -> complex: ...
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __neg__(self) -> complex: ...
+    def __pos__(self) -> complex: ...
+    def __str__(self) -> str: ...
+    def __complex__(self) -> complex: ...
+    def __abs__(self) -> float: ...
+    def __hash__(self) -> int: ...
+    def __nonzero__(self) -> bool: ...
+
+class basestring(metaclass=ABCMeta): ...
+
+class unicode(basestring, Sequence[unicode]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, o: object) -> None: ...
+    @overload
+    def __init__(self, o: str, encoding: unicode = ..., errors: unicode = ...) -> None: ...
+    def capitalize(self) -> unicode: ...
+    def center(self, width: int, fillchar: unicode = ...) -> unicode: ...
+    def count(self, x: unicode) -> int: ...
+    def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...
+    def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
+    def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]], start: int = ..., end: int = ...) -> bool: ...
+    def expandtabs(self, tabsize: int = ...) -> unicode: ...
+    def find(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...
+    def format(self, *args: object, **kwargs: object) -> unicode: ...
+    def index(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...
+    def isalnum(self) -> bool: ...
+    def isalpha(self) -> bool: ...
+    def isdecimal(self) -> bool: ...
+    def isdigit(self) -> bool: ...
+    def isidentifier(self) -> bool: ...
+    def islower(self) -> bool: ...
+    def isnumeric(self) -> bool: ...
+    def isprintable(self) -> bool: ...
+    def isspace(self) -> bool: ...
+    def istitle(self) -> bool: ...
+    def isupper(self) -> bool: ...
+    def join(self, iterable: Iterable[unicode]) -> unicode: ...
+    def ljust(self, width: int, fillchar: unicode = ...) -> unicode: ...
+    def lower(self) -> unicode: ...
+    def lstrip(self, chars: unicode = ...) -> unicode: ...
+    def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+    def replace(self, old: unicode, new: unicode, count: int = ...) -> unicode: ...
+    def rfind(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...
+    def rindex(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...
+    def rjust(self, width: int, fillchar: unicode = ...) -> unicode: ...
+    def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+    def rsplit(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
+    def rstrip(self, chars: unicode = ...) -> unicode: ...
+    def split(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
+    def splitlines(self, keepends: bool = ...) -> List[unicode]: ...
+    def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = ..., end: int = ...) -> bool: ...
+    def strip(self, chars: unicode = ...) -> unicode: ...
+    def swapcase(self) -> unicode: ...
+    def title(self) -> unicode: ...
+    def translate(self, table: Union[Dict[int, Any], unicode]) -> unicode: ...
+    def upper(self) -> unicode: ...
+    def zfill(self, width: int) -> unicode: ...
+    @overload
+    def __getitem__(self, i: int) -> unicode: ...
+    @overload
+    def __getitem__(self, s: slice) -> unicode: ...
+    def __getslice__(self, start: int, stop: int) -> unicode: ...
+    def __add__(self, s: unicode) -> unicode: ...
+    def __mul__(self, n: int) -> unicode: ...
+    def __rmul__(self, n: int) -> unicode: ...
+    def __mod__(self, x: Any) -> unicode: ...
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: unicode) -> bool: ...
+    def __le__(self, x: unicode) -> bool: ...
+    def __gt__(self, x: unicode) -> bool: ...
+    def __ge__(self, x: unicode) -> bool: ...
+    def __len__(self) -> int: ...
+    # The argument type is incompatible with Sequence
+    def __contains__(self, s: Union[unicode, bytes]) -> bool: ...  # type: ignore
+    def __iter__(self) -> Iterator[unicode]: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __hash__(self) -> int: ...
+    def __getnewargs__(self) -> Tuple[unicode]: ...
+
+class _FormatMapMapping(Protocol):
+    def __getitem__(self, __key: str) -> Any: ...
+
+class str(Sequence[str], basestring):
+    def __init__(self, o: object = ...) -> None: ...
+    def capitalize(self) -> str: ...
+    def center(self, __width: int, __fillchar: str = ...) -> str: ...
+    def count(self, x: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    def decode(self, encoding: Text = ..., errors: Text = ...) -> unicode: ...
+    def encode(self, encoding: Text = ..., errors: Text = ...) -> bytes: ...
+    def endswith(self, suffix: Union[Text, Tuple[Text, ...]]) -> bool: ...
+    def expandtabs(self, tabsize: int = ...) -> str: ...
+    def find(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    def format(self, *args: object, **kwargs: object) -> str: ...
+    def format_map(self, map: _FormatMapMapping) -> str: ...
+    def index(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    def isalnum(self) -> bool: ...
+    def isalpha(self) -> bool: ...
+    def isdigit(self) -> bool: ...
+    def islower(self) -> bool: ...
+    def isspace(self) -> bool: ...
+    def istitle(self) -> bool: ...
+    def isupper(self) -> bool: ...
+    def join(self, __iterable: Iterable[AnyStr]) -> AnyStr: ...
+    def ljust(self, __width: int, __fillchar: str = ...) -> str: ...
+    def lower(self) -> str: ...
+    @overload
+    def lstrip(self, __chars: str = ...) -> str: ...
+    @overload
+    def lstrip(self, __chars: unicode) -> unicode: ...
+    @overload
+    def partition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ...
+    @overload
+    def partition(self, __sep: str) -> Tuple[str, str, str]: ...
+    @overload
+    def partition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+    def replace(self, __old: AnyStr, __new: AnyStr, __count: int = ...) -> AnyStr: ...
+    def rfind(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    def rindex(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    def rjust(self, __width: int, __fillchar: str = ...) -> str: ...
+    @overload
+    def rpartition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ...
+    @overload
+    def rpartition(self, __sep: str) -> Tuple[str, str, str]: ...
+    @overload
+    def rpartition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+    @overload
+    def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+    @overload
+    def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
+    @overload
+    def rstrip(self, __chars: str = ...) -> str: ...
+    @overload
+    def rstrip(self, __chars: unicode) -> unicode: ...
+    @overload
+    def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+    @overload
+    def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
+    def splitlines(self, keepends: bool = ...) -> List[str]: ...
+    def startswith(self, prefix: Union[Text, Tuple[Text, ...]]) -> bool: ...
+    @overload
+    def strip(self, __chars: str = ...) -> str: ...
+    @overload
+    def strip(self, chars: unicode) -> unicode: ...
+    def swapcase(self) -> str: ...
+    def title(self) -> str: ...
+    def translate(self, __table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ...
+    def upper(self) -> str: ...
+    def zfill(self, __width: int) -> str: ...
+    def __add__(self, s: AnyStr) -> AnyStr: ...
+    # Incompatible with Sequence.__contains__
+    def __contains__(self, o: Union[str, Text]) -> bool: ...  # type: ignore
+    def __eq__(self, x: object) -> bool: ...
+    def __ge__(self, x: Text) -> bool: ...
+    def __getitem__(self, i: Union[int, slice]) -> str: ...
+    def __gt__(self, x: Text) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __le__(self, x: Text) -> bool: ...
+    def __len__(self) -> int: ...
+    def __lt__(self, x: Text) -> bool: ...
+    def __mod__(self, x: Any) -> str: ...
+    def __mul__(self, n: int) -> str: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __rmul__(self, n: int) -> str: ...
+    def __str__(self) -> str: ...
+    def __getnewargs__(self) -> Tuple[str]: ...
+    def __getslice__(self, start: int, stop: int) -> str: ...
+    def __float__(self) -> float: ...
+    def __int__(self) -> int: ...
+
+bytes = str
+
+class bytearray(MutableSequence[int], ByteString):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, ints: Iterable[int]) -> None: ...
+    @overload
+    def __init__(self, string: str) -> None: ...
+    @overload
+    def __init__(self, string: Text, encoding: Text, errors: Text = ...) -> None: ...
+    @overload
+    def __init__(self, length: int) -> None: ...
+    def capitalize(self) -> bytearray: ...
+    def center(self, __width: int, __fillchar: bytes = ...) -> bytearray: ...
+    def count(self, __sub: str) -> int: ...
+    def decode(self, encoding: Text = ..., errors: Text = ...) -> str: ...
+    def endswith(self, __suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ...
+    def expandtabs(self, tabsize: int = ...) -> bytearray: ...
+    def extend(self, iterable: Union[str, Iterable[int]]) -> None: ...
+    def find(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ...
+    def index(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ...
+    def insert(self, __index: int, __item: int) -> None: ...
+    def isalnum(self) -> bool: ...
+    def isalpha(self) -> bool: ...
+    def isdigit(self) -> bool: ...
+    def islower(self) -> bool: ...
+    def isspace(self) -> bool: ...
+    def istitle(self) -> bool: ...
+    def isupper(self) -> bool: ...
+    def join(self, __iterable: Iterable[str]) -> bytearray: ...
+    def ljust(self, __width: int, __fillchar: str = ...) -> bytearray: ...
+    def lower(self) -> bytearray: ...
+    def lstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ...
+    def partition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ...
+    def replace(self, __old: bytes, __new: bytes, __count: int = ...) -> bytearray: ...
+    def rfind(self, __sub: bytes, __start: int = ..., __end: int = ...) -> int: ...
+    def rindex(self, __sub: bytes, __start: int = ..., __end: int = ...) -> int: ...
+    def rjust(self, __width: int, __fillchar: bytes = ...) -> bytearray: ...
+    def rpartition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ...
+    def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ...
+    def rstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ...
+    def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ...
+    def splitlines(self, keepends: bool = ...) -> List[bytearray]: ...
+    def startswith(
+        self, __prefix: Union[bytes, Tuple[bytes, ...]], __start: Optional[int] = ..., __end: Optional[int] = ...
+    ) -> bool: ...
+    def strip(self, __bytes: Optional[bytes] = ...) -> bytearray: ...
+    def swapcase(self) -> bytearray: ...
+    def title(self) -> bytearray: ...
+    def translate(self, __table: str) -> bytearray: ...
+    def upper(self) -> bytearray: ...
+    def zfill(self, __width: int) -> bytearray: ...
+    @classmethod
+    def fromhex(cls, __string: str) -> bytearray: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[int]: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    __hash__: None  # type: ignore
+    @overload
+    def __getitem__(self, i: int) -> int: ...
+    @overload
+    def __getitem__(self, s: slice) -> bytearray: ...
+    @overload
+    def __setitem__(self, i: int, x: int) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, x: Union[Iterable[int], bytes]) -> None: ...
+    def __delitem__(self, i: Union[int, slice]) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> bytearray: ...
+    def __setslice__(self, start: int, stop: int, x: Union[Sequence[int], str]) -> None: ...
+    def __delslice__(self, start: int, stop: int) -> None: ...
+    def __add__(self, s: bytes) -> bytearray: ...
+    def __mul__(self, n: int) -> bytearray: ...
+    # Incompatible with Sequence.__contains__
+    def __contains__(self, o: Union[int, bytes]) -> bool: ...  # type: ignore
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: bytes) -> bool: ...
+    def __le__(self, x: bytes) -> bool: ...
+    def __gt__(self, x: bytes) -> bool: ...
+    def __ge__(self, x: bytes) -> bool: ...
+
+class memoryview(Sized, Container[str]):
+    format: str
+    itemsize: int
+    shape: Optional[Tuple[int, ...]]
+    strides: Optional[Tuple[int, ...]]
+    suboffsets: Optional[Tuple[int, ...]]
+    readonly: bool
+    ndim: int
+    def __init__(self, obj: ReadableBuffer) -> None: ...
+    @overload
+    def __getitem__(self, i: int) -> str: ...
+    @overload
+    def __getitem__(self, s: slice) -> memoryview: ...
+    def __contains__(self, x: object) -> bool: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __len__(self) -> int: ...
+    @overload
+    def __setitem__(self, s: slice, o: memoryview) -> None: ...
+    @overload
+    def __setitem__(self, i: int, o: bytes) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ...
+    def tobytes(self) -> bytes: ...
+    def tolist(self) -> List[int]: ...
+
+class bool(int):
+    def __new__(cls: Type[_T], __o: object = ...) -> _T: ...
+    @overload
+    def __and__(self, x: bool) -> bool: ...
+    @overload
+    def __and__(self, x: int) -> int: ...
+    @overload
+    def __or__(self, x: bool) -> bool: ...
+    @overload
+    def __or__(self, x: int) -> int: ...
+    @overload
+    def __xor__(self, x: bool) -> bool: ...
+    @overload
+    def __xor__(self, x: int) -> int: ...
+    @overload
+    def __rand__(self, x: bool) -> bool: ...
+    @overload
+    def __rand__(self, x: int) -> int: ...
+    @overload
+    def __ror__(self, x: bool) -> bool: ...
+    @overload
+    def __ror__(self, x: int) -> int: ...
+    @overload
+    def __rxor__(self, x: bool) -> bool: ...
+    @overload
+    def __rxor__(self, x: int) -> int: ...
+    def __getnewargs__(self) -> Tuple[int]: ...
+
+class slice(object):
+    start: Any
+    step: Any
+    stop: Any
+    @overload
+    def __init__(self, stop: Any) -> None: ...
+    @overload
+    def __init__(self, start: Any, stop: Any, step: Any = ...) -> None: ...
+    __hash__: None  # type: ignore
+    def indices(self, len: int) -> Tuple[int, int, int]: ...
+
+class tuple(Sequence[_T_co], Generic[_T_co]):
+    def __new__(cls: Type[_T], iterable: Iterable[_T_co] = ...) -> _T: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, x: object) -> bool: ...
+    @overload
+    def __getitem__(self, x: int) -> _T_co: ...
+    @overload
+    def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ...
+    def __iter__(self) -> Iterator[_T_co]: ...
+    def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __le__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    @overload
+    def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ...
+    @overload
+    def __add__(self, x: Tuple[Any, ...]) -> Tuple[Any, ...]: ...
+    def __mul__(self, n: int) -> Tuple[_T_co, ...]: ...
+    def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ...
+    def count(self, __value: Any) -> int: ...
+    def index(self, __value: Any) -> int: ...
+
+class function:
+    # TODO not defined in builtins!
+    __name__: str
+    __module__: str
+    __code__: CodeType
+
+class list(MutableSequence[_T], Generic[_T]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, iterable: Iterable[_T]) -> None: ...
+    def append(self, __object: _T) -> None: ...
+    def extend(self, __iterable: Iterable[_T]) -> None: ...
+    def pop(self, __index: int = ...) -> _T: ...
+    def index(self, __value: _T, __start: int = ..., __stop: int = ...) -> int: ...
+    def count(self, __value: _T) -> int: ...
+    def insert(self, __index: int, __object: _T) -> None: ...
+    def remove(self, __value: _T) -> None: ...
+    def reverse(self) -> None: ...
+    def sort(self, cmp: Callable[[_T, _T], Any] = ..., key: Callable[[_T], Any] = ..., reverse: bool = ...) -> None: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __str__(self) -> str: ...
+    __hash__: None  # type: ignore
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice) -> List[_T]: ...
+    @overload
+    def __setitem__(self, i: int, o: _T) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
+    def __delitem__(self, i: Union[int, slice]) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> List[_T]: ...
+    def __setslice__(self, start: int, stop: int, o: Sequence[_T]) -> None: ...
+    def __delslice__(self, start: int, stop: int) -> None: ...
+    def __add__(self, x: List[_T]) -> List[_T]: ...
+    def __iadd__(self: _S, x: Iterable[_T]) -> _S: ...
+    def __mul__(self, n: int) -> List[_T]: ...
+    def __rmul__(self, n: int) -> List[_T]: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __reversed__(self) -> Iterator[_T]: ...
+    def __gt__(self, x: List[_T]) -> bool: ...
+    def __ge__(self, x: List[_T]) -> bool: ...
+    def __lt__(self, x: List[_T]) -> bool: ...
+    def __le__(self, x: List[_T]) -> bool: ...
+
+class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
+    # NOTE: Keyword arguments are special. If they are used, _KT must include
+    #       str, but we have no way of enforcing it here.
+    @overload
+    def __init__(self, **kwargs: _VT) -> None: ...
+    @overload
+    def __init__(self, map: SupportsKeysAndGetItem[_KT, _VT], **kwargs: _VT) -> None: ...
+    @overload
+    def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
+    def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ...
+    def has_key(self, k: _KT) -> bool: ...
+    def clear(self) -> None: ...
+    def copy(self) -> Dict[_KT, _VT]: ...
+    def popitem(self) -> Tuple[_KT, _VT]: ...
+    def setdefault(self, __key: _KT, __default: _VT = ...) -> _VT: ...
+    @overload
+    def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, **kwargs: _VT) -> None: ...
+    def iterkeys(self) -> Iterator[_KT]: ...
+    def itervalues(self) -> Iterator[_VT]: ...
+    def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ...
+    def viewkeys(self) -> KeysView[_KT]: ...
+    def viewvalues(self) -> ValuesView[_VT]: ...
+    def viewitems(self) -> ItemsView[_KT, _VT]: ...
+    @classmethod
+    @overload
+    def fromkeys(cls, __iterable: Iterable[_T]) -> Dict[_T, Any]: ...
+    @classmethod
+    @overload
+    def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> Dict[_T, _S]: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, k: _KT) -> _VT: ...
+    def __setitem__(self, k: _KT, v: _VT) -> None: ...
+    def __delitem__(self, v: _KT) -> None: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def __str__(self) -> str: ...
+    __hash__: None  # type: ignore
+
+class set(MutableSet[_T], Generic[_T]):
+    def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
+    def add(self, element: _T) -> None: ...
+    def clear(self) -> None: ...
+    def copy(self) -> Set[_T]: ...
+    def difference(self, *s: Iterable[Any]) -> Set[_T]: ...
+    def difference_update(self, *s: Iterable[Any]) -> None: ...
+    def discard(self, element: _T) -> None: ...
+    def intersection(self, *s: Iterable[Any]) -> Set[_T]: ...
+    def intersection_update(self, *s: Iterable[Any]) -> None: ...
+    def isdisjoint(self, s: Iterable[Any]) -> bool: ...
+    def issubset(self, s: Iterable[Any]) -> bool: ...
+    def issuperset(self, s: Iterable[Any]) -> bool: ...
+    def pop(self) -> _T: ...
+    def remove(self, element: _T) -> None: ...
+    def symmetric_difference(self, s: Iterable[_T]) -> Set[_T]: ...
+    def symmetric_difference_update(self, s: Iterable[_T]) -> None: ...
+    def union(self, *s: Iterable[_T]) -> Set[_T]: ...
+    def update(self, *s: Iterable[_T]) -> None: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __str__(self) -> str: ...
+    def __and__(self, s: AbstractSet[object]) -> Set[_T]: ...
+    def __iand__(self, s: AbstractSet[object]) -> Set[_T]: ...
+    def __or__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
+    def __ior__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
+    @overload
+    def __sub__(self: Set[str], s: AbstractSet[Optional[Text]]) -> Set[_T]: ...
+    @overload
+    def __sub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ...
+    @overload  # type: ignore
+    def __isub__(self: Set[str], s: AbstractSet[Optional[Text]]) -> Set[_T]: ...
+    @overload
+    def __isub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ...
+    def __xor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
+    def __ixor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
+    def __le__(self, s: AbstractSet[object]) -> bool: ...
+    def __lt__(self, s: AbstractSet[object]) -> bool: ...
+    def __ge__(self, s: AbstractSet[object]) -> bool: ...
+    def __gt__(self, s: AbstractSet[object]) -> bool: ...
+    __hash__: None  # type: ignore
+
+class frozenset(AbstractSet[_T_co], Generic[_T_co]):
+    def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ...
+    def copy(self) -> FrozenSet[_T_co]: ...
+    def difference(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ...
+    def intersection(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ...
+    def isdisjoint(self, s: Iterable[_T_co]) -> bool: ...
+    def issubset(self, s: Iterable[object]) -> bool: ...
+    def issuperset(self, s: Iterable[object]) -> bool: ...
+    def symmetric_difference(self, s: Iterable[_T_co]) -> FrozenSet[_T_co]: ...
+    def union(self, *s: Iterable[_T_co]) -> FrozenSet[_T_co]: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __iter__(self) -> Iterator[_T_co]: ...
+    def __str__(self) -> str: ...
+    def __and__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ...
+    def __or__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ...
+    def __sub__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ...
+    def __xor__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ...
+    def __le__(self, s: AbstractSet[object]) -> bool: ...
+    def __lt__(self, s: AbstractSet[object]) -> bool: ...
+    def __ge__(self, s: AbstractSet[object]) -> bool: ...
+    def __gt__(self, s: AbstractSet[object]) -> bool: ...
+
+class enumerate(Iterator[Tuple[int, _T]], Generic[_T]):
+    def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ...
+    def __iter__(self) -> Iterator[Tuple[int, _T]]: ...
+    def next(self) -> Tuple[int, _T]: ...
+
+class xrange(Sized, Iterable[int], Reversible[int]):
+    @overload
+    def __init__(self, stop: int) -> None: ...
+    @overload
+    def __init__(self, start: int, stop: int, step: int = ...) -> None: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[int]: ...
+    def __getitem__(self, i: int) -> int: ...
+    def __reversed__(self) -> Iterator[int]: ...
+
+class property(object):
+    def __init__(
+        self,
+        fget: Optional[Callable[[Any], Any]] = ...,
+        fset: Optional[Callable[[Any, Any], None]] = ...,
+        fdel: Optional[Callable[[Any], None]] = ...,
+        doc: Optional[str] = ...,
+    ) -> None: ...
+    def getter(self, fget: Callable[[Any], Any]) -> property: ...
+    def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
+    def deleter(self, fdel: Callable[[Any], None]) -> property: ...
+    def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ...
+    def __set__(self, obj: Any, value: Any) -> None: ...
+    def __delete__(self, obj: Any) -> None: ...
+    def fget(self) -> Any: ...
+    def fset(self, value: Any) -> None: ...
+    def fdel(self) -> None: ...
+
+long = int
+
+class _NotImplementedType(Any):  # type: ignore
+    # A little weird, but typing the __call__ as NotImplemented makes the error message
+    # for NotImplemented() much better
+    __call__: NotImplemented  # type: ignore
+
+NotImplemented: _NotImplementedType
+
+def abs(__x: SupportsAbs[_T]) -> _T: ...
+def all(__iterable: Iterable[object]) -> bool: ...
+def any(__iterable: Iterable[object]) -> bool: ...
+def apply(__func: Callable[..., _T], __args: Optional[Sequence[Any]] = ..., __kwds: Optional[Mapping[str, Any]] = ...) -> _T: ...
+def bin(__number: Union[int, _SupportsIndex]) -> str: ...
+def callable(__obj: object) -> bool: ...
+def chr(__i: int) -> str: ...
+def cmp(__x: Any, __y: Any) -> int: ...
+
+_N1 = TypeVar("_N1", bool, int, float, complex)
+
+def coerce(__x: _N1, __y: _N1) -> Tuple[_N1, _N1]: ...
+
+# This class is to be exported as PathLike from os,
+# but we define it here as _PathLike to avoid import cycle issues.
+# See https://github.com/python/typeshed/pull/991#issuecomment-288160993
+_AnyStr_co = TypeVar("_AnyStr_co", str, bytes, covariant=True)
+@runtime_checkable
+class _PathLike(Protocol[_AnyStr_co]):
+    def __fspath__(self) -> _AnyStr_co: ...
+
+def compile(source: Union[Text, mod], filename: Text, mode: Text, flags: int = ..., dont_inherit: int = ...) -> Any: ...
+def delattr(__obj: Any, __name: Text) -> None: ...
+def dir(__o: object = ...) -> List[str]: ...
+
+_N2 = TypeVar("_N2", int, float)
+
+def divmod(__x: _N2, __y: _N2) -> Tuple[_N2, _N2]: ...
+def eval(
+    __source: Union[Text, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ...
+) -> Any: ...
+def execfile(__filename: str, __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Dict[str, Any]] = ...) -> None: ...
+def exit(code: object = ...) -> NoReturn: ...
+@overload
+def filter(__function: Callable[[AnyStr], Any], __iterable: AnyStr) -> AnyStr: ...  # type: ignore
+@overload
+def filter(__function: None, __iterable: Tuple[Optional[_T], ...]) -> Tuple[_T, ...]: ...  # type: ignore
+@overload
+def filter(__function: Callable[[_T], Any], __iterable: Tuple[_T, ...]) -> Tuple[_T, ...]: ...  # type: ignore
+@overload
+def filter(__function: None, __iterable: Iterable[Optional[_T]]) -> List[_T]: ...
+@overload
+def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> List[_T]: ...
+def format(__value: object, __format_spec: str = ...) -> str: ...  # TODO unicode
+def getattr(__o: Any, name: Text, __default: Any = ...) -> Any: ...
+def globals() -> Dict[str, Any]: ...
+def hasattr(__obj: Any, __name: Text) -> bool: ...
+def hash(__obj: object) -> int: ...
+def hex(__number: Union[int, _SupportsIndex]) -> str: ...
+def id(__obj: object) -> int: ...
+def input(__prompt: Any = ...) -> Any: ...
+def intern(__string: str) -> str: ...
+@overload
+def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ...
+@overload
+def iter(__function: Callable[[], Optional[_T]], __sentinel: None) -> Iterator[_T]: ...
+@overload
+def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ...
+def isinstance(__obj: object, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ...
+def issubclass(__cls: type, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ...
+def len(__obj: Sized) -> int: ...
+def locals() -> Dict[str, Any]: ...
+@overload
+def map(__func: None, __iter1: Iterable[_T1]) -> List[_T1]: ...
+@overload
+def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
+@overload
+def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
+@overload
+def map(
+    __func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4]
+) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...
+@overload
+def map(
+    __func: None,
+    __iter1: Iterable[_T1],
+    __iter2: Iterable[_T2],
+    __iter3: Iterable[_T3],
+    __iter4: Iterable[_T4],
+    __iter5: Iterable[_T5],
+) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+@overload
+def map(
+    __func: None,
+    __iter1: Iterable[Any],
+    __iter2: Iterable[Any],
+    __iter3: Iterable[Any],
+    __iter4: Iterable[Any],
+    __iter5: Iterable[Any],
+    __iter6: Iterable[Any],
+    *iterables: Iterable[Any],
+) -> List[Tuple[Any, ...]]: ...
+@overload
+def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> List[_S]: ...
+@overload
+def map(__func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[_S]: ...
+@overload
+def map(
+    __func: Callable[[_T1, _T2, _T3], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]
+) -> List[_S]: ...
+@overload
+def map(
+    __func: Callable[[_T1, _T2, _T3, _T4], _S],
+    __iter1: Iterable[_T1],
+    __iter2: Iterable[_T2],
+    __iter3: Iterable[_T3],
+    __iter4: Iterable[_T4],
+) -> List[_S]: ...
+@overload
+def map(
+    __func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],
+    __iter1: Iterable[_T1],
+    __iter2: Iterable[_T2],
+    __iter3: Iterable[_T3],
+    __iter4: Iterable[_T4],
+    __iter5: Iterable[_T5],
+) -> List[_S]: ...
+@overload
+def map(
+    __func: Callable[..., _S],
+    __iter1: Iterable[Any],
+    __iter2: Iterable[Any],
+    __iter3: Iterable[Any],
+    __iter4: Iterable[Any],
+    __iter5: Iterable[Any],
+    __iter6: Iterable[Any],
+    *iterables: Iterable[Any],
+) -> List[_S]: ...
+@overload
+def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
+@overload
+def max(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
+@overload
+def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
+@overload
+def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
+@overload
+def next(__i: Iterator[_T]) -> _T: ...
+@overload
+def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ...
+def oct(__number: Union[int, _SupportsIndex]) -> str: ...
+def open(name: Union[unicode, int], mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...
+def ord(__c: Union[Text, bytes]) -> int: ...
+
+# This is only available after from __future__ import print_function.
+def print(
+    *values: object, sep: Optional[Text] = ..., end: Optional[Text] = ..., file: Optional[SupportsWrite[Any]] = ...
+) -> None: ...
+
+_E = TypeVar("_E", contravariant=True)
+_M = TypeVar("_M", contravariant=True)
+
+class _SupportsPow2(Protocol[_E, _T_co]):
+    def __pow__(self, __other: _E) -> _T_co: ...
+
+class _SupportsPow3(Protocol[_E, _M, _T_co]):
+    def __pow__(self, __other: _E, __modulo: _M) -> _T_co: ...
+
+@overload
+def pow(__base: int, __exp: int, __mod: None = ...) -> Any: ...  # returns int or float depending on whether exp is non-negative
+@overload
+def pow(__base: int, __exp: int, __mod: int) -> int: ...
+@overload
+def pow(__base: float, __exp: float, __mod: None = ...) -> float: ...
+@overload
+def pow(__base: _SupportsPow2[_E, _T_co], __exp: _E) -> _T_co: ...
+@overload
+def pow(__base: _SupportsPow3[_E, _M, _T_co], __exp: _E, __mod: _M) -> _T_co: ...
+def quit(code: object = ...) -> NoReturn: ...
+def range(__x: int, __y: int = ..., __step: int = ...) -> List[int]: ...  # noqa: F811
+def raw_input(__prompt: Any = ...) -> str: ...
+@overload
+def reduce(__function: Callable[[_T, _S], _T], __iterable: Iterable[_S], __initializer: _T) -> _T: ...
+@overload
+def reduce(__function: Callable[[_T, _T], _T], __iterable: Iterable[_T]) -> _T: ...
+def reload(__module: Any) -> Any: ...
+@overload
+def reversed(__sequence: Sequence[_T]) -> Iterator[_T]: ...
+@overload
+def reversed(__sequence: Reversible[_T]) -> Iterator[_T]: ...
+def repr(__obj: object) -> str: ...
+@overload
+def round(number: float) -> float: ...
+@overload
+def round(number: float, ndigits: int) -> float: ...
+@overload
+def round(number: SupportsFloat) -> float: ...
+@overload
+def round(number: SupportsFloat, ndigits: int) -> float: ...
+def setattr(__obj: Any, __name: Text, __value: Any) -> None: ...
+def sorted(
+    __iterable: Iterable[_T],
+    *,
+    cmp: Callable[[_T, _T], int] = ...,
+    key: Optional[Callable[[_T], Any]] = ...,
+    reverse: bool = ...,
+) -> List[_T]: ...
+@overload
+def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ...
+@overload
+def sum(__iterable: Iterable[_T], __start: _S) -> Union[_T, _S]: ...
+def unichr(__i: int) -> unicode: ...
+def vars(__object: Any = ...) -> Dict[str, Any]: ...
+@overload
+def zip(__iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ...
+@overload
+def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
+@overload
+def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
+@overload
+def zip(
+    __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4]
+) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...
+@overload
+def zip(
+    __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5]
+) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+@overload
+def zip(
+    __iter1: Iterable[Any],
+    __iter2: Iterable[Any],
+    __iter3: Iterable[Any],
+    __iter4: Iterable[Any],
+    __iter5: Iterable[Any],
+    __iter6: Iterable[Any],
+    *iterables: Iterable[Any],
+) -> List[Tuple[Any, ...]]: ...
+def __import__(
+    name: Text,
+    globals: Optional[Mapping[str, Any]] = ...,
+    locals: Optional[Mapping[str, Any]] = ...,
+    fromlist: Sequence[str] = ...,
+    level: int = ...,
+) -> Any: ...
+
+# Actually the type of Ellipsis is <type 'ellipsis'>, but since it's
+# not exposed anywhere under that name, we make it private here.
+class ellipsis: ...
+
+Ellipsis: ellipsis
+
+# TODO: buffer support is incomplete; e.g. some_string.startswith(some_buffer) doesn't type check.
+_AnyBuffer = TypeVar("_AnyBuffer", str, unicode, bytearray, buffer)
+
+class buffer(Sized):
+    def __init__(self, object: _AnyBuffer, offset: int = ..., size: int = ...) -> None: ...
+    def __add__(self, other: _AnyBuffer) -> str: ...
+    def __cmp__(self, other: _AnyBuffer) -> bool: ...
+    def __getitem__(self, key: Union[int, slice]) -> str: ...
+    def __getslice__(self, i: int, j: int) -> str: ...
+    def __len__(self) -> int: ...
+    def __mul__(self, x: int) -> str: ...
+
+class BaseException(object):
+    args: Tuple[Any, ...]
+    message: Any
+    def __init__(self, *args: object) -> None: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __getitem__(self, i: int) -> Any: ...
+    def __getslice__(self, start: int, stop: int) -> Tuple[Any, ...]: ...
+
+class GeneratorExit(BaseException): ...
+class KeyboardInterrupt(BaseException): ...
+
+class SystemExit(BaseException):
+    code: int
+
+class Exception(BaseException): ...
+class StopIteration(Exception): ...
+class StandardError(Exception): ...
+
+_StandardError = StandardError
+
+class EnvironmentError(StandardError):
+    errno: int
+    strerror: str
+    # TODO can this be unicode?
+    filename: str
+
+class OSError(EnvironmentError): ...
+class IOError(EnvironmentError): ...
+class ArithmeticError(_StandardError): ...
+class AssertionError(_StandardError): ...
+class AttributeError(_StandardError): ...
+class BufferError(_StandardError): ...
+class EOFError(_StandardError): ...
+class ImportError(_StandardError): ...
+class LookupError(_StandardError): ...
+class MemoryError(_StandardError): ...
+class NameError(_StandardError): ...
+class ReferenceError(_StandardError): ...
+class RuntimeError(_StandardError): ...
+
+class SyntaxError(_StandardError):
+    msg: str
+    lineno: Optional[int]
+    offset: Optional[int]
+    text: Optional[str]
+    filename: Optional[str]
+
+class SystemError(_StandardError): ...
+class TypeError(_StandardError): ...
+class ValueError(_StandardError): ...
+class FloatingPointError(ArithmeticError): ...
+class OverflowError(ArithmeticError): ...
+class ZeroDivisionError(ArithmeticError): ...
+class IndexError(LookupError): ...
+class KeyError(LookupError): ...
+class UnboundLocalError(NameError): ...
+
+class WindowsError(OSError):
+    winerror: int
+
+class NotImplementedError(RuntimeError): ...
+class IndentationError(SyntaxError): ...
+class TabError(IndentationError): ...
+class UnicodeError(ValueError): ...
+
+class UnicodeDecodeError(UnicodeError):
+    encoding: str
+    object: bytes
+    start: int
+    end: int
+    reason: str
+    def __init__(self, __encoding: str, __object: bytes, __start: int, __end: int, __reason: str) -> None: ...
+
+class UnicodeEncodeError(UnicodeError):
+    encoding: str
+    object: Text
+    start: int
+    end: int
+    reason: str
+    def __init__(self, __encoding: str, __object: Text, __start: int, __end: int, __reason: str) -> None: ...
+
+class UnicodeTranslateError(UnicodeError): ...
+class Warning(Exception): ...
+class UserWarning(Warning): ...
+class DeprecationWarning(Warning): ...
+class SyntaxWarning(Warning): ...
+class RuntimeWarning(Warning): ...
+class FutureWarning(Warning): ...
+class PendingDeprecationWarning(Warning): ...
+class ImportWarning(Warning): ...
+class UnicodeWarning(Warning): ...
+class BytesWarning(Warning): ...
+
+class file(BinaryIO):
+    @overload
+    def __init__(self, file: str, mode: str = ..., buffering: int = ...) -> None: ...
+    @overload
+    def __init__(self, file: unicode, mode: str = ..., buffering: int = ...) -> None: ...
+    @overload
+    def __init__(self, file: int, mode: str = ..., buffering: int = ...) -> None: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def next(self) -> str: ...
+    def read(self, n: int = ...) -> str: ...
+    def __enter__(self) -> BinaryIO: ...
+    def __exit__(
+        self, t: Optional[type] = ..., exc: Optional[BaseException] = ..., tb: Optional[Any] = ...
+    ) -> Optional[bool]: ...
+    def flush(self) -> None: ...
+    def fileno(self) -> int: ...
+    def isatty(self) -> bool: ...
+    def close(self) -> None: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def seek(self, offset: int, whence: int = ...) -> int: ...
+    def tell(self) -> int: ...
+    def readline(self, limit: int = ...) -> str: ...
+    def readlines(self, hint: int = ...) -> List[str]: ...
+    def write(self, data: str) -> int: ...
+    def writelines(self, data: Iterable[str]) -> None: ...
+    def truncate(self, pos: Optional[int] = ...) -> int: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/ast.pyi

@@ -0,0 +1,28 @@
+# Python 2.7 ast
+
+# Rename typing to _typing, as not to conflict with typing imported
+# from _ast below when loaded in an unorthodox way by the Dropbox
+# internal Bazel integration.
+import typing as _typing
+from typing import Any, Iterator, Optional, Union
+
+from _ast import *
+from _ast import AST, Module
+
+def parse(source: Union[str, unicode], filename: Union[str, unicode] = ..., mode: Union[str, unicode] = ...) -> Module: ...
+def copy_location(new_node: AST, old_node: AST) -> AST: ...
+def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ...
+def fix_missing_locations(node: AST) -> AST: ...
+def get_docstring(node: AST, clean: bool = ...) -> str: ...
+def increment_lineno(node: AST, n: int = ...) -> AST: ...
+def iter_child_nodes(node: AST) -> Iterator[AST]: ...
+def iter_fields(node: AST) -> Iterator[_typing.Tuple[str, Any]]: ...
+def literal_eval(node_or_string: Union[str, unicode, AST]) -> Any: ...
+def walk(node: AST) -> Iterator[AST]: ...
+
+class NodeVisitor:
+    def visit(self, node: AST) -> Any: ...
+    def generic_visit(self, node: AST) -> Any: ...
+
+class NodeTransformer(NodeVisitor):
+    def generic_visit(self, node: AST) -> Optional[AST]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/collections.pyi

@@ -0,0 +1,129 @@
+from typing import (
+    AbstractSet,
+    Any,
+    Callable as Callable,
+    Container as Container,
+    Dict,
+    Generic,
+    Hashable as Hashable,
+    ItemsView as ItemsView,
+    Iterable as Iterable,
+    Iterator as Iterator,
+    KeysView as KeysView,
+    List,
+    Mapping as Mapping,
+    MappingView as MappingView,
+    MutableMapping as MutableMapping,
+    MutableSequence as MutableSequence,
+    MutableSet as MutableSet,
+    Optional,
+    Reversible,
+    Sequence as Sequence,
+    Sized as Sized,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    ValuesView as ValuesView,
+    overload,
+)
+
+Set = AbstractSet
+
+_S = TypeVar("_S")
+_T = TypeVar("_T")
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+# namedtuple is special-cased in the type checker; the initializer is ignored.
+def namedtuple(
+    typename: Union[str, unicode],
+    field_names: Union[str, unicode, Iterable[Union[str, unicode]]],
+    verbose: bool = ...,
+    rename: bool = ...,
+) -> Type[Tuple[Any, ...]]: ...
+
+class deque(Sized, Iterable[_T], Reversible[_T], Generic[_T]):
+    def __init__(self, iterable: Iterable[_T] = ..., maxlen: int = ...) -> None: ...
+    @property
+    def maxlen(self) -> Optional[int]: ...
+    def append(self, x: _T) -> None: ...
+    def appendleft(self, x: _T) -> None: ...
+    def clear(self) -> None: ...
+    def count(self, x: _T) -> int: ...
+    def extend(self, iterable: Iterable[_T]) -> None: ...
+    def extendleft(self, iterable: Iterable[_T]) -> None: ...
+    def pop(self) -> _T: ...
+    def popleft(self) -> _T: ...
+    def remove(self, value: _T) -> None: ...
+    def reverse(self) -> None: ...
+    def rotate(self, n: int = ...) -> None: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __str__(self) -> str: ...
+    def __hash__(self) -> int: ...
+    def __getitem__(self, i: int) -> _T: ...
+    def __setitem__(self, i: int, x: _T) -> None: ...
+    def __contains__(self, o: _T) -> bool: ...
+    def __reversed__(self) -> Iterator[_T]: ...
+    def __iadd__(self: _S, iterable: Iterable[_T]) -> _S: ...
+
+class Counter(Dict[_T, int], Generic[_T]):
+    @overload
+    def __init__(self, **kwargs: int) -> None: ...
+    @overload
+    def __init__(self, mapping: Mapping[_T, int]) -> None: ...
+    @overload
+    def __init__(self, iterable: Iterable[_T]) -> None: ...
+    def copy(self: _S) -> _S: ...
+    def elements(self) -> Iterator[_T]: ...
+    def most_common(self, n: Optional[int] = ...) -> List[Tuple[_T, int]]: ...
+    @overload
+    def subtract(self, __mapping: Mapping[_T, int]) -> None: ...
+    @overload
+    def subtract(self, iterable: Iterable[_T]) -> None: ...
+    # The Iterable[Tuple[...]] argument type is not actually desirable
+    # (the tuples will be added as keys, breaking type safety) but
+    # it's included so that the signature is compatible with
+    # Dict.update. Not sure if we should use '# type: ignore' instead
+    # and omit the type from the union.
+    @overload
+    def update(self, __m: Mapping[_T, int], **kwargs: int) -> None: ...
+    @overload
+    def update(self, __m: Union[Iterable[_T], Iterable[Tuple[_T, int]]], **kwargs: int) -> None: ...
+    @overload
+    def update(self, **kwargs: int) -> None: ...
+    def __add__(self, other: Counter[_T]) -> Counter[_T]: ...
+    def __sub__(self, other: Counter[_T]) -> Counter[_T]: ...
+    def __and__(self, other: Counter[_T]) -> Counter[_T]: ...
+    def __or__(self, other: Counter[_T]) -> Counter[_T]: ...
+    def __iadd__(self, other: Counter[_T]) -> Counter[_T]: ...
+    def __isub__(self, other: Counter[_T]) -> Counter[_T]: ...
+    def __iand__(self, other: Counter[_T]) -> Counter[_T]: ...
+    def __ior__(self, other: Counter[_T]) -> Counter[_T]: ...
+
+class OrderedDict(Dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]):
+    def popitem(self, last: bool = ...) -> Tuple[_KT, _VT]: ...
+    def copy(self: _S) -> _S: ...
+    def __reversed__(self) -> Iterator[_KT]: ...
+
+class defaultdict(Dict[_KT, _VT], Generic[_KT, _VT]):
+    default_factory: Callable[[], _VT]
+    @overload
+    def __init__(self, **kwargs: _VT) -> None: ...
+    @overload
+    def __init__(self, default_factory: Optional[Callable[[], _VT]]) -> None: ...
+    @overload
+    def __init__(self, default_factory: Optional[Callable[[], _VT]], **kwargs: _VT) -> None: ...
+    @overload
+    def __init__(self, default_factory: Optional[Callable[[], _VT]], map: Mapping[_KT, _VT]) -> None: ...
+    @overload
+    def __init__(self, default_factory: Optional[Callable[[], _VT]], map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
+    @overload
+    def __init__(self, default_factory: Optional[Callable[[], _VT]], iterable: Iterable[Tuple[_KT, _VT]]) -> None: ...
+    @overload
+    def __init__(
+        self, default_factory: Optional[Callable[[], _VT]], iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT
+    ) -> None: ...
+    def __missing__(self, key: _KT) -> _VT: ...
+    def copy(self: _S) -> _S: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/commands.pyi

@@ -0,0 +1,10 @@
+from typing import AnyStr, Text, Tuple, overload
+
+def getstatus(file: Text) -> str: ...
+def getoutput(cmd: Text) -> str: ...
+def getstatusoutput(cmd: Text) -> Tuple[int, str]: ...
+@overload
+def mk2arg(head: bytes, x: bytes) -> bytes: ...
+@overload
+def mk2arg(head: Text, x: Text) -> Text: ...
+def mkarg(x: AnyStr) -> AnyStr: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/compileall.pyi

@@ -0,0 +1,16 @@
+from _typeshed import AnyPath
+from typing import Any, Optional, Pattern
+
+# rx can be any object with a 'search' method; once we have Protocols we can change the type
+def compile_dir(
+    dir: AnyPath,
+    maxlevels: int = ...,
+    ddir: Optional[AnyPath] = ...,
+    force: bool = ...,
+    rx: Optional[Pattern[Any]] = ...,
+    quiet: int = ...,
+) -> int: ...
+def compile_file(
+    fullname: AnyPath, ddir: Optional[AnyPath] = ..., force: bool = ..., rx: Optional[Pattern[Any]] = ..., quiet: int = ...
+) -> int: ...
+def compile_path(skip_curdir: bool = ..., maxlevels: int = ..., force: bool = ..., quiet: int = ...) -> int: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_msi.pyi

@@ -0,0 +1,6 @@
+from distutils.cmd import Command
+
+class bdist_msi(Command):
+    def initialize_options(self) -> None: ...
+    def finalize_options(self) -> None: ...
+    def run(self) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/__init__.pyi

@@ -0,0 +1,6 @@
+from typing import IO, Any, AnyStr
+
+def message_from_string(s: AnyStr, *args, **kwargs): ...
+def message_from_bytes(s: str, *args, **kwargs): ...
+def message_from_file(fp: IO[AnyStr], *args, **kwargs): ...
+def message_from_binary_file(fp: IO[str], *args, **kwargs): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/_parseaddr.pyi

@@ -0,0 +1,40 @@
+from typing import Any, Optional
+
+def parsedate_tz(data): ...
+def parsedate(data): ...
+def mktime_tz(data): ...
+def quote(str): ...
+
+class AddrlistClass:
+    specials: Any
+    pos: Any
+    LWS: Any
+    CR: Any
+    FWS: Any
+    atomends: Any
+    phraseends: Any
+    field: Any
+    commentlist: Any
+    def __init__(self, field): ...
+    def gotonext(self): ...
+    def getaddrlist(self): ...
+    def getaddress(self): ...
+    def getrouteaddr(self): ...
+    def getaddrspec(self): ...
+    def getdomain(self): ...
+    def getdelimited(self, beginchar, endchars, allowcomments: bool = ...): ...
+    def getquote(self): ...
+    def getcomment(self): ...
+    def getdomainliteral(self): ...
+    def getatom(self, atomends: Optional[Any] = ...): ...
+    def getphraselist(self): ...
+
+class AddressList(AddrlistClass):
+    addresslist: Any
+    def __init__(self, field): ...
+    def __len__(self): ...
+    def __add__(self, other): ...
+    def __iadd__(self, other): ...
+    def __sub__(self, other): ...
+    def __isub__(self, other): ...
+    def __getitem__(self, index): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/base64mime.pyi

@@ -0,0 +1,11 @@
+def base64_len(s: bytes) -> int: ...
+def header_encode(header, charset=..., keep_eols=..., maxlinelen=..., eol=...): ...
+def encode(s, binary=..., maxlinelen=..., eol=...): ...
+
+body_encode = encode
+encodestring = encode
+
+def decode(s, convert_eols=...): ...
+
+body_decode = decode
+decodestring = decode

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/charset.pyi

@@ -0,0 +1,26 @@
+def add_charset(charset, header_enc=..., body_enc=..., output_charset=...) -> None: ...
+def add_alias(alias, canonical) -> None: ...
+def add_codec(charset, codecname) -> None: ...
+
+QP: int  # undocumented
+BASE64: int  # undocumented
+SHORTEST: int  # undocumented
+
+class Charset:
+    input_charset = ...
+    header_encoding = ...
+    body_encoding = ...
+    output_charset = ...
+    input_codec = ...
+    output_codec = ...
+    def __init__(self, input_charset=...) -> None: ...
+    def __eq__(self, other): ...
+    def __ne__(self, other): ...
+    def get_body_encoding(self): ...
+    def convert(self, s): ...
+    def to_splittable(self, s): ...
+    def from_splittable(self, ustr, to_output: bool = ...): ...
+    def get_output_charset(self): ...
+    def encoded_header_len(self, s): ...
+    def header_encode(self, s, convert: bool = ...): ...
+    def body_encode(self, s, convert: bool = ...): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/feedparser.pyi

@@ -0,0 +1,17 @@
+class BufferedSubFile:
+    def __init__(self) -> None: ...
+    def push_eof_matcher(self, pred) -> None: ...
+    def pop_eof_matcher(self): ...
+    def close(self) -> None: ...
+    def readline(self): ...
+    def unreadline(self, line) -> None: ...
+    def push(self, data): ...
+    def pushlines(self, lines) -> None: ...
+    def is_closed(self): ...
+    def __iter__(self): ...
+    def next(self): ...
+
+class FeedParser:
+    def __init__(self, _factory=...) -> None: ...
+    def feed(self, data) -> None: ...
+    def close(self): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/header.pyi

@@ -0,0 +1,10 @@
+def decode_header(header): ...
+def make_header(decoded_seq, maxlinelen=..., header_name=..., continuation_ws=...): ...
+
+class Header:
+    def __init__(self, s=..., charset=..., maxlinelen=..., header_name=..., continuation_ws=..., errors=...) -> None: ...
+    def __unicode__(self): ...
+    def __eq__(self, other): ...
+    def __ne__(self, other): ...
+    def append(self, s, charset=..., errors=...) -> None: ...
+    def encode(self, splitchars=...): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/message.pyi

@@ -0,0 +1,45 @@
+from typing import Any, Generator
+
+class Message:
+    preamble = ...
+    epilogue = ...
+    defects = ...
+    def __init__(self): ...
+    def as_string(self, unixfrom=...): ...
+    def is_multipart(self) -> bool: ...
+    def set_unixfrom(self, unixfrom) -> None: ...
+    def get_unixfrom(self): ...
+    def attach(self, payload) -> None: ...
+    def get_payload(self, i=..., decode: bool = ...): ...
+    def set_payload(self, payload, charset=...) -> None: ...
+    def set_charset(self, charset): ...
+    def get_charset(self): ...
+    def __len__(self): ...
+    def __getitem__(self, name): ...
+    def __setitem__(self, name, val) -> None: ...
+    def __delitem__(self, name) -> None: ...
+    def __contains__(self, name): ...
+    def has_key(self, name) -> bool: ...
+    def keys(self): ...
+    def values(self): ...
+    def items(self): ...
+    def get(self, name, failobj=...): ...
+    def get_all(self, name, failobj=...): ...
+    def add_header(self, _name, _value, **_params) -> None: ...
+    def replace_header(self, _name, _value) -> None: ...
+    def get_content_type(self): ...
+    def get_content_maintype(self): ...
+    def get_content_subtype(self): ...
+    def get_default_type(self): ...
+    def set_default_type(self, ctype) -> None: ...
+    def get_params(self, failobj=..., header=..., unquote: bool = ...): ...
+    def get_param(self, param, failobj=..., header=..., unquote: bool = ...): ...
+    def set_param(self, param, value, header=..., requote: bool = ..., charset=..., language=...) -> None: ...
+    def del_param(self, param, header=..., requote: bool = ...): ...
+    def set_type(self, type, header=..., requote: bool = ...): ...
+    def get_filename(self, failobj=...): ...
+    def get_boundary(self, failobj=...): ...
+    def set_boundary(self, boundary) -> None: ...
+    def get_content_charset(self, failobj=...): ...
+    def get_charsets(self, failobj=...): ...
+    def walk(self) -> Generator[Any, Any, Any]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/parser.pyi

@@ -0,0 +1,10 @@
+from .feedparser import FeedParser as FeedParser  # not in __all__ but listed in documentation
+
+class Parser:
+    def __init__(self, *args, **kws) -> None: ...
+    def parse(self, fp, headersonly: bool = ...): ...
+    def parsestr(self, text, headersonly: bool = ...): ...
+
+class HeaderParser(Parser):
+    def parse(self, fp, headersonly: bool = ...): ...
+    def parsestr(self, text, headersonly: bool = ...): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/quoprimime.pyi

@@ -0,0 +1,18 @@
+def header_quopri_check(c): ...
+def body_quopri_check(c): ...
+def header_quopri_len(s): ...
+def body_quopri_len(str): ...
+def unquote(s): ...
+def quote(c): ...
+def header_encode(header, charset: str = ..., keep_eols: bool = ..., maxlinelen: int = ..., eol=...): ...
+def encode(body, binary: bool = ..., maxlinelen: int = ..., eol=...): ...
+
+body_encode = encode
+encodestring = encode
+
+def decode(encoded, eol=...): ...
+
+body_decode = decode
+decodestring = decode
+
+def header_decode(s): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/email/utils.pyi

@@ -0,0 +1,21 @@
+from email._parseaddr import (
+    AddressList as _AddressList,
+    mktime_tz as mktime_tz,
+    parsedate as _parsedate,
+    parsedate_tz as _parsedate_tz,
+)
+from quopri import decodestring as _qdecode
+from typing import Any, Optional
+
+def formataddr(pair): ...
+def getaddresses(fieldvalues): ...
+def formatdate(timeval: Optional[Any] = ..., localtime: bool = ..., usegmt: bool = ...): ...
+def make_msgid(idstring: Optional[Any] = ...): ...
+def parsedate(data): ...
+def parsedate_tz(data): ...
+def parseaddr(addr): ...
+def unquote(str): ...
+def decode_rfc2231(s): ...
+def encode_rfc2231(s, charset: Optional[Any] = ..., language: Optional[Any] = ...): ...
+def decode_params(params): ...
+def collapse_rfc2231_value(value, errors=..., fallback_charset=...): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/httplib.pyi

@@ -0,0 +1,218 @@
+import mimetools
+import ssl
+from typing import Any, Dict, Optional, Protocol
+
+class HTTPMessage(mimetools.Message):
+    def addcontinue(self, key: str, more: str) -> None: ...
+    dict: Dict[str, str]
+    def addheader(self, key: str, value: str) -> None: ...
+    unixfrom: str
+    headers: Any
+    status: str
+    seekable: bool
+    def readheaders(self) -> None: ...
+
+class HTTPResponse:
+    fp: Any
+    debuglevel: Any
+    strict: Any
+    msg: Any
+    version: Any
+    status: Any
+    reason: Any
+    chunked: Any
+    chunk_left: Any
+    length: Any
+    will_close: Any
+    def __init__(
+        self, sock, debuglevel: int = ..., strict: int = ..., method: Optional[Any] = ..., buffering: bool = ...
+    ) -> None: ...
+    def begin(self): ...
+    def close(self): ...
+    def isclosed(self): ...
+    def read(self, amt: Optional[Any] = ...): ...
+    def fileno(self): ...
+    def getheader(self, name, default: Optional[Any] = ...): ...
+    def getheaders(self): ...
+
+# This is an API stub only for HTTPConnection and HTTPSConnection, as used in
+# urllib2.AbstractHTTPHandler.do_open, which takes either the class
+# HTTPConnection or the class HTTPSConnection, *not* an instance of either
+# class. do_open does not use all of the parameters of HTTPConnection.__init__
+# or HTTPSConnection.__init__, so HTTPConnectionProtocol only implements the
+# parameters that do_open does use.
+class HTTPConnectionProtocol(Protocol):
+    def __call__(self, host: str, timeout: int = ..., **http_con_args: Any) -> HTTPConnection: ...
+
+class HTTPConnection:
+    response_class: Any
+    default_port: Any
+    auto_open: Any
+    debuglevel: Any
+    strict: Any
+    timeout: Any
+    source_address: Any
+    sock: Any
+    host: str = ...
+    port: int = ...
+    def __init__(
+        self, host, port: Optional[Any] = ..., strict: Optional[Any] = ..., timeout=..., source_address: Optional[Any] = ...
+    ) -> None: ...
+    def set_tunnel(self, host, port: Optional[Any] = ..., headers: Optional[Any] = ...): ...
+    def set_debuglevel(self, level): ...
+    def connect(self): ...
+    def close(self): ...
+    def send(self, data): ...
+    def putrequest(self, method, url, skip_host: int = ..., skip_accept_encoding: int = ...): ...
+    def putheader(self, header, *values): ...
+    def endheaders(self, message_body: Optional[Any] = ...): ...
+    def request(self, method, url, body: Optional[Any] = ..., headers=...): ...
+    def getresponse(self, buffering: bool = ...): ...
+
+class HTTP:
+    debuglevel: Any
+    def __init__(self, host: str = ..., port: Optional[Any] = ..., strict: Optional[Any] = ...) -> None: ...
+    def connect(self, host: Optional[Any] = ..., port: Optional[Any] = ...): ...
+    def getfile(self): ...
+    file: Any
+    headers: Any
+    def getreply(self, buffering: bool = ...): ...
+    def close(self): ...
+
+class HTTPSConnection(HTTPConnection):
+    default_port: Any
+    key_file: Any
+    cert_file: Any
+    def __init__(
+        self,
+        host,
+        port: Optional[Any] = ...,
+        key_file: Optional[Any] = ...,
+        cert_file: Optional[Any] = ...,
+        strict: Optional[Any] = ...,
+        timeout=...,
+        source_address: Optional[Any] = ...,
+        context: Optional[Any] = ...,
+    ) -> None: ...
+    sock: Any
+    def connect(self): ...
+
+class HTTPS(HTTP):
+    key_file: Any
+    cert_file: Any
+    def __init__(
+        self,
+        host: str = ...,
+        port: Optional[Any] = ...,
+        key_file: Optional[Any] = ...,
+        cert_file: Optional[Any] = ...,
+        strict: Optional[Any] = ...,
+        context: Optional[Any] = ...,
+    ) -> None: ...
+
+class HTTPException(Exception): ...
+class NotConnected(HTTPException): ...
+class InvalidURL(HTTPException): ...
+
+class UnknownProtocol(HTTPException):
+    args: Any
+    version: Any
+    def __init__(self, version) -> None: ...
+
+class UnknownTransferEncoding(HTTPException): ...
+class UnimplementedFileMode(HTTPException): ...
+
+class IncompleteRead(HTTPException):
+    args: Any
+    partial: Any
+    expected: Any
+    def __init__(self, partial, expected: Optional[Any] = ...) -> None: ...
+
+class ImproperConnectionState(HTTPException): ...
+class CannotSendRequest(ImproperConnectionState): ...
+class CannotSendHeader(ImproperConnectionState): ...
+class ResponseNotReady(ImproperConnectionState): ...
+
+class BadStatusLine(HTTPException):
+    args: Any
+    line: Any
+    def __init__(self, line) -> None: ...
+
+class LineTooLong(HTTPException):
+    def __init__(self, line_type) -> None: ...
+
+error: Any
+
+class LineAndFileWrapper:
+    def __init__(self, line, file) -> None: ...
+    def __getattr__(self, attr): ...
+    def read(self, amt: Optional[Any] = ...): ...
+    def readline(self): ...
+    def readlines(self, size: Optional[Any] = ...): ...
+
+# Constants
+
+responses: Dict[int, str]
+
+HTTP_PORT: int
+HTTPS_PORT: int
+
+# status codes
+# informational
+CONTINUE: int
+SWITCHING_PROTOCOLS: int
+PROCESSING: int
+
+# successful
+OK: int
+CREATED: int
+ACCEPTED: int
+NON_AUTHORITATIVE_INFORMATION: int
+NO_CONTENT: int
+RESET_CONTENT: int
+PARTIAL_CONTENT: int
+MULTI_STATUS: int
+IM_USED: int
+
+# redirection
+MULTIPLE_CHOICES: int
+MOVED_PERMANENTLY: int
+FOUND: int
+SEE_OTHER: int
+NOT_MODIFIED: int
+USE_PROXY: int
+TEMPORARY_REDIRECT: int
+
+# client error
+BAD_REQUEST: int
+UNAUTHORIZED: int
+PAYMENT_REQUIRED: int
+FORBIDDEN: int
+NOT_FOUND: int
+METHOD_NOT_ALLOWED: int
+NOT_ACCEPTABLE: int
+PROXY_AUTHENTICATION_REQUIRED: int
+REQUEST_TIMEOUT: int
+CONFLICT: int
+GONE: int
+LENGTH_REQUIRED: int
+PRECONDITION_FAILED: int
+REQUEST_ENTITY_TOO_LARGE: int
+REQUEST_URI_TOO_LONG: int
+UNSUPPORTED_MEDIA_TYPE: int
+REQUESTED_RANGE_NOT_SATISFIABLE: int
+EXPECTATION_FAILED: int
+UNPROCESSABLE_ENTITY: int
+LOCKED: int
+FAILED_DEPENDENCY: int
+UPGRADE_REQUIRED: int
+
+# server error
+INTERNAL_SERVER_ERROR: int
+NOT_IMPLEMENTED: int
+BAD_GATEWAY: int
+SERVICE_UNAVAILABLE: int
+GATEWAY_TIMEOUT: int
+HTTP_VERSION_NOT_SUPPORTED: int
+INSUFFICIENT_STORAGE: int
+NOT_EXTENDED: int

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/itertools.pyi

@@ -0,0 +1,164 @@
+from typing import Any, Callable, Generic, Iterable, Iterator, Optional, Sequence, Tuple, TypeVar, Union, overload
+
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+
+def count(start: int = ..., step: int = ...) -> Iterator[int]: ...  # more general types?
+
+class cycle(Iterator[_T], Generic[_T]):
+    def __init__(self, iterable: Iterable[_T]) -> None: ...
+    def next(self) -> _T: ...
+    def __iter__(self) -> Iterator[_T]: ...
+
+def repeat(object: _T, times: int = ...) -> Iterator[_T]: ...
+
+class chain(Iterator[_T], Generic[_T]):
+    def __init__(self, *iterables: Iterable[_T]) -> None: ...
+    def next(self) -> _T: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    @staticmethod
+    def from_iterable(iterable: Iterable[Iterable[_S]]) -> Iterator[_S]: ...
+
+def compress(data: Iterable[_T], selectors: Iterable[Any]) -> Iterator[_T]: ...
+def dropwhile(predicate: Callable[[_T], Any], iterable: Iterable[_T]) -> Iterator[_T]: ...
+def ifilter(predicate: Optional[Callable[[_T], Any]], iterable: Iterable[_T]) -> Iterator[_T]: ...
+def ifilterfalse(predicate: Optional[Callable[[_T], Any]], iterable: Iterable[_T]) -> Iterator[_T]: ...
+@overload
+def groupby(iterable: Iterable[_T], key: None = ...) -> Iterator[Tuple[_T, Iterator[_T]]]: ...
+@overload
+def groupby(iterable: Iterable[_T], key: Callable[[_T], _S]) -> Iterator[Tuple[_S, Iterator[_T]]]: ...
+@overload
+def islice(iterable: Iterable[_T], stop: Optional[int]) -> Iterator[_T]: ...
+@overload
+def islice(iterable: Iterable[_T], start: Optional[int], stop: Optional[int], step: Optional[int] = ...) -> Iterator[_T]: ...
+
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+_T4 = TypeVar("_T4")
+_T5 = TypeVar("_T5")
+_T6 = TypeVar("_T6")
+@overload
+def imap(func: Callable[[_T1], _S], iter1: Iterable[_T1]) -> Iterator[_S]: ...
+@overload
+def imap(func: Callable[[_T1, _T2], _S], iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[_S]: ...
+@overload
+def imap(
+    func: Callable[[_T1, _T2, _T3], _S], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3]
+) -> Iterator[_S]: ...
+@overload
+def imap(
+    func: Callable[[_T1, _T2, _T3, _T4], _S],
+    iter1: Iterable[_T1],
+    iter2: Iterable[_T2],
+    iter3: Iterable[_T3],
+    iter4: Iterable[_T4],
+) -> Iterator[_S]: ...
+@overload
+def imap(
+    func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],
+    iter1: Iterable[_T1],
+    iter2: Iterable[_T2],
+    iter3: Iterable[_T3],
+    iter4: Iterable[_T4],
+    iter5: Iterable[_T5],
+) -> Iterator[_S]: ...
+@overload
+def imap(
+    func: Callable[[_T1, _T2, _T3, _T4, _T5, _T6], _S],
+    iter1: Iterable[_T1],
+    iter2: Iterable[_T2],
+    iter3: Iterable[_T3],
+    iter4: Iterable[_T4],
+    iter5: Iterable[_T5],
+    iter6: Iterable[_T6],
+) -> Iterator[_S]: ...
+@overload
+def imap(
+    func: Callable[..., _S],
+    iter1: Iterable[Any],
+    iter2: Iterable[Any],
+    iter3: Iterable[Any],
+    iter4: Iterable[Any],
+    iter5: Iterable[Any],
+    iter6: Iterable[Any],
+    iter7: Iterable[Any],
+    *iterables: Iterable[Any],
+) -> Iterator[_S]: ...
+def starmap(func: Any, iterable: Iterable[Any]) -> Iterator[Any]: ...
+def takewhile(predicate: Callable[[_T], Any], iterable: Iterable[_T]) -> Iterator[_T]: ...
+def tee(iterable: Iterable[_T], n: int = ...) -> Tuple[Iterator[_T], ...]: ...
+@overload
+def izip(iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...
+@overload
+def izip(iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...
+@overload
+def izip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ...
+@overload
+def izip(
+    iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4]
+) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ...
+@overload
+def izip(
+    iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5]
+) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+@overload
+def izip(
+    iter1: Iterable[_T1],
+    iter2: Iterable[_T2],
+    iter3: Iterable[_T3],
+    iter4: Iterable[_T4],
+    iter5: Iterable[_T5],
+    iter6: Iterable[_T6],
+) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
+@overload
+def izip(
+    iter1: Iterable[Any],
+    iter2: Iterable[Any],
+    iter3: Iterable[Any],
+    iter4: Iterable[Any],
+    iter5: Iterable[Any],
+    iter6: Iterable[Any],
+    iter7: Iterable[Any],
+    *iterables: Iterable[Any],
+) -> Iterator[Tuple[Any, ...]]: ...
+def izip_longest(*p: Iterable[Any], fillvalue: Any = ...) -> Iterator[Any]: ...
+@overload
+def product(iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...
+@overload
+def product(iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...
+@overload
+def product(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ...
+@overload
+def product(
+    iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4]
+) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ...
+@overload
+def product(
+    iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5]
+) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+@overload
+def product(
+    iter1: Iterable[_T1],
+    iter2: Iterable[_T2],
+    iter3: Iterable[_T3],
+    iter4: Iterable[_T4],
+    iter5: Iterable[_T5],
+    iter6: Iterable[_T6],
+) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
+@overload
+def product(
+    iter1: Iterable[Any],
+    iter2: Iterable[Any],
+    iter3: Iterable[Any],
+    iter4: Iterable[Any],
+    iter5: Iterable[Any],
+    iter6: Iterable[Any],
+    iter7: Iterable[Any],
+    *iterables: Iterable[Any],
+) -> Iterator[Tuple[Any, ...]]: ...
+@overload
+def product(*iterables: Iterable[Any], repeat: int) -> Iterator[Tuple[Any, ...]]: ...
+def permutations(iterable: Iterable[_T], r: int = ...) -> Iterator[Sequence[_T]]: ...
+def combinations(iterable: Iterable[_T], r: int) -> Iterator[Sequence[_T]]: ...
+def combinations_with_replacement(iterable: Iterable[_T], r: int) -> Iterator[Sequence[_T]]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/mutex.pyi

@@ -0,0 +1,12 @@
+from typing import Any, Callable, Deque, TypeVar
+
+_ArgType = TypeVar("_ArgType")
+
+class mutex:
+    locked: bool
+    queue: Deque[Any]
+    def __init__(self) -> None: ...
+    def test(self) -> bool: ...
+    def testandset(self) -> bool: ...
+    def lock(self, function: Callable[[_ArgType], Any], argument: _ArgType) -> None: ...
+    def unlock(self) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/os2emxpath.pyi

@@ -0,0 +1,85 @@
+import os
+import sys
+from _typeshed import AnyPath, BytesPath, StrPath
+from genericpath import exists as exists
+from typing import Any, AnyStr, Callable, List, Optional, Sequence, Text, Tuple, TypeVar, overload
+
+_T = TypeVar("_T")
+
+# ----- os.path variables -----
+supports_unicode_filenames: bool
+# aliases (also in os)
+curdir: str
+pardir: str
+sep: str
+if sys.platform == "win32":
+    altsep: str
+else:
+    altsep: Optional[str]
+extsep: str
+pathsep: str
+defpath: str
+devnull: str
+
+# ----- os.path function stubs -----
+def abspath(path: AnyStr) -> AnyStr: ...
+def basename(p: AnyStr) -> AnyStr: ...
+def dirname(p: AnyStr) -> AnyStr: ...
+def expanduser(path: AnyStr) -> AnyStr: ...
+def expandvars(path: AnyStr) -> AnyStr: ...
+def normcase(s: AnyStr) -> AnyStr: ...
+def normpath(path: AnyStr) -> AnyStr: ...
+
+if sys.platform == "win32":
+    def realpath(path: AnyStr) -> AnyStr: ...
+
+else:
+    def realpath(filename: AnyStr) -> AnyStr: ...
+
+# NOTE: Empty lists results in '' (str) regardless of contained type.
+# Also, in Python 2 mixed sequences of Text and bytes results in either Text or bytes
+# So, fall back to Any
+def commonprefix(m: Sequence[AnyPath]) -> Any: ...
+def lexists(path: AnyPath) -> bool: ...
+
+# These return float if os.stat_float_times() == True,
+# but int is a subclass of float.
+def getatime(filename: AnyPath) -> float: ...
+def getmtime(filename: AnyPath) -> float: ...
+def getctime(filename: AnyPath) -> float: ...
+def getsize(filename: AnyPath) -> int: ...
+def isabs(s: AnyPath) -> bool: ...
+def isfile(path: AnyPath) -> bool: ...
+def isdir(s: AnyPath) -> bool: ...
+def islink(path: AnyPath) -> bool: ...
+def ismount(path: AnyPath) -> bool: ...
+
+# Make sure signatures are disjunct, and allow combinations of bytes and unicode.
+# (Since Python 2 allows that, too)
+# Note that e.g. os.path.join("a", "b", "c", "d", u"e") will still result in
+# a type error.
+@overload
+def join(__p1: bytes, *p: bytes) -> bytes: ...
+@overload
+def join(__p1: bytes, __p2: bytes, __p3: bytes, __p4: Text, *p: AnyPath) -> Text: ...
+@overload
+def join(__p1: bytes, __p2: bytes, __p3: Text, *p: AnyPath) -> Text: ...
+@overload
+def join(__p1: bytes, __p2: Text, *p: AnyPath) -> Text: ...
+@overload
+def join(__p1: Text, *p: AnyPath) -> Text: ...
+@overload
+def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ...
+@overload
+def relpath(path: StrPath, start: Optional[StrPath] = ...) -> Text: ...
+def samefile(f1: AnyPath, f2: AnyPath) -> bool: ...
+def sameopenfile(fp1: int, fp2: int) -> bool: ...
+def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ...
+def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
+def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
+def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
+
+if sys.platform == "win32":
+    def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...  # deprecated
+
+def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/spwd.pyi

@@ -0,0 +1,15 @@
+from typing import List, NamedTuple
+
+class struct_spwd(NamedTuple):
+    sp_nam: str
+    sp_pwd: str
+    sp_lstchg: int
+    sp_min: int
+    sp_max: int
+    sp_warn: int
+    sp_inact: int
+    sp_expire: int
+    sp_flag: int
+
+def getspall() -> List[struct_spwd]: ...
+def getspnam(name: str) -> struct_spwd: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/sre_constants.pyi

@@ -0,0 +1,93 @@
+from typing import Dict, List, TypeVar
+
+MAGIC: int
+MAXREPEAT: int
+
+class error(Exception): ...
+
+FAILURE: str
+SUCCESS: str
+ANY: str
+ANY_ALL: str
+ASSERT: str
+ASSERT_NOT: str
+AT: str
+BIGCHARSET: str
+BRANCH: str
+CALL: str
+CATEGORY: str
+CHARSET: str
+GROUPREF: str
+GROUPREF_IGNORE: str
+GROUPREF_EXISTS: str
+IN: str
+IN_IGNORE: str
+INFO: str
+JUMP: str
+LITERAL: str
+LITERAL_IGNORE: str
+MARK: str
+MAX_REPEAT: str
+MAX_UNTIL: str
+MIN_REPEAT: str
+MIN_UNTIL: str
+NEGATE: str
+NOT_LITERAL: str
+NOT_LITERAL_IGNORE: str
+RANGE: str
+REPEAT: str
+REPEAT_ONE: str
+SUBPATTERN: str
+MIN_REPEAT_ONE: str
+AT_BEGINNING: str
+AT_BEGINNING_LINE: str
+AT_BEGINNING_STRING: str
+AT_BOUNDARY: str
+AT_NON_BOUNDARY: str
+AT_END: str
+AT_END_LINE: str
+AT_END_STRING: str
+AT_LOC_BOUNDARY: str
+AT_LOC_NON_BOUNDARY: str
+AT_UNI_BOUNDARY: str
+AT_UNI_NON_BOUNDARY: str
+CATEGORY_DIGIT: str
+CATEGORY_NOT_DIGIT: str
+CATEGORY_SPACE: str
+CATEGORY_NOT_SPACE: str
+CATEGORY_WORD: str
+CATEGORY_NOT_WORD: str
+CATEGORY_LINEBREAK: str
+CATEGORY_NOT_LINEBREAK: str
+CATEGORY_LOC_WORD: str
+CATEGORY_LOC_NOT_WORD: str
+CATEGORY_UNI_DIGIT: str
+CATEGORY_UNI_NOT_DIGIT: str
+CATEGORY_UNI_SPACE: str
+CATEGORY_UNI_NOT_SPACE: str
+CATEGORY_UNI_WORD: str
+CATEGORY_UNI_NOT_WORD: str
+CATEGORY_UNI_LINEBREAK: str
+CATEGORY_UNI_NOT_LINEBREAK: str
+
+_T = TypeVar("_T")
+
+def makedict(list: List[_T]) -> Dict[_T, int]: ...
+
+OP_IGNORE: Dict[str, str]
+AT_MULTILINE: Dict[str, str]
+AT_LOCALE: Dict[str, str]
+AT_UNICODE: Dict[str, str]
+CH_LOCALE: Dict[str, str]
+CH_UNICODE: Dict[str, str]
+SRE_FLAG_TEMPLATE: int
+SRE_FLAG_IGNORECASE: int
+SRE_FLAG_LOCALE: int
+SRE_FLAG_MULTILINE: int
+SRE_FLAG_DOTALL: int
+SRE_FLAG_UNICODE: int
+SRE_FLAG_VERBOSE: int
+SRE_FLAG_DEBUG: int
+SRE_INFO_PREFIX: int
+SRE_INFO_LITERAL: int
+SRE_INFO_CHARSET: int

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/sre_parse.pyi

@@ -0,0 +1,62 @@
+from typing import Any, Dict, Iterable, List, Match, Optional, Pattern as _Pattern, Set, Tuple, Union
+
+SPECIAL_CHARS: str
+REPEAT_CHARS: str
+DIGITS: Set[Any]
+OCTDIGITS: Set[Any]
+HEXDIGITS: Set[Any]
+WHITESPACE: Set[Any]
+ESCAPES: Dict[str, Tuple[str, int]]
+CATEGORIES: Dict[str, Union[Tuple[str, str], Tuple[str, List[Tuple[str, str]]]]]
+FLAGS: Dict[str, int]
+
+class Pattern:
+    flags: int
+    open: List[int]
+    groups: int
+    groupdict: Dict[str, int]
+    lookbehind: int
+    def __init__(self) -> None: ...
+    def opengroup(self, name: str = ...) -> int: ...
+    def closegroup(self, gid: int) -> None: ...
+    def checkgroup(self, gid: int) -> bool: ...
+
+_OpSubpatternType = Tuple[Optional[int], int, int, SubPattern]
+_OpGroupRefExistsType = Tuple[int, SubPattern, SubPattern]
+_OpInType = List[Tuple[str, int]]
+_OpBranchType = Tuple[None, List[SubPattern]]
+_AvType = Union[_OpInType, _OpBranchType, Iterable[SubPattern], _OpGroupRefExistsType, _OpSubpatternType]
+_CodeType = Union[str, _AvType]
+
+class SubPattern:
+    pattern: str
+    data: List[_CodeType]
+    width: Optional[int]
+    def __init__(self, pattern, data: List[_CodeType] = ...) -> None: ...
+    def dump(self, level: int = ...) -> None: ...
+    def __len__(self) -> int: ...
+    def __delitem__(self, index: Union[int, slice]) -> None: ...
+    def __getitem__(self, index: Union[int, slice]) -> Union[SubPattern, _CodeType]: ...
+    def __setitem__(self, index: Union[int, slice], code: _CodeType): ...
+    def insert(self, index, code: _CodeType) -> None: ...
+    def append(self, code: _CodeType) -> None: ...
+    def getwidth(self) -> int: ...
+
+class Tokenizer:
+    string: str
+    index: int
+    def __init__(self, string: str) -> None: ...
+    def match(self, char: str, skip: int = ...) -> int: ...
+    def get(self) -> Optional[str]: ...
+    def tell(self) -> Tuple[int, Optional[str]]: ...
+    def seek(self, index: int) -> None: ...
+
+def isident(char: str) -> bool: ...
+def isdigit(char: str) -> bool: ...
+def isname(name: str) -> bool: ...
+def parse(str: str, flags: int = ..., pattern: Pattern = ...) -> SubPattern: ...
+
+_Template = Tuple[List[Tuple[int, int]], List[Optional[int]]]
+
+def parse_template(source: str, pattern: _Pattern[Any]) -> _Template: ...
+def expand_template(template: _Template, match: Match[Any]) -> str: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2/whichdb.pyi

@@ -0,0 +1,3 @@
+from typing import Optional, Text
+
+def whichdb(filename: Text) -> Optional[str]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/__future__.pyi

@@ -0,0 +1,25 @@
+import sys
+from typing import List
+
+class _Feature:
+    def getOptionalRelease(self) -> sys._version_info: ...
+    def getMandatoryRelease(self) -> sys._version_info: ...
+    compiler_flag: int
+
+absolute_import: _Feature
+division: _Feature
+generators: _Feature
+nested_scopes: _Feature
+print_function: _Feature
+unicode_literals: _Feature
+with_statement: _Feature
+if sys.version_info >= (3, 0):
+    barry_as_FLUFL: _Feature
+
+if sys.version_info >= (3, 5):
+    generator_stop: _Feature
+
+if sys.version_info >= (3, 7):
+    annotations: _Feature
+
+all_feature_names: List[str]  # undocumented

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/_bisect.pyi

@@ -0,0 +1,8 @@
+from typing import MutableSequence, Optional, Sequence, TypeVar
+
+_T = TypeVar("_T")
+
+def bisect_left(a: Sequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> int: ...
+def bisect_right(a: Sequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> int: ...
+def insort_left(a: MutableSequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> None: ...
+def insort_right(a: MutableSequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/_curses.pyi

@@ -0,0 +1,490 @@
+import sys
+from typing import IO, Any, BinaryIO, NamedTuple, Optional, Tuple, Union, overload
+
+_chtype = Union[str, bytes, int]
+
+ALL_MOUSE_EVENTS: int
+A_ALTCHARSET: int
+A_ATTRIBUTES: int
+A_BLINK: int
+A_BOLD: int
+A_CHARTEXT: int
+A_COLOR: int
+A_DIM: int
+A_HORIZONTAL: int
+A_INVIS: int
+if sys.version_info >= (3, 7):
+    A_ITALIC: int
+A_LEFT: int
+A_LOW: int
+A_NORMAL: int
+A_PROTECT: int
+A_REVERSE: int
+A_RIGHT: int
+A_STANDOUT: int
+A_TOP: int
+A_UNDERLINE: int
+A_VERTICAL: int
+BUTTON1_CLICKED: int
+BUTTON1_DOUBLE_CLICKED: int
+BUTTON1_PRESSED: int
+BUTTON1_RELEASED: int
+BUTTON1_TRIPLE_CLICKED: int
+BUTTON2_CLICKED: int
+BUTTON2_DOUBLE_CLICKED: int
+BUTTON2_PRESSED: int
+BUTTON2_RELEASED: int
+BUTTON2_TRIPLE_CLICKED: int
+BUTTON3_CLICKED: int
+BUTTON3_DOUBLE_CLICKED: int
+BUTTON3_PRESSED: int
+BUTTON3_RELEASED: int
+BUTTON3_TRIPLE_CLICKED: int
+BUTTON4_CLICKED: int
+BUTTON4_DOUBLE_CLICKED: int
+BUTTON4_PRESSED: int
+BUTTON4_RELEASED: int
+BUTTON4_TRIPLE_CLICKED: int
+BUTTON_ALT: int
+BUTTON_CTRL: int
+BUTTON_SHIFT: int
+COLOR_BLACK: int
+COLOR_BLUE: int
+COLOR_CYAN: int
+COLOR_GREEN: int
+COLOR_MAGENTA: int
+COLOR_RED: int
+COLOR_WHITE: int
+COLOR_YELLOW: int
+ERR: int
+KEY_A1: int
+KEY_A3: int
+KEY_B2: int
+KEY_BACKSPACE: int
+KEY_BEG: int
+KEY_BREAK: int
+KEY_BTAB: int
+KEY_C1: int
+KEY_C3: int
+KEY_CANCEL: int
+KEY_CATAB: int
+KEY_CLEAR: int
+KEY_CLOSE: int
+KEY_COMMAND: int
+KEY_COPY: int
+KEY_CREATE: int
+KEY_CTAB: int
+KEY_DC: int
+KEY_DL: int
+KEY_DOWN: int
+KEY_EIC: int
+KEY_END: int
+KEY_ENTER: int
+KEY_EOL: int
+KEY_EOS: int
+KEY_EXIT: int
+KEY_F0: int
+KEY_F1: int
+KEY_F10: int
+KEY_F11: int
+KEY_F12: int
+KEY_F13: int
+KEY_F14: int
+KEY_F15: int
+KEY_F16: int
+KEY_F17: int
+KEY_F18: int
+KEY_F19: int
+KEY_F2: int
+KEY_F20: int
+KEY_F21: int
+KEY_F22: int
+KEY_F23: int
+KEY_F24: int
+KEY_F25: int
+KEY_F26: int
+KEY_F27: int
+KEY_F28: int
+KEY_F29: int
+KEY_F3: int
+KEY_F30: int
+KEY_F31: int
+KEY_F32: int
+KEY_F33: int
+KEY_F34: int
+KEY_F35: int
+KEY_F36: int
+KEY_F37: int
+KEY_F38: int
+KEY_F39: int
+KEY_F4: int
+KEY_F40: int
+KEY_F41: int
+KEY_F42: int
+KEY_F43: int
+KEY_F44: int
+KEY_F45: int
+KEY_F46: int
+KEY_F47: int
+KEY_F48: int
+KEY_F49: int
+KEY_F5: int
+KEY_F50: int
+KEY_F51: int
+KEY_F52: int
+KEY_F53: int
+KEY_F54: int
+KEY_F55: int
+KEY_F56: int
+KEY_F57: int
+KEY_F58: int
+KEY_F59: int
+KEY_F6: int
+KEY_F60: int
+KEY_F61: int
+KEY_F62: int
+KEY_F63: int
+KEY_F7: int
+KEY_F8: int
+KEY_F9: int
+KEY_FIND: int
+KEY_HELP: int
+KEY_HOME: int
+KEY_IC: int
+KEY_IL: int
+KEY_LEFT: int
+KEY_LL: int
+KEY_MARK: int
+KEY_MAX: int
+KEY_MESSAGE: int
+KEY_MIN: int
+KEY_MOUSE: int
+KEY_MOVE: int
+KEY_NEXT: int
+KEY_NPAGE: int
+KEY_OPEN: int
+KEY_OPTIONS: int
+KEY_PPAGE: int
+KEY_PREVIOUS: int
+KEY_PRINT: int
+KEY_REDO: int
+KEY_REFERENCE: int
+KEY_REFRESH: int
+KEY_REPLACE: int
+KEY_RESET: int
+KEY_RESIZE: int
+KEY_RESTART: int
+KEY_RESUME: int
+KEY_RIGHT: int
+KEY_SAVE: int
+KEY_SBEG: int
+KEY_SCANCEL: int
+KEY_SCOMMAND: int
+KEY_SCOPY: int
+KEY_SCREATE: int
+KEY_SDC: int
+KEY_SDL: int
+KEY_SELECT: int
+KEY_SEND: int
+KEY_SEOL: int
+KEY_SEXIT: int
+KEY_SF: int
+KEY_SFIND: int
+KEY_SHELP: int
+KEY_SHOME: int
+KEY_SIC: int
+KEY_SLEFT: int
+KEY_SMESSAGE: int
+KEY_SMOVE: int
+KEY_SNEXT: int
+KEY_SOPTIONS: int
+KEY_SPREVIOUS: int
+KEY_SPRINT: int
+KEY_SR: int
+KEY_SREDO: int
+KEY_SREPLACE: int
+KEY_SRESET: int
+KEY_SRIGHT: int
+KEY_SRSUME: int
+KEY_SSAVE: int
+KEY_SSUSPEND: int
+KEY_STAB: int
+KEY_SUNDO: int
+KEY_SUSPEND: int
+KEY_UNDO: int
+KEY_UP: int
+OK: int
+REPORT_MOUSE_POSITION: int
+_C_API: Any
+version: bytes
+
+def baudrate() -> int: ...
+def beep() -> None: ...
+def can_change_color() -> bool: ...
+def cbreak(__flag: bool = ...) -> None: ...
+def color_content(__color_number: int) -> Tuple[int, int, int]: ...
+def color_pair(__color_number: int) -> int: ...
+def curs_set(__visibility: int) -> int: ...
+def def_prog_mode() -> None: ...
+def def_shell_mode() -> None: ...
+def delay_output(__ms: int) -> None: ...
+def doupdate() -> None: ...
+def echo(__flag: bool = ...) -> None: ...
+def endwin() -> None: ...
+def erasechar() -> bytes: ...
+def filter() -> None: ...
+def flash() -> None: ...
+def flushinp() -> None: ...
+def getmouse() -> Tuple[int, int, int, int, int]: ...
+def getsyx() -> Tuple[int, int]: ...
+def getwin(__file: BinaryIO) -> _CursesWindow: ...
+def halfdelay(__tenths: int) -> None: ...
+def has_colors() -> bool: ...
+def has_ic() -> bool: ...
+def has_il() -> bool: ...
+def has_key(__key: int) -> bool: ...
+def init_color(__color_number: int, __r: int, __g: int, __b: int) -> None: ...
+def init_pair(__pair_number: int, __fg: int, __bg: int) -> None: ...
+def initscr() -> _CursesWindow: ...
+def intrflush(__flag: bool) -> None: ...
+def is_term_resized(__nlines: int, __ncols: int) -> bool: ...
+def isendwin() -> bool: ...
+def keyname(__key: int) -> bytes: ...
+def killchar() -> bytes: ...
+def longname() -> bytes: ...
+def meta(__yes: bool) -> None: ...
+def mouseinterval(__interval: int) -> None: ...
+def mousemask(__newmask: int) -> Tuple[int, int]: ...
+def napms(__ms: int) -> int: ...
+def newpad(__nlines: int, __ncols: int) -> _CursesWindow: ...
+def newwin(__nlines: int, __ncols: int, __begin_y: int = ..., __begin_x: int = ...) -> _CursesWindow: ...
+def nl(__flag: bool = ...) -> None: ...
+def nocbreak() -> None: ...
+def noecho() -> None: ...
+def nonl() -> None: ...
+def noqiflush() -> None: ...
+def noraw() -> None: ...
+def pair_content(__pair_number: int) -> Tuple[int, int]: ...
+def pair_number(__attr: int) -> int: ...
+def putp(__string: bytes) -> None: ...
+def qiflush(__flag: bool = ...) -> None: ...
+def raw(__flag: bool = ...) -> None: ...
+def reset_prog_mode() -> None: ...
+def reset_shell_mode() -> None: ...
+def resetty() -> None: ...
+def resize_term(__nlines: int, __ncols: int) -> None: ...
+def resizeterm(__nlines: int, __ncols: int) -> None: ...
+def savetty() -> None: ...
+def setsyx(__y: int, __x: int) -> None: ...
+def setupterm(term: Optional[str] = ..., fd: int = ...) -> None: ...
+def start_color() -> None: ...
+def termattrs() -> int: ...
+def termname() -> bytes: ...
+def tigetflag(__capname: str) -> int: ...
+def tigetnum(__capname: str) -> int: ...
+def tigetstr(__capname: str) -> bytes: ...
+def tparm(
+    __str: bytes,
+    __i1: int = ...,
+    __i2: int = ...,
+    __i3: int = ...,
+    __i4: int = ...,
+    __i5: int = ...,
+    __i6: int = ...,
+    __i7: int = ...,
+    __i8: int = ...,
+    __i9: int = ...,
+) -> bytes: ...
+def typeahead(__fd: int) -> None: ...
+def unctrl(__ch: _chtype) -> bytes: ...
+
+if sys.version_info >= (3, 3):
+    def unget_wch(__ch: Union[int, str]) -> None: ...
+
+def ungetch(__ch: _chtype) -> None: ...
+def ungetmouse(__id: int, __x: int, __y: int, __z: int, __bstate: int) -> None: ...
+
+if sys.version_info >= (3, 5):
+    def update_lines_cols() -> int: ...
+
+def use_default_colors() -> None: ...
+def use_env(__flag: bool) -> None: ...
+
+class error(Exception): ...
+
+class _CursesWindow:
+    if sys.version_info >= (3, 3):
+        encoding: str
+    @overload
+    def addch(self, ch: _chtype, attr: int = ...) -> None: ...
+    @overload
+    def addch(self, y: int, x: int, ch: _chtype, attr: int = ...) -> None: ...
+    @overload
+    def addnstr(self, str: str, n: int, attr: int = ...) -> None: ...
+    @overload
+    def addnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ...
+    @overload
+    def addstr(self, str: str, attr: int = ...) -> None: ...
+    @overload
+    def addstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ...
+    def attroff(self, attr: int) -> None: ...
+    def attron(self, attr: int) -> None: ...
+    def attrset(self, attr: int) -> None: ...
+    def bkgd(self, ch: _chtype, attr: int = ...) -> None: ...
+    def bkgdset(self, ch: _chtype, attr: int = ...) -> None: ...
+    def border(
+        self,
+        ls: _chtype = ...,
+        rs: _chtype = ...,
+        ts: _chtype = ...,
+        bs: _chtype = ...,
+        tl: _chtype = ...,
+        tr: _chtype = ...,
+        bl: _chtype = ...,
+        br: _chtype = ...,
+    ) -> None: ...
+    @overload
+    def box(self) -> None: ...
+    @overload
+    def box(self, vertch: _chtype = ..., horch: _chtype = ...) -> None: ...
+    @overload
+    def chgat(self, attr: int) -> None: ...
+    @overload
+    def chgat(self, num: int, attr: int) -> None: ...
+    @overload
+    def chgat(self, y: int, x: int, attr: int) -> None: ...
+    @overload
+    def chgat(self, y: int, x: int, num: int, attr: int) -> None: ...
+    def clear(self) -> None: ...
+    def clearok(self, yes: int) -> None: ...
+    def clrtobot(self) -> None: ...
+    def clrtoeol(self) -> None: ...
+    def cursyncup(self) -> None: ...
+    @overload
+    def delch(self) -> None: ...
+    @overload
+    def delch(self, y: int, x: int) -> None: ...
+    def deleteln(self) -> None: ...
+    @overload
+    def derwin(self, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    @overload
+    def derwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    def echochar(self, ch: _chtype, attr: int = ...) -> None: ...
+    def enclose(self, y: int, x: int) -> bool: ...
+    def erase(self) -> None: ...
+    def getbegyx(self) -> Tuple[int, int]: ...
+    def getbkgd(self) -> Tuple[int, int]: ...
+    @overload
+    def getch(self) -> int: ...
+    @overload
+    def getch(self, y: int, x: int) -> int: ...
+    if sys.version_info >= (3, 3):
+        @overload
+        def get_wch(self) -> Union[int, str]: ...
+        @overload
+        def get_wch(self, y: int, x: int) -> Union[int, str]: ...
+    @overload
+    def getkey(self) -> str: ...
+    @overload
+    def getkey(self, y: int, x: int) -> str: ...
+    def getmaxyx(self) -> Tuple[int, int]: ...
+    def getparyx(self) -> Tuple[int, int]: ...
+    @overload
+    def getstr(self) -> _chtype: ...
+    @overload
+    def getstr(self, n: int) -> _chtype: ...
+    @overload
+    def getstr(self, y: int, x: int) -> _chtype: ...
+    @overload
+    def getstr(self, y: int, x: int, n: int) -> _chtype: ...
+    def getyx(self) -> Tuple[int, int]: ...
+    @overload
+    def hline(self, ch: _chtype, n: int) -> None: ...
+    @overload
+    def hline(self, y: int, x: int, ch: _chtype, n: int) -> None: ...
+    def idcok(self, flag: bool) -> None: ...
+    def idlok(self, yes: bool) -> None: ...
+    def immedok(self, flag: bool) -> None: ...
+    @overload
+    def inch(self) -> _chtype: ...
+    @overload
+    def inch(self, y: int, x: int) -> _chtype: ...
+    @overload
+    def insch(self, ch: _chtype, attr: int = ...) -> None: ...
+    @overload
+    def insch(self, y: int, x: int, ch: _chtype, attr: int = ...) -> None: ...
+    def insdelln(self, nlines: int) -> None: ...
+    def insertln(self) -> None: ...
+    @overload
+    def insnstr(self, str: str, n: int, attr: int = ...) -> None: ...
+    @overload
+    def insnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ...
+    @overload
+    def insstr(self, str: str, attr: int = ...) -> None: ...
+    @overload
+    def insstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ...
+    @overload
+    def instr(self, n: int = ...) -> _chtype: ...
+    @overload
+    def instr(self, y: int, x: int, n: int = ...) -> _chtype: ...
+    def is_linetouched(self, line: int) -> bool: ...
+    def is_wintouched(self) -> bool: ...
+    def keypad(self, yes: bool) -> None: ...
+    def leaveok(self, yes: bool) -> None: ...
+    def move(self, new_y: int, new_x: int) -> None: ...
+    def mvderwin(self, y: int, x: int) -> None: ...
+    def mvwin(self, new_y: int, new_x: int) -> None: ...
+    def nodelay(self, yes: bool) -> None: ...
+    def notimeout(self, yes: bool) -> None: ...
+    def noutrefresh(self) -> None: ...
+    @overload
+    def overlay(self, destwin: _CursesWindow) -> None: ...
+    @overload
+    def overlay(
+        self, destwin: _CursesWindow, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
+    ) -> None: ...
+    @overload
+    def overwrite(self, destwin: _CursesWindow) -> None: ...
+    @overload
+    def overwrite(
+        self, destwin: _CursesWindow, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
+    ) -> None: ...
+    def putwin(self, file: IO[Any]) -> None: ...
+    def redrawln(self, beg: int, num: int) -> None: ...
+    def redrawwin(self) -> None: ...
+    @overload
+    def refresh(self) -> None: ...
+    @overload
+    def refresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None: ...
+    def resize(self, nlines: int, ncols: int) -> None: ...
+    def scroll(self, lines: int = ...) -> None: ...
+    def scrollok(self, flag: bool) -> None: ...
+    def setscrreg(self, top: int, bottom: int) -> None: ...
+    def standend(self) -> None: ...
+    def standout(self) -> None: ...
+    @overload
+    def subpad(self, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    @overload
+    def subpad(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    @overload
+    def subwin(self, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    @overload
+    def subwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ...
+    def syncdown(self) -> None: ...
+    def syncok(self, flag: bool) -> None: ...
+    def syncup(self) -> None: ...
+    def timeout(self, delay: int) -> None: ...
+    def touchline(self, start: int, count: int, changed: bool = ...) -> None: ...
+    def touchwin(self) -> None: ...
+    def untouchwin(self) -> None: ...
+    @overload
+    def vline(self, ch: _chtype, n: int) -> None: ...
+    @overload
+    def vline(self, y: int, x: int, ch: _chtype, n: int) -> None: ...
+
+if sys.version_info >= (3, 8):
+    class _ncurses_version(NamedTuple):
+        major: int
+        minor: int
+        patch: int
+    ncurses_version: _ncurses_version

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/asyncore.pyi

@@ -0,0 +1,119 @@
+import sys
+from _typeshed import FileDescriptorLike
+from socket import SocketType
+from typing import Any, Dict, Optional, Tuple, Union, overload
+
+# cyclic dependence with asynchat
+_maptype = Dict[int, Any]
+
+socket_map: _maptype = ...  # Undocumented
+
+class ExitNow(Exception): ...
+
+def read(obj: Any) -> None: ...
+def write(obj: Any) -> None: ...
+def readwrite(obj: Any, flags: int) -> None: ...
+def poll(timeout: float = ..., map: Optional[_maptype] = ...) -> None: ...
+def poll2(timeout: float = ..., map: Optional[_maptype] = ...) -> None: ...
+
+poll3 = poll2
+
+def loop(timeout: float = ..., use_poll: bool = ..., map: Optional[_maptype] = ..., count: Optional[int] = ...) -> None: ...
+
+# Not really subclass of socket.socket; it's only delegation.
+# It is not covariant to it.
+class dispatcher:
+
+    debug: bool
+    connected: bool
+    accepting: bool
+    connecting: bool
+    closing: bool
+    ignore_log_types: frozenset[str]
+    socket: Optional[SocketType]
+    def __init__(self, sock: Optional[SocketType] = ..., map: Optional[_maptype] = ...) -> None: ...
+    def add_channel(self, map: Optional[_maptype] = ...) -> None: ...
+    def del_channel(self, map: Optional[_maptype] = ...) -> None: ...
+    def create_socket(self, family: int = ..., type: int = ...) -> None: ...
+    def set_socket(self, sock: SocketType, map: Optional[_maptype] = ...) -> None: ...
+    def set_reuse_addr(self) -> None: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def listen(self, num: int) -> None: ...
+    def bind(self, addr: Union[Tuple[Any, ...], str]) -> None: ...
+    def connect(self, address: Union[Tuple[Any, ...], str]) -> None: ...
+    def accept(self) -> Optional[Tuple[SocketType, Any]]: ...
+    def send(self, data: bytes) -> int: ...
+    def recv(self, buffer_size: int) -> bytes: ...
+    def close(self) -> None: ...
+    def log(self, message: Any) -> None: ...
+    def log_info(self, message: Any, type: str = ...) -> None: ...
+    def handle_read_event(self) -> None: ...
+    def handle_connect_event(self) -> None: ...
+    def handle_write_event(self) -> None: ...
+    def handle_expt_event(self) -> None: ...
+    def handle_error(self) -> None: ...
+    def handle_expt(self) -> None: ...
+    def handle_read(self) -> None: ...
+    def handle_write(self) -> None: ...
+    def handle_connect(self) -> None: ...
+    def handle_accept(self) -> None: ...
+    def handle_close(self) -> None: ...
+    if sys.version_info < (3, 5):
+        # Historically, some methods were "imported" from `self.socket` by
+        # means of `__getattr__`. This was long deprecated, and as of Python
+        # 3.5 has been removed; simply call the relevant methods directly on
+        # self.socket if necessary.
+        def detach(self) -> int: ...
+        def fileno(self) -> int: ...
+        # return value is an address
+        def getpeername(self) -> Any: ...
+        def getsockname(self) -> Any: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: None = ...) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
+        def gettimeout(self) -> float: ...
+        def ioctl(self, control: object, option: Tuple[int, int, int]) -> None: ...
+        # TODO the return value may be BinaryIO or TextIO, depending on mode
+        def makefile(
+            self, mode: str = ..., buffering: int = ..., encoding: str = ..., errors: str = ..., newline: str = ...
+        ) -> Any: ...
+        # return type is an address
+        def recvfrom(self, bufsize: int, flags: int = ...) -> Any: ...
+        def recvfrom_into(self, buffer: bytes, nbytes: int, flags: int = ...) -> Any: ...
+        def recv_into(self, buffer: bytes, nbytes: int, flags: int = ...) -> Any: ...
+        def sendall(self, data: bytes, flags: int = ...) -> None: ...
+        def sendto(self, data: bytes, address: Union[Tuple[str, int], str], flags: int = ...) -> int: ...
+        def setblocking(self, flag: bool) -> None: ...
+        def settimeout(self, value: Union[float, None]) -> None: ...
+        def setsockopt(self, level: int, optname: int, value: Union[int, bytes]) -> None: ...
+        def shutdown(self, how: int) -> None: ...
+
+class dispatcher_with_send(dispatcher):
+    def __init__(self, sock: SocketType = ..., map: Optional[_maptype] = ...) -> None: ...
+    def initiate_send(self) -> None: ...
+    def handle_write(self) -> None: ...
+    # incompatible signature:
+    # def send(self, data: bytes) -> Optional[int]: ...
+
+def compact_traceback() -> Tuple[Tuple[str, str, str], type, type, str]: ...
+def close_all(map: Optional[_maptype] = ..., ignore_all: bool = ...) -> None: ...
+
+if sys.platform != "win32":
+    class file_wrapper:
+        fd: int
+        def __init__(self, fd: int) -> None: ...
+        def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def send(self, data: bytes, flags: int = ...) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: None = ...) -> int: ...
+        @overload
+        def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
+        def read(self, bufsize: int, flags: int = ...) -> bytes: ...
+        def write(self, data: bytes, flags: int = ...) -> int: ...
+        def close(self) -> None: ...
+        def fileno(self) -> int: ...
+    class file_dispatcher(dispatcher):
+        def __init__(self, fd: FileDescriptorLike, map: Optional[_maptype] = ...) -> None: ...
+        def set_file(self, fd: int) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/cmath.pyi

@@ -0,0 +1,42 @@
+import sys
+from typing import SupportsComplex, SupportsFloat, Tuple, Union
+
+e: float
+pi: float
+if sys.version_info >= (3, 6):
+    inf: float
+    infj: complex
+    nan: float
+    nanj: complex
+    tau: float
+
+_C = Union[SupportsFloat, SupportsComplex]
+
+def acos(__z: _C) -> complex: ...
+def acosh(__z: _C) -> complex: ...
+def asin(__z: _C) -> complex: ...
+def asinh(__z: _C) -> complex: ...
+def atan(__z: _C) -> complex: ...
+def atanh(__z: _C) -> complex: ...
+def cos(__z: _C) -> complex: ...
+def cosh(__z: _C) -> complex: ...
+def exp(__z: _C) -> complex: ...
+
+if sys.version_info >= (3, 5):
+    def isclose(a: _C, b: _C, *, rel_tol: SupportsFloat = ..., abs_tol: SupportsFloat = ...) -> bool: ...
+
+def isinf(__z: _C) -> bool: ...
+def isnan(__z: _C) -> bool: ...
+def log(__x: _C, __y_obj: _C = ...) -> complex: ...
+def log10(__z: _C) -> complex: ...
+def phase(__z: _C) -> float: ...
+def polar(__z: _C) -> Tuple[float, float]: ...
+def rect(__r: float, __phi: float) -> complex: ...
+def sin(__z: _C) -> complex: ...
+def sinh(__z: _C) -> complex: ...
+def sqrt(__z: _C) -> complex: ...
+def tan(__z: _C) -> complex: ...
+def tanh(__z: _C) -> complex: ...
+
+if sys.version_info >= (3,):
+    def isfinite(__z: _C) -> bool: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/codeop.pyi

@@ -0,0 +1,14 @@
+from types import CodeType
+from typing import Optional
+
+def compile_command(source: str, filename: str = ..., symbol: str = ...) -> Optional[CodeType]: ...
+
+class Compile:
+    flags: int
+    def __init__(self) -> None: ...
+    def __call__(self, source: str, filename: str, symbol: str) -> CodeType: ...
+
+class CommandCompiler:
+    compiler: Compile
+    def __init__(self) -> None: ...
+    def __call__(self, source: str, filename: str = ..., symbol: str = ...) -> Optional[CodeType]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/contextlib.pyi

@@ -0,0 +1,102 @@
+import sys
+from types import TracebackType
+from typing import IO, Any, Callable, ContextManager, Iterable, Iterator, Optional, Type, TypeVar, overload
+
+if sys.version_info >= (3, 5):
+    from typing import AsyncContextManager, AsyncIterator
+
+if sys.version_info >= (3, 6):
+    AbstractContextManager = ContextManager
+if sys.version_info >= (3, 7):
+    AbstractAsyncContextManager = AsyncContextManager
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_T_io = TypeVar("_T_io", bound=Optional[IO[str]])
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+_ExitFunc = Callable[[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]], bool]
+_CM_EF = TypeVar("_CM_EF", ContextManager[Any], _ExitFunc)
+
+if sys.version_info >= (3, 2):
+    class _GeneratorContextManager(ContextManager[_T_co]):
+        def __call__(self, func: _F) -> _F: ...
+    def contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]: ...
+
+else:
+    class GeneratorContextManager(ContextManager[_T_co]):
+        def __call__(self, func: _F) -> _F: ...
+    def contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., ContextManager[_T]]: ...
+
+if sys.version_info >= (3, 7):
+    def asynccontextmanager(func: Callable[..., AsyncIterator[_T]]) -> Callable[..., AsyncContextManager[_T]]: ...
+
+if sys.version_info < (3,):
+    def nested(*mgr: ContextManager[Any]) -> ContextManager[Iterable[Any]]: ...
+
+class closing(ContextManager[_T]):
+    def __init__(self, thing: _T) -> None: ...
+
+if sys.version_info >= (3, 4):
+    class suppress(ContextManager[None]):
+        def __init__(self, *exceptions: Type[BaseException]) -> None: ...
+        def __exit__(
+            self, exctype: Optional[Type[BaseException]], excinst: Optional[BaseException], exctb: Optional[TracebackType]
+        ) -> bool: ...
+    class redirect_stdout(ContextManager[_T_io]):
+        def __init__(self, new_target: _T_io) -> None: ...
+
+if sys.version_info >= (3, 5):
+    class redirect_stderr(ContextManager[_T_io]):
+        def __init__(self, new_target: _T_io) -> None: ...
+
+if sys.version_info >= (3,):
+    class ContextDecorator:
+        def __call__(self, func: _F) -> _F: ...
+    _U = TypeVar("_U", bound=ExitStack)
+    class ExitStack(ContextManager[ExitStack]):
+        def __init__(self) -> None: ...
+        def enter_context(self, cm: ContextManager[_T]) -> _T: ...
+        def push(self, exit: _CM_EF) -> _CM_EF: ...
+        def callback(self, callback: Callable[..., Any], *args: Any, **kwds: Any) -> Callable[..., Any]: ...
+        def pop_all(self: _U) -> _U: ...
+        def close(self) -> None: ...
+        def __enter__(self: _U) -> _U: ...
+        def __exit__(
+            self,
+            __exc_type: Optional[Type[BaseException]],
+            __exc_value: Optional[BaseException],
+            __traceback: Optional[TracebackType],
+        ) -> bool: ...
+
+if sys.version_info >= (3, 7):
+    from typing import Awaitable
+
+    _S = TypeVar("_S", bound=AsyncExitStack)
+
+    _ExitCoroFunc = Callable[[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]], Awaitable[bool]]
+    _CallbackCoroFunc = Callable[..., Awaitable[Any]]
+    _ACM_EF = TypeVar("_ACM_EF", AsyncContextManager[Any], _ExitCoroFunc)
+    class AsyncExitStack(AsyncContextManager[AsyncExitStack]):
+        def __init__(self) -> None: ...
+        def enter_context(self, cm: ContextManager[_T]) -> _T: ...
+        def enter_async_context(self, cm: AsyncContextManager[_T]) -> Awaitable[_T]: ...
+        def push(self, exit: _CM_EF) -> _CM_EF: ...
+        def push_async_exit(self, exit: _ACM_EF) -> _ACM_EF: ...
+        def callback(self, callback: Callable[..., Any], *args: Any, **kwds: Any) -> Callable[..., Any]: ...
+        def push_async_callback(self, callback: _CallbackCoroFunc, *args: Any, **kwds: Any) -> _CallbackCoroFunc: ...
+        def pop_all(self: _S) -> _S: ...
+        def aclose(self) -> Awaitable[None]: ...
+        def __aenter__(self: _S) -> Awaitable[_S]: ...
+        def __aexit__(
+            self,
+            __exc_type: Optional[Type[BaseException]],
+            __exc_value: Optional[BaseException],
+            __traceback: Optional[TracebackType],
+        ) -> Awaitable[bool]: ...
+
+if sys.version_info >= (3, 7):
+    @overload
+    def nullcontext(enter_result: _T) -> ContextManager[_T]: ...
+    @overload
+    def nullcontext() -> ContextManager[None]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/crypt.pyi

@@ -0,0 +1,22 @@
+import sys
+from typing import List, Optional, Union
+
+if sys.version_info >= (3, 3):
+    class _Method: ...
+    METHOD_CRYPT: _Method
+    METHOD_MD5: _Method
+    METHOD_SHA256: _Method
+    METHOD_SHA512: _Method
+    if sys.version_info >= (3, 7):
+        METHOD_BLOWFISH: _Method
+
+    methods: List[_Method]
+
+    if sys.version_info >= (3, 7):
+        def mksalt(method: Optional[_Method] = ..., *, rounds: Optional[int] = ...) -> str: ...
+    else:
+        def mksalt(method: Optional[_Method] = ...) -> str: ...
+    def crypt(word: str, salt: Optional[Union[str, _Method]] = ...) -> str: ...
+
+else:
+    def crypt(word: str, salt: str) -> str: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/difflib.pyi

@@ -0,0 +1,153 @@
+import sys
+from typing import (
+    Any,
+    AnyStr,
+    Callable,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    NamedTuple,
+    Optional,
+    Sequence,
+    Text,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+
+if sys.version_info >= (3,):
+    _StrType = Text
+else:
+    # Aliases can't point to type vars, so we need to redeclare AnyStr
+    _StrType = TypeVar("_StrType", Text, bytes)
+
+_JunkCallback = Union[Callable[[Text], bool], Callable[[str], bool]]
+
+class Match(NamedTuple):
+    a: int
+    b: int
+    size: int
+
+class SequenceMatcher(Generic[_T]):
+    def __init__(
+        self, isjunk: Optional[Callable[[_T], bool]] = ..., a: Sequence[_T] = ..., b: Sequence[_T] = ..., autojunk: bool = ...
+    ) -> None: ...
+    def set_seqs(self, a: Sequence[_T], b: Sequence[_T]) -> None: ...
+    def set_seq1(self, a: Sequence[_T]) -> None: ...
+    def set_seq2(self, b: Sequence[_T]) -> None: ...
+    if sys.version_info >= (3, 9):
+        def find_longest_match(
+            self, alo: int = ..., ahi: Optional[int] = ..., blo: int = ..., bhi: Optional[int] = ...
+        ) -> Match: ...
+    else:
+        def find_longest_match(self, alo: int, ahi: int, blo: int, bhi: int) -> Match: ...
+    def get_matching_blocks(self) -> List[Match]: ...
+    def get_opcodes(self) -> List[Tuple[str, int, int, int, int]]: ...
+    def get_grouped_opcodes(self, n: int = ...) -> Iterable[List[Tuple[str, int, int, int, int]]]: ...
+    def ratio(self) -> float: ...
+    def quick_ratio(self) -> float: ...
+    def real_quick_ratio(self) -> float: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+# mypy thinks the signatures of the overloads overlap, but the types still work fine
+@overload
+def get_close_matches(  # type: ignore
+    word: AnyStr, possibilities: Iterable[AnyStr], n: int = ..., cutoff: float = ...
+) -> List[AnyStr]: ...
+@overload
+def get_close_matches(
+    word: Sequence[_T], possibilities: Iterable[Sequence[_T]], n: int = ..., cutoff: float = ...
+) -> List[Sequence[_T]]: ...
+
+class Differ:
+    def __init__(self, linejunk: Optional[_JunkCallback] = ..., charjunk: Optional[_JunkCallback] = ...) -> None: ...
+    def compare(self, a: Sequence[_StrType], b: Sequence[_StrType]) -> Iterator[_StrType]: ...
+
+def IS_LINE_JUNK(line: _StrType, pat: Any = ...) -> bool: ...  # pat is undocumented
+def IS_CHARACTER_JUNK(ch: _StrType, ws: _StrType = ...) -> bool: ...  # ws is undocumented
+def unified_diff(
+    a: Sequence[_StrType],
+    b: Sequence[_StrType],
+    fromfile: _StrType = ...,
+    tofile: _StrType = ...,
+    fromfiledate: _StrType = ...,
+    tofiledate: _StrType = ...,
+    n: int = ...,
+    lineterm: _StrType = ...,
+) -> Iterator[_StrType]: ...
+def context_diff(
+    a: Sequence[_StrType],
+    b: Sequence[_StrType],
+    fromfile: _StrType = ...,
+    tofile: _StrType = ...,
+    fromfiledate: _StrType = ...,
+    tofiledate: _StrType = ...,
+    n: int = ...,
+    lineterm: _StrType = ...,
+) -> Iterator[_StrType]: ...
+def ndiff(
+    a: Sequence[_StrType], b: Sequence[_StrType], linejunk: Optional[_JunkCallback] = ..., charjunk: Optional[_JunkCallback] = ...
+) -> Iterator[_StrType]: ...
+
+class HtmlDiff(object):
+    def __init__(
+        self,
+        tabsize: int = ...,
+        wrapcolumn: Optional[int] = ...,
+        linejunk: Optional[_JunkCallback] = ...,
+        charjunk: Optional[_JunkCallback] = ...,
+    ) -> None: ...
+    if sys.version_info >= (3, 5):
+        def make_file(
+            self,
+            fromlines: Sequence[_StrType],
+            tolines: Sequence[_StrType],
+            fromdesc: _StrType = ...,
+            todesc: _StrType = ...,
+            context: bool = ...,
+            numlines: int = ...,
+            *,
+            charset: str = ...,
+        ) -> _StrType: ...
+    else:
+        def make_file(
+            self,
+            fromlines: Sequence[_StrType],
+            tolines: Sequence[_StrType],
+            fromdesc: _StrType = ...,
+            todesc: _StrType = ...,
+            context: bool = ...,
+            numlines: int = ...,
+        ) -> _StrType: ...
+    def make_table(
+        self,
+        fromlines: Sequence[_StrType],
+        tolines: Sequence[_StrType],
+        fromdesc: _StrType = ...,
+        todesc: _StrType = ...,
+        context: bool = ...,
+        numlines: int = ...,
+    ) -> _StrType: ...
+
+def restore(delta: Iterable[_StrType], which: int) -> Iterator[_StrType]: ...
+
+if sys.version_info >= (3, 5):
+    def diff_bytes(
+        dfunc: Callable[[Sequence[str], Sequence[str], str, str, str, str, int, str], Iterator[str]],
+        a: Sequence[bytes],
+        b: Sequence[bytes],
+        fromfile: bytes = ...,
+        tofile: bytes = ...,
+        fromfiledate: bytes = ...,
+        tofiledate: bytes = ...,
+        n: int = ...,
+        lineterm: bytes = ...,
+    ) -> Iterator[bytes]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/dummy_threading.pyi

@@ -0,0 +1,2 @@
+from _dummy_threading import *
+from _dummy_threading import __all__ as __all__

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/fractions.pyi

@@ -0,0 +1,159 @@
+import sys
+from decimal import Decimal
+from numbers import Integral, Rational, Real
+from typing import Optional, Tuple, Union, overload
+from typing_extensions import Literal
+
+_ComparableNum = Union[int, float, Decimal, Real]
+
+if sys.version_info < (3, 9):
+    @overload
+    def gcd(a: int, b: int) -> int: ...
+    @overload
+    def gcd(a: Integral, b: int) -> Integral: ...
+    @overload
+    def gcd(a: int, b: Integral) -> Integral: ...
+    @overload
+    def gcd(a: Integral, b: Integral) -> Integral: ...
+
+class Fraction(Rational):
+    @overload
+    def __new__(
+        cls, numerator: Union[int, Rational] = ..., denominator: Optional[Union[int, Rational]] = ..., *, _normalize: bool = ...
+    ) -> Fraction: ...
+    @overload
+    def __new__(cls, __value: Union[float, Decimal, str], *, _normalize: bool = ...) -> Fraction: ...
+    @classmethod
+    def from_float(cls, f: float) -> Fraction: ...
+    @classmethod
+    def from_decimal(cls, dec: Decimal) -> Fraction: ...
+    def limit_denominator(self, max_denominator: int = ...) -> Fraction: ...
+    if sys.version_info >= (3, 8):
+        def as_integer_ratio(self) -> Tuple[int, int]: ...
+    @property
+    def numerator(self) -> int: ...
+    @property
+    def denominator(self) -> int: ...
+    @overload
+    def __add__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __add__(self, other: float) -> float: ...
+    @overload
+    def __add__(self, other: complex) -> complex: ...
+    @overload
+    def __radd__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __radd__(self, other: float) -> float: ...
+    @overload
+    def __radd__(self, other: complex) -> complex: ...
+    @overload
+    def __sub__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __sub__(self, other: float) -> float: ...
+    @overload
+    def __sub__(self, other: complex) -> complex: ...
+    @overload
+    def __rsub__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __rsub__(self, other: float) -> float: ...
+    @overload
+    def __rsub__(self, other: complex) -> complex: ...
+    @overload
+    def __mul__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __mul__(self, other: float) -> float: ...
+    @overload
+    def __mul__(self, other: complex) -> complex: ...
+    @overload
+    def __rmul__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __rmul__(self, other: float) -> float: ...
+    @overload
+    def __rmul__(self, other: complex) -> complex: ...
+    @overload
+    def __truediv__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __truediv__(self, other: float) -> float: ...
+    @overload
+    def __truediv__(self, other: complex) -> complex: ...
+    @overload
+    def __rtruediv__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __rtruediv__(self, other: float) -> float: ...
+    @overload
+    def __rtruediv__(self, other: complex) -> complex: ...
+    if sys.version_info < (3, 0):
+        @overload
+        def __div__(self, other: Union[int, Fraction]) -> Fraction: ...
+        @overload
+        def __div__(self, other: float) -> float: ...
+        @overload
+        def __div__(self, other: complex) -> complex: ...
+        @overload
+        def __rdiv__(self, other: Union[int, Fraction]) -> Fraction: ...
+        @overload
+        def __rdiv__(self, other: float) -> float: ...
+        @overload
+        def __rdiv__(self, other: complex) -> complex: ...
+    @overload
+    def __floordiv__(self, other: Union[int, Fraction]) -> int: ...
+    @overload
+    def __floordiv__(self, other: float) -> float: ...
+    @overload
+    def __rfloordiv__(self, other: Union[int, Fraction]) -> int: ...
+    @overload
+    def __rfloordiv__(self, other: float) -> float: ...
+    @overload
+    def __mod__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __mod__(self, other: float) -> float: ...
+    @overload
+    def __rmod__(self, other: Union[int, Fraction]) -> Fraction: ...
+    @overload
+    def __rmod__(self, other: float) -> float: ...
+    @overload
+    def __divmod__(self, other: Union[int, Fraction]) -> Tuple[int, Fraction]: ...
+    @overload
+    def __divmod__(self, other: float) -> Tuple[float, Fraction]: ...
+    @overload
+    def __rdivmod__(self, other: Union[int, Fraction]) -> Tuple[int, Fraction]: ...
+    @overload
+    def __rdivmod__(self, other: float) -> Tuple[float, Fraction]: ...
+    @overload
+    def __pow__(self, other: int) -> Fraction: ...
+    @overload
+    def __pow__(self, other: Union[float, Fraction]) -> float: ...
+    @overload
+    def __pow__(self, other: complex) -> complex: ...
+    @overload
+    def __rpow__(self, other: Union[int, float, Fraction]) -> float: ...
+    @overload
+    def __rpow__(self, other: complex) -> complex: ...
+    def __pos__(self) -> Fraction: ...
+    def __neg__(self) -> Fraction: ...
+    def __abs__(self) -> Fraction: ...
+    def __trunc__(self) -> int: ...
+    if sys.version_info >= (3, 0):
+        def __floor__(self) -> int: ...
+        def __ceil__(self) -> int: ...
+        @overload
+        def __round__(self, ndigits: None = ...) -> int: ...
+        @overload
+        def __round__(self, ndigits: int) -> Fraction: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __lt__(self, other: _ComparableNum) -> bool: ...
+    def __gt__(self, other: _ComparableNum) -> bool: ...
+    def __le__(self, other: _ComparableNum) -> bool: ...
+    def __ge__(self, other: _ComparableNum) -> bool: ...
+    if sys.version_info >= (3, 0):
+        def __bool__(self) -> bool: ...
+    else:
+        def __nonzero__(self) -> bool: ...
+    # Not actually defined within fractions.py, but provides more useful
+    # overrides
+    @property
+    def real(self) -> Fraction: ...
+    @property
+    def imag(self) -> Literal[0]: ...
+    def conjugate(self) -> Fraction: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/imaplib.pyi

@@ -0,0 +1,172 @@
+import subprocess
+import sys
+import time
+from socket import socket as _socket
+from ssl import SSLContext, SSLSocket
+from types import TracebackType
+from typing import IO, Any, Callable, Dict, List, Optional, Pattern, Text, Tuple, Type, Union
+from typing_extensions import Literal
+
+# TODO: Commands should use their actual return types, not this type alias.
+#       E.g. Tuple[Literal["OK"], List[bytes]]
+_CommandResults = Tuple[str, List[Any]]
+
+_AnyResponseData = Union[List[None], List[Union[bytes, Tuple[bytes, bytes]]]]
+
+class IMAP4:
+    error: Type[Exception] = ...
+    abort: Type[Exception] = ...
+    readonly: Type[Exception] = ...
+    mustquote: Pattern[Text] = ...
+    debug: int = ...
+    state: str = ...
+    literal: Optional[Text] = ...
+    tagged_commands: Dict[bytes, Optional[List[bytes]]]
+    untagged_responses: Dict[str, List[Union[bytes, Tuple[bytes, bytes]]]]
+    continuation_response: str = ...
+    is_readonly: bool = ...
+    tagnum: int = ...
+    tagpre: str = ...
+    tagre: Pattern[Text] = ...
+    welcome: bytes = ...
+    capabilities: Tuple[str] = ...
+    PROTOCOL_VERSION: str = ...
+    if sys.version_info >= (3, 9):
+        def __init__(self, host: str = ..., port: int = ..., timeout: Optional[float] = ...) -> None: ...
+        def open(self, host: str = ..., port: int = ..., timeout: Optional[float] = ...) -> None: ...
+    else:
+        def __init__(self, host: str = ..., port: int = ...) -> None: ...
+        def open(self, host: str = ..., port: int = ...) -> None: ...
+    def __getattr__(self, attr: str) -> Any: ...
+    host: str = ...
+    port: int = ...
+    sock: _socket = ...
+    file: Union[IO[Text], IO[bytes]] = ...
+    def read(self, size: int) -> bytes: ...
+    def readline(self) -> bytes: ...
+    def send(self, data: bytes) -> None: ...
+    def shutdown(self) -> None: ...
+    def socket(self) -> _socket: ...
+    def recent(self) -> _CommandResults: ...
+    def response(self, code: str) -> _CommandResults: ...
+    def append(self, mailbox: str, flags: str, date_time: str, message: str) -> str: ...
+    def authenticate(self, mechanism: str, authobject: Callable[[bytes], Optional[bytes]]) -> Tuple[str, str]: ...
+    def capability(self) -> _CommandResults: ...
+    def check(self) -> _CommandResults: ...
+    def close(self) -> _CommandResults: ...
+    def copy(self, message_set: str, new_mailbox: str) -> _CommandResults: ...
+    def create(self, mailbox: str) -> _CommandResults: ...
+    def delete(self, mailbox: str) -> _CommandResults: ...
+    def deleteacl(self, mailbox: str, who: str) -> _CommandResults: ...
+    if sys.version_info >= (3, 5):
+        def enable(self, capability: str) -> _CommandResults: ...
+        def __enter__(self) -> IMAP4: ...
+        def __exit__(self, t: Optional[Type[BaseException]], v: Optional[BaseException], tb: Optional[TracebackType]) -> None: ...
+    def expunge(self) -> _CommandResults: ...
+    def fetch(self, message_set: str, message_parts: str) -> Tuple[str, _AnyResponseData]: ...
+    def getacl(self, mailbox: str) -> _CommandResults: ...
+    def getannotation(self, mailbox: str, entry: str, attribute: str) -> _CommandResults: ...
+    def getquota(self, root: str) -> _CommandResults: ...
+    def getquotaroot(self, mailbox: str) -> _CommandResults: ...
+    def list(self, directory: str = ..., pattern: str = ...) -> Tuple[str, _AnyResponseData]: ...
+    def login(self, user: str, password: str) -> Tuple[Literal["OK"], List[bytes]]: ...
+    def login_cram_md5(self, user: str, password: str) -> _CommandResults: ...
+    def logout(self) -> Tuple[str, _AnyResponseData]: ...
+    def lsub(self, directory: str = ..., pattern: str = ...) -> _CommandResults: ...
+    def myrights(self, mailbox: str) -> _CommandResults: ...
+    def namespace(self) -> _CommandResults: ...
+    def noop(self) -> Tuple[str, List[bytes]]: ...
+    def partial(self, message_num: str, message_part: str, start: str, length: str) -> _CommandResults: ...
+    def proxyauth(self, user: str) -> _CommandResults: ...
+    def rename(self, oldmailbox: str, newmailbox: str) -> _CommandResults: ...
+    def search(self, charset: Optional[str], *criteria: str) -> _CommandResults: ...
+    def select(self, mailbox: str = ..., readonly: bool = ...) -> Tuple[str, List[Optional[bytes]]]: ...
+    def setacl(self, mailbox: str, who: str, what: str) -> _CommandResults: ...
+    def setannotation(self, *args: str) -> _CommandResults: ...
+    def setquota(self, root: str, limits: str) -> _CommandResults: ...
+    def sort(self, sort_criteria: str, charset: str, *search_criteria: str) -> _CommandResults: ...
+    if sys.version_info >= (3,):
+        def starttls(self, ssl_context: Optional[Any] = ...) -> Tuple[Literal["OK"], List[None]]: ...
+    def status(self, mailbox: str, names: str) -> _CommandResults: ...
+    def store(self, message_set: str, command: str, flags: str) -> _CommandResults: ...
+    def subscribe(self, mailbox: str) -> _CommandResults: ...
+    def thread(self, threading_algorithm: str, charset: str, *search_criteria: str) -> _CommandResults: ...
+    def uid(self, command: str, *args: str) -> _CommandResults: ...
+    def unsubscribe(self, mailbox: str) -> _CommandResults: ...
+    if sys.version_info >= (3, 9):
+        def unselect(self) -> _CommandResults: ...
+    def xatom(self, name: str, *args: str) -> _CommandResults: ...
+    def print_log(self) -> None: ...
+
+class IMAP4_SSL(IMAP4):
+    keyfile: str = ...
+    certfile: str = ...
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            host: str = ...,
+            port: int = ...,
+            keyfile: Optional[str] = ...,
+            certfile: Optional[str] = ...,
+            ssl_context: Optional[SSLContext] = ...,
+            timeout: Optional[float] = ...,
+        ) -> None: ...
+    elif sys.version_info >= (3, 3):
+        def __init__(
+            self,
+            host: str = ...,
+            port: int = ...,
+            keyfile: Optional[str] = ...,
+            certfile: Optional[str] = ...,
+            ssl_context: Optional[SSLContext] = ...,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, host: str = ..., port: int = ..., keyfile: Optional[str] = ..., certfile: Optional[str] = ...
+        ) -> None: ...
+    host: str = ...
+    port: int = ...
+    sock: _socket = ...
+    sslobj: SSLSocket = ...
+    file: IO[Any] = ...
+    if sys.version_info >= (3, 9):
+        def open(self, host: str = ..., port: Optional[int] = ..., timeout: Optional[float] = ...) -> None: ...
+    else:
+        def open(self, host: str = ..., port: Optional[int] = ...) -> None: ...
+    def read(self, size: int) -> bytes: ...
+    def readline(self) -> bytes: ...
+    def send(self, data: bytes) -> None: ...
+    def shutdown(self) -> None: ...
+    def socket(self) -> _socket: ...
+    def ssl(self) -> SSLSocket: ...
+
+class IMAP4_stream(IMAP4):
+    command: str = ...
+    def __init__(self, command: str) -> None: ...
+    host: str = ...
+    port: int = ...
+    sock: _socket = ...
+    file: IO[Any] = ...
+    process: subprocess.Popen[bytes] = ...
+    writefile: IO[Any] = ...
+    readfile: IO[Any] = ...
+    if sys.version_info >= (3, 9):
+        def open(self, host: Optional[str] = ..., port: Optional[int] = ..., timeout: Optional[float] = ...) -> None: ...
+    else:
+        def open(self, host: Optional[str] = ..., port: Optional[int] = ...) -> None: ...
+    def read(self, size: int) -> bytes: ...
+    def readline(self) -> bytes: ...
+    def send(self, data: bytes) -> None: ...
+    def shutdown(self) -> None: ...
+
+class _Authenticator:
+    mech: Callable[[bytes], bytes] = ...
+    def __init__(self, mechinst: Callable[[bytes], bytes]) -> None: ...
+    def process(self, data: str) -> str: ...
+    def encode(self, inp: bytes) -> str: ...
+    def decode(self, inp: str) -> bytes: ...
+
+def Internaldate2tuple(resp: str) -> time.struct_time: ...
+def Int2AP(num: int) -> str: ...
+def ParseFlags(resp: str) -> Tuple[str]: ...
+def Time2Internaldate(date_time: Union[float, time.struct_time, str]) -> str: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/keyword.pyi

@@ -0,0 +1,10 @@
+import sys
+from typing import Sequence, Text
+
+def iskeyword(s: Text) -> bool: ...
+
+kwlist: Sequence[str]
+
+if sys.version_info >= (3, 9):
+    def issoftkeyword(s: str) -> bool: ...
+    softkwlist: Sequence[str]

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/mailcap.pyi

@@ -0,0 +1,8 @@
+from typing import Dict, List, Mapping, Optional, Sequence, Tuple, Union
+
+_Cap = Dict[str, Union[str, int]]
+
+def findmatch(
+    caps: Mapping[str, List[_Cap]], MIMEtype: str, key: str = ..., filename: str = ..., plist: Sequence[str] = ...
+) -> Tuple[Optional[str], Optional[_Cap]]: ...
+def getcaps() -> Dict[str, List[_Cap]]: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/mimetypes.pyi

@@ -0,0 +1,36 @@
+import sys
+from typing import IO, Dict, List, Optional, Sequence, Text, Tuple, Union
+
+if sys.version_info >= (3, 8):
+    from os import PathLike
+    def guess_type(url: Union[Text, PathLike[str]], strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ...
+
+else:
+    def guess_type(url: Text, strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ...
+
+def guess_all_extensions(type: str, strict: bool = ...) -> List[str]: ...
+def guess_extension(type: str, strict: bool = ...) -> Optional[str]: ...
+def init(files: Optional[Sequence[str]] = ...) -> None: ...
+def read_mime_types(filename: str) -> Optional[Dict[str, str]]: ...
+def add_type(type: str, ext: str, strict: bool = ...) -> None: ...
+
+inited: bool
+knownfiles: List[str]
+suffix_map: Dict[str, str]
+encodings_map: Dict[str, str]
+types_map: Dict[str, str]
+common_types: Dict[str, str]
+
+class MimeTypes:
+    suffix_map: Dict[str, str]
+    encodings_map: Dict[str, str]
+    types_map: Tuple[Dict[str, str], Dict[str, str]]
+    types_map_inv: Tuple[Dict[str, str], Dict[str, str]]
+    def __init__(self, filenames: Tuple[str, ...] = ..., strict: bool = ...) -> None: ...
+    def guess_extension(self, type: str, strict: bool = ...) -> Optional[str]: ...
+    def guess_type(self, url: str, strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ...
+    def guess_all_extensions(self, type: str, strict: bool = ...) -> List[str]: ...
+    def read(self, filename: str, strict: bool = ...) -> None: ...
+    def readfp(self, fp: IO[str], strict: bool = ...) -> None: ...
+    if sys.platform == "win32":
+        def read_windows_registry(self, strict: bool = ...) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/2and3/msvcrt.pyi

@@ -0,0 +1,24 @@
+import sys
+from typing import Text
+
+# This module is only available on Windows
+if sys.platform == "win32":
+    LK_LOCK: int
+    LK_NBLCK: int
+    LK_NBRLCK: int
+    LK_RLCK: int
+    LK_UNLCK: int
+    def locking(__fd: int, __mode: int, __nbytes: int) -> None: ...
+    def setmode(__fd: int, __mode: int) -> int: ...
+    def open_osfhandle(__handle: int, __flags: int) -> int: ...
+    def get_osfhandle(__fd: int) -> int: ...
+    def kbhit() -> bool: ...
+    def getch() -> bytes: ...
+    def getwch() -> Text: ...
+    def getche() -> bytes: ...
+    def getwche() -> Text: ...
+    def putch(__char: bytes) -> None: ...
+    def putwch(__unicode_char: Text) -> None: ...
+    def ungetch(__char: bytes) -> None: ...
+    def ungetwch(__unicode_char: Text) -> None: ...
+    def heapmin() -> None: ...