Add files using upload-large-folder tool

.gitattributes

@@ -474,3 +474,7 @@ material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:
 material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/xlsxwriter/__pycache__/worksheet.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Bold.ttf filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908298_m.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans.ttf filter=lfs diff=lfs merge=lfs -text
+material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pillow.libs/libbrotlicommon-c55a5f7a.so.1.1.0 filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908294_m.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/pygments/lexers/__pycache__/lisp.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

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

@@ -0,0 +1,6 @@
+import SimpleHTTPServer
+from typing import List
+
+class CGIHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
+    cgi_directories: List[str]
+    def do_POST(self) -> None: ...

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

@@ -0,0 +1,40 @@
+from typing import Any, Dict, Optional
+
+class CookieError(Exception): ...
+
+class Morsel(Dict[Any, Any]):
+    key: Any
+    def __init__(self): ...
+    def __setitem__(self, K, V): ...
+    def isReservedKey(self, K): ...
+    value: Any
+    coded_value: Any
+    def set(self, key, val, coded_val, LegalChars=..., idmap=..., translate=...): ...
+    def output(self, attrs: Optional[Any] = ..., header=...): ...
+    def js_output(self, attrs: Optional[Any] = ...): ...
+    def OutputString(self, attrs: Optional[Any] = ...): ...
+
+class BaseCookie(Dict[Any, Any]):
+    def value_decode(self, val): ...
+    def value_encode(self, val): ...
+    def __init__(self, input: Optional[Any] = ...): ...
+    def __setitem__(self, key, value): ...
+    def output(self, attrs: Optional[Any] = ..., header=..., sep=...): ...
+    def js_output(self, attrs: Optional[Any] = ...): ...
+    def load(self, rawdata): ...
+
+class SimpleCookie(BaseCookie):
+    def value_decode(self, val): ...
+    def value_encode(self, val): ...
+
+class SerialCookie(BaseCookie):
+    def __init__(self, input: Optional[Any] = ...): ...
+    def value_decode(self, val): ...
+    def value_encode(self, val): ...
+
+class SmartCookie(BaseCookie):
+    def __init__(self, input: Optional[Any] = ...): ...
+    def value_decode(self, val): ...
+    def value_encode(self, val): ...
+
+Cookie: Any

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

@@ -0,0 +1,51 @@
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Union, overload
+
+CODESIZE: int
+MAGIC: int
+MAXREPEAT: long
+copyright: str
+
+class SRE_Match(object):
+    def start(self, group: int = ...) -> int: ...
+    def end(self, group: int = ...) -> int: ...
+    def expand(self, s: str) -> Any: ...
+    @overload
+    def group(self) -> str: ...
+    @overload
+    def group(self, group: int = ...) -> Optional[str]: ...
+    def groupdict(self) -> Dict[int, Optional[str]]: ...
+    def groups(self) -> Tuple[Optional[str], ...]: ...
+    def span(self) -> Tuple[int, int]: ...
+    @property
+    def regs(self) -> Tuple[Tuple[int, int], ...]: ...  # undocumented
+
+class SRE_Scanner(object):
+    pattern: str
+    def match(self) -> SRE_Match: ...
+    def search(self) -> SRE_Match: ...
+
+class SRE_Pattern(object):
+    pattern: str
+    flags: int
+    groups: int
+    groupindex: Mapping[str, int]
+    indexgroup: Sequence[int]
+    def findall(self, source: str, pos: int = ..., endpos: int = ...) -> List[Union[Tuple[Any, ...], str]]: ...
+    def finditer(self, source: str, pos: int = ..., endpos: int = ...) -> Iterable[Union[Tuple[Any, ...], str]]: ...
+    def match(self, pattern, pos: int = ..., endpos: int = ...) -> SRE_Match: ...
+    def scanner(self, s: str, start: int = ..., end: int = ...) -> SRE_Scanner: ...
+    def search(self, pattern, pos: int = ..., endpos: int = ...) -> SRE_Match: ...
+    def split(self, source: str, maxsplit: int = ...) -> List[Optional[str]]: ...
+    def sub(self, repl: str, string: str, count: int = ...) -> Tuple[Any, ...]: ...
+    def subn(self, repl: str, string: str, count: int = ...) -> Tuple[Any, ...]: ...
+
+def compile(
+    pattern: str,
+    flags: int,
+    code: List[int],
+    groups: int = ...,
+    groupindex: Mapping[str, int] = ...,
+    indexgroup: Sequence[int] = ...,
+) -> SRE_Pattern: ...
+def getcodesize() -> int: ...
+def getlower(a: int, b: int) -> int: ...

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

@@ -0,0 +1,5 @@
+from typing import Any, TypeVar
+
+_FT = TypeVar("_FT")
+
+def register(func: _FT, *args: Any, **kargs: Any) -> _FT: ...

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

@@ -0,0 +1,21 @@
+from typing import Any, Callable, Dict, NoReturn, Optional, Tuple
+
+class error(Exception):
+    def __init__(self, *args: Any) -> None: ...
+
+def start_new_thread(function: Callable[..., Any], args: Tuple[Any, ...], kwargs: Dict[str, Any] = ...) -> None: ...
+def exit() -> NoReturn: ...
+def get_ident() -> int: ...
+def allocate_lock() -> LockType: ...
+def stack_size(size: Optional[int] = ...) -> int: ...
+
+class LockType(object):
+    locked_status: bool
+    def __init__(self) -> None: ...
+    def acquire(self, waitflag: Optional[bool] = ...) -> bool: ...
+    def __enter__(self, waitflag: Optional[bool] = ...) -> bool: ...
+    def __exit__(self, typ: Any, val: Any, tb: Any) -> None: ...
+    def release(self) -> bool: ...
+    def locked(self) -> bool: ...
+
+def interrupt_main() -> None: ...

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

@@ -0,0 +1,33 @@
+import types
+from typing import IO, Any, Iterable, List, Optional, Tuple
+
+C_BUILTIN: int
+C_EXTENSION: int
+IMP_HOOK: int
+PKG_DIRECTORY: int
+PY_CODERESOURCE: int
+PY_COMPILED: int
+PY_FROZEN: int
+PY_RESOURCE: int
+PY_SOURCE: int
+SEARCH_ERROR: int
+
+def acquire_lock() -> None: ...
+def find_module(name: str, path: Iterable[str] = ...) -> Optional[Tuple[IO[Any], str, Tuple[str, str, int]]]: ...
+def get_magic() -> str: ...
+def get_suffixes() -> List[Tuple[str, str, int]]: ...
+def init_builtin(name: str) -> types.ModuleType: ...
+def init_frozen(name: str) -> types.ModuleType: ...
+def is_builtin(name: str) -> int: ...
+def is_frozen(name: str) -> bool: ...
+def load_compiled(name: str, pathname: str, file: IO[Any] = ...) -> types.ModuleType: ...
+def load_dynamic(name: str, pathname: str, file: IO[Any] = ...) -> types.ModuleType: ...
+def load_module(name: str, file: str, pathname: str, description: Tuple[str, str, int]) -> types.ModuleType: ...
+def load_source(name: str, pathname: str, file: IO[Any] = ...) -> types.ModuleType: ...
+def lock_held() -> bool: ...
+def new_module(name: str) -> types.ModuleType: ...
+def release_lock() -> None: ...
+
+class NullImporter:
+    def __init__(self, path_string: str) -> None: ...
+    def find_module(self, fullname: str, path: str = ...) -> None: ...

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

@@ -0,0 +1,5 @@
+from hashlib import md5 as md5
+
+new = md5
+blocksize: int
+digest_size: int

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

@@ -0,0 +1,60 @@
+from typing import Any, Callable, Hashable, Iterable, Iterator, MutableMapping, Optional, TypeVar, Union
+
+_T = TypeVar("_T")
+_Setlike = Union[BaseSet[_T], Iterable[_T]]
+_SelfT = TypeVar("_SelfT")
+
+class BaseSet(Iterable[_T]):
+    def __init__(self) -> None: ...
+    def __len__(self) -> int: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __cmp__(self, other: Any) -> int: ...
+    def __eq__(self, other: Any) -> bool: ...
+    def __ne__(self, other: Any) -> bool: ...
+    def copy(self: _SelfT) -> _SelfT: ...
+    def __copy__(self: _SelfT) -> _SelfT: ...
+    def __deepcopy__(self: _SelfT, memo: MutableMapping[int, BaseSet[_T]]) -> _SelfT: ...
+    def __or__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ...
+    def union(self: _SelfT, other: _Setlike[_T]) -> _SelfT: ...
+    def __and__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ...
+    def intersection(self: _SelfT, other: _Setlike[Any]) -> _SelfT: ...
+    def __xor__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ...
+    def symmetric_difference(self: _SelfT, other: _Setlike[_T]) -> _SelfT: ...
+    def __sub__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ...
+    def difference(self: _SelfT, other: _Setlike[Any]) -> _SelfT: ...
+    def __contains__(self, element: Any) -> bool: ...
+    def issubset(self, other: BaseSet[_T]) -> bool: ...
+    def issuperset(self, other: BaseSet[_T]) -> bool: ...
+    def __le__(self, other: BaseSet[_T]) -> bool: ...
+    def __ge__(self, other: BaseSet[_T]) -> bool: ...
+    def __lt__(self, other: BaseSet[_T]) -> bool: ...
+    def __gt__(self, other: BaseSet[_T]) -> bool: ...
+
+class ImmutableSet(BaseSet[_T], Hashable):
+    def __init__(self, iterable: Optional[_Setlike[_T]] = ...) -> None: ...
+    def __hash__(self) -> int: ...
+
+class Set(BaseSet[_T]):
+    def __init__(self, iterable: Optional[_Setlike[_T]] = ...) -> None: ...
+    def __ior__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ...
+    def union_update(self, other: _Setlike[_T]) -> None: ...
+    def __iand__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ...
+    def intersection_update(self, other: _Setlike[Any]) -> None: ...
+    def __ixor__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ...
+    def symmetric_difference_update(self, other: _Setlike[_T]) -> None: ...
+    def __isub__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ...
+    def difference_update(self, other: _Setlike[Any]) -> None: ...
+    def update(self, iterable: _Setlike[_T]) -> None: ...
+    def clear(self) -> None: ...
+    def add(self, element: _T) -> None: ...
+    def remove(self, element: _T) -> None: ...
+    def discard(self, element: _T) -> None: ...
+    def pop(self) -> _T: ...
+    def __as_immutable__(self) -> ImmutableSet[_T]: ...
+    def __as_temporarily_immutable__(self) -> _TemporarilyImmutableSet[_T]: ...
+
+class _TemporarilyImmutableSet(BaseSet[_T]):
+    def __init__(self, set: BaseSet[_T]) -> None: ...
+    def __hash__(self) -> int: ...

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

@@ -0,0 +1,186 @@
+import ssl
+from httplib import HTTPConnectionProtocol, HTTPResponse
+from typing import Any, AnyStr, Callable, Dict, List, Mapping, Optional, Sequence, Text, Tuple, Type, Union
+from urllib import addinfourl
+
+_string = Union[str, unicode]
+
+class URLError(IOError):
+    reason: Union[str, BaseException]
+
+class HTTPError(URLError, addinfourl):
+    code: int
+    headers: Mapping[str, str]
+    def __init__(self, url, code: int, msg: str, hdrs: Mapping[str, str], fp: addinfourl) -> None: ...
+
+class Request(object):
+    host: str
+    port: str
+    data: str
+    headers: Dict[str, str]
+    unverifiable: bool
+    type: Optional[str]
+    origin_req_host = ...
+    unredirected_hdrs: Dict[str, str]
+    def __init__(
+        self,
+        url: str,
+        data: Optional[str] = ...,
+        headers: Dict[str, str] = ...,
+        origin_req_host: Optional[str] = ...,
+        unverifiable: bool = ...,
+    ) -> None: ...
+    def __getattr__(self, attr): ...
+    def get_method(self) -> str: ...
+    def add_data(self, data) -> None: ...
+    def has_data(self) -> bool: ...
+    def get_data(self) -> str: ...
+    def get_full_url(self) -> str: ...
+    def get_type(self): ...
+    def get_host(self) -> str: ...
+    def get_selector(self): ...
+    def set_proxy(self, host, type) -> None: ...
+    def has_proxy(self) -> bool: ...
+    def get_origin_req_host(self) -> str: ...
+    def is_unverifiable(self) -> bool: ...
+    def add_header(self, key: str, val: str) -> None: ...
+    def add_unredirected_header(self, key: str, val: str) -> None: ...
+    def has_header(self, header_name: str) -> bool: ...
+    def get_header(self, header_name: str, default: Optional[str] = ...) -> str: ...
+    def header_items(self): ...
+
+class OpenerDirector(object):
+    addheaders: List[Tuple[str, str]]
+    def add_handler(self, handler: BaseHandler) -> None: ...
+    def open(
+        self, fullurl: Union[Request, _string], data: Optional[_string] = ..., timeout: Optional[float] = ...
+    ) -> Optional[addinfourl]: ...
+    def error(self, proto: _string, *args: Any): ...
+
+# Note that this type is somewhat a lie. The return *can* be None if
+# a custom opener has been installed that fails to handle the request.
+def urlopen(
+    url: Union[Request, _string],
+    data: Optional[_string] = ...,
+    timeout: Optional[float] = ...,
+    cafile: Optional[_string] = ...,
+    capath: Optional[_string] = ...,
+    cadefault: bool = ...,
+    context: Optional[ssl.SSLContext] = ...,
+) -> addinfourl: ...
+def install_opener(opener: OpenerDirector) -> None: ...
+def build_opener(*handlers: Union[BaseHandler, Type[BaseHandler]]) -> OpenerDirector: ...
+
+class BaseHandler:
+    handler_order: int
+    parent: OpenerDirector
+    def add_parent(self, parent: OpenerDirector) -> None: ...
+    def close(self) -> None: ...
+    def __lt__(self, other: Any) -> bool: ...
+
+class HTTPErrorProcessor(BaseHandler):
+    def http_response(self, request, response): ...
+
+class HTTPDefaultErrorHandler(BaseHandler):
+    def http_error_default(self, req: Request, fp: addinfourl, code: int, msg: str, hdrs: Mapping[str, str]): ...
+
+class HTTPRedirectHandler(BaseHandler):
+    max_repeats: int
+    max_redirections: int
+    def redirect_request(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str], newurl): ...
+    def http_error_301(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ...
+    def http_error_302(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ...
+    def http_error_303(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ...
+    def http_error_307(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ...
+    inf_msg: str
+
+class ProxyHandler(BaseHandler):
+    proxies: Mapping[str, str]
+    def __init__(self, proxies: Optional[Mapping[str, str]] = ...): ...
+    def proxy_open(self, req: Request, proxy, type): ...
+
+class HTTPPasswordMgr:
+    def __init__(self) -> None: ...
+    def add_password(self, realm: Optional[Text], uri: Union[Text, Sequence[Text]], user: Text, passwd: Text) -> None: ...
+    def find_user_password(self, realm: Optional[Text], authuri: Text) -> Tuple[Any, Any]: ...
+    def reduce_uri(self, uri: _string, default_port: bool = ...) -> Tuple[Any, Any]: ...
+    def is_suburi(self, base: _string, test: _string) -> bool: ...
+
+class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr): ...
+
+class AbstractBasicAuthHandler:
+    def __init__(self, password_mgr: Optional[HTTPPasswordMgr] = ...) -> None: ...
+    def add_password(self, realm: Optional[Text], uri: Union[Text, Sequence[Text]], user: Text, passwd: Text) -> None: ...
+    def http_error_auth_reqed(self, authreq, host, req: Request, headers: Mapping[str, str]): ...
+    def retry_http_basic_auth(self, host, req: Request, realm): ...
+
+class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
+    auth_header: str
+    def http_error_401(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ...
+
+class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
+    auth_header: str
+    def http_error_407(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ...
+
+class AbstractDigestAuthHandler:
+    def __init__(self, passwd: Optional[HTTPPasswordMgr] = ...) -> None: ...
+    def add_password(self, realm: Optional[Text], uri: Union[Text, Sequence[Text]], user: Text, passwd: Text) -> None: ...
+    def reset_retry_count(self) -> None: ...
+    def http_error_auth_reqed(self, auth_header: str, host: str, req: Request, headers: Mapping[str, str]) -> None: ...
+    def retry_http_digest_auth(self, req: Request, auth: str) -> Optional[HTTPResponse]: ...
+    def get_cnonce(self, nonce: str) -> str: ...
+    def get_authorization(self, req: Request, chal: Mapping[str, str]) -> str: ...
+    def get_algorithm_impls(self, algorithm: str) -> Tuple[Callable[[str], str], Callable[[str, str], str]]: ...
+    def get_entity_digest(self, data: Optional[bytes], chal: Mapping[str, str]) -> Optional[str]: ...
+
+class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
+    auth_header: str
+    handler_order: int
+    def http_error_401(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ...
+
+class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
+    auth_header: str
+    handler_order: int
+    def http_error_407(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ...
+
+class AbstractHTTPHandler(BaseHandler):  # undocumented
+    def __init__(self, debuglevel: int = ...) -> None: ...
+    def set_http_debuglevel(self, level: int) -> None: ...
+    def do_request_(self, request: Request) -> Request: ...
+    def do_open(self, http_class: HTTPConnectionProtocol, req: Request, **http_conn_args: Optional[Any]) -> addinfourl: ...
+
+class HTTPHandler(AbstractHTTPHandler):
+    def http_open(self, req: Request) -> addinfourl: ...
+    def http_request(self, request: Request) -> Request: ...  # undocumented
+
+class HTTPSHandler(AbstractHTTPHandler):
+    def __init__(self, debuglevel: int = ..., context: Optional[ssl.SSLContext] = ...) -> None: ...
+    def https_open(self, req: Request) -> addinfourl: ...
+    def https_request(self, request: Request) -> Request: ...  # undocumented
+
+class HTTPCookieProcessor(BaseHandler):
+    def __init__(self, cookiejar: Optional[Any] = ...): ...
+    def http_request(self, request: Request): ...
+    def http_response(self, request: Request, response): ...
+
+class UnknownHandler(BaseHandler):
+    def unknown_open(self, req: Request): ...
+
+class FileHandler(BaseHandler):
+    def file_open(self, req: Request): ...
+    def get_names(self): ...
+    def open_local_file(self, req: Request): ...
+
+class FTPHandler(BaseHandler):
+    def ftp_open(self, req: Request): ...
+    def connect_ftp(self, user, passwd, host, port, dirs, timeout): ...
+
+class CacheFTPHandler(FTPHandler):
+    def __init__(self) -> None: ...
+    def setTimeout(self, t: Optional[float]): ...
+    def setMaxConns(self, m: int): ...
+    def check_cache(self): ...
+    def clear_cache(self): ...
+
+def parse_http_list(s: AnyStr) -> List[AnyStr]: ...
+def parse_keqv_list(l: List[AnyStr]) -> Dict[AnyStr, AnyStr]: ...

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

@@ -0,0 +1,248 @@
+from datetime import datetime
+from gzip import GzipFile
+from httplib import HTTPConnection, HTTPResponse, HTTPSConnection
+from ssl import SSLContext
+from StringIO import StringIO
+from time import struct_time
+from types import InstanceType
+from typing import IO, Any, AnyStr, Callable, Iterable, List, Mapping, MutableMapping, Optional, Tuple, Type, TypeVar, Union
+
+_Unmarshaller = Any
+_timeTuple = Tuple[int, int, int, int, int, int, int, int, int]
+# Represents types that can be compared against a DateTime object
+_dateTimeComp = Union[unicode, DateTime, datetime]
+# A "host description" used by Transport factories
+_hostDesc = Union[str, Tuple[str, Mapping[Any, Any]]]
+
+def escape(s: AnyStr, replace: Callable[[AnyStr, AnyStr, AnyStr], AnyStr] = ...) -> AnyStr: ...
+
+MAXINT: int
+MININT: int
+PARSE_ERROR: int
+SERVER_ERROR: int
+APPLICATION_ERROR: int
+SYSTEM_ERROR: int
+TRANSPORT_ERROR: int
+NOT_WELLFORMED_ERROR: int
+UNSUPPORTED_ENCODING: int
+INVALID_ENCODING_CHAR: int
+INVALID_XMLRPC: int
+METHOD_NOT_FOUND: int
+INVALID_METHOD_PARAMS: int
+INTERNAL_ERROR: int
+
+class Error(Exception): ...
+
+class ProtocolError(Error):
+    url: str
+    errcode: int
+    errmsg: str
+    headers: Any
+    def __init__(self, url: str, errcode: int, errmsg: str, headers: Any) -> None: ...
+
+class ResponseError(Error): ...
+
+class Fault(Error):
+    faultCode: Any
+    faultString: str
+    def __init__(self, faultCode: Any, faultString: str, **extra: Any) -> None: ...
+
+boolean: Type[bool]
+Boolean: Type[bool]
+
+class DateTime:
+    value: str
+    def __init__(self, value: Union[str, unicode, datetime, float, int, _timeTuple, struct_time] = ...) -> None: ...
+    def make_comparable(self, other: _dateTimeComp) -> Tuple[unicode, unicode]: ...
+    def __lt__(self, other: _dateTimeComp) -> bool: ...
+    def __le__(self, other: _dateTimeComp) -> bool: ...
+    def __gt__(self, other: _dateTimeComp) -> bool: ...
+    def __ge__(self, other: _dateTimeComp) -> bool: ...
+    def __eq__(self, other: _dateTimeComp) -> bool: ...  # type: ignore
+    def __ne__(self, other: _dateTimeComp) -> bool: ...  # type: ignore
+    def timetuple(self) -> struct_time: ...
+    def __cmp__(self, other: _dateTimeComp) -> int: ...
+    def decode(self, data: Any) -> None: ...
+    def encode(self, out: IO[str]) -> None: ...
+
+class Binary:
+    data: str
+    def __init__(self, data: Optional[str] = ...) -> None: ...
+    def __cmp__(self, other: Any) -> int: ...
+    def decode(self, data: str) -> None: ...
+    def encode(self, out: IO[str]) -> None: ...
+
+WRAPPERS: Tuple[Type[Any], ...]
+
+# Still part of the public API, but see http://bugs.python.org/issue1773632
+FastParser: None
+FastUnmarshaller: None
+FastMarshaller: None
+
+# xmlrpclib.py will leave ExpatParser undefined if it can't import expat from
+# xml.parsers. Because this is Python 2.7, the import will succeed.
+class ExpatParser:
+    def __init__(self, target: _Unmarshaller) -> None: ...
+    def feed(self, data: str): ...
+    def close(self): ...
+
+# TODO: Add xmllib.XMLParser as base class
+class SlowParser:
+    handle_xml: Callable[[str, bool], None]
+    unknown_starttag: Callable[[str, Any], None]
+    handle_data: Callable[[str], None]
+    handle_cdata: Callable[[str], None]
+    unknown_endtag: Callable[[str, Callable[[Iterable[str], str], str]], None]
+    def __init__(self, target: _Unmarshaller) -> None: ...
+
+class Marshaller:
+    memo: MutableMapping[int, Any]
+    data: Optional[str]
+    encoding: Optional[str]
+    allow_none: bool
+    def __init__(self, encoding: Optional[str] = ..., allow_none: bool = ...) -> None: ...
+    dispatch: Mapping[type, Callable[[Marshaller, str, Callable[[str], None]], None]]
+    def dumps(
+        self,
+        values: Union[
+            Iterable[
+                Union[
+                    None,
+                    int,
+                    bool,
+                    long,
+                    float,
+                    str,
+                    unicode,
+                    List[Any],
+                    Tuple[Any, ...],
+                    Mapping[Any, Any],
+                    datetime,
+                    InstanceType,
+                ]
+            ],
+            Fault,
+        ],
+    ) -> str: ...
+    def dump_nil(self, value: None, write: Callable[[str], None]) -> None: ...
+    def dump_int(self, value: int, write: Callable[[str], None]) -> None: ...
+    def dump_bool(self, value: bool, write: Callable[[str], None]) -> None: ...
+    def dump_long(self, value: long, write: Callable[[str], None]) -> None: ...
+    def dump_double(self, value: float, write: Callable[[str], None]) -> None: ...
+    def dump_string(
+        self,
+        value: str,
+        write: Callable[[str], None],
+        escape: Callable[[AnyStr, Callable[[AnyStr, AnyStr, AnyStr], AnyStr]], AnyStr] = ...,
+    ) -> None: ...
+    def dump_unicode(
+        self,
+        value: unicode,
+        write: Callable[[str], None],
+        escape: Callable[[AnyStr, Callable[[AnyStr, AnyStr, AnyStr], AnyStr]], AnyStr] = ...,
+    ) -> None: ...
+    def dump_array(self, value: Iterable[Any], write: Callable[[str], None]) -> None: ...
+    def dump_struct(
+        self,
+        value: Mapping[unicode, Any],
+        write: Callable[[str], None],
+        escape: Callable[[AnyStr, Callable[[AnyStr, AnyStr, AnyStr], AnyStr]], AnyStr] = ...,
+    ) -> None: ...
+    def dump_datetime(self, value: datetime, write: Callable[[str], None]) -> None: ...
+    def dump_instance(self, value: InstanceType, write: Callable[[str], None]) -> None: ...
+
+class Unmarshaller:
+    def append(self, object: Any) -> None: ...
+    def __init__(self, use_datetime: bool = ...) -> None: ...
+    def close(self) -> Tuple[Any, ...]: ...
+    def getmethodname(self) -> Optional[str]: ...
+    def xml(self, encoding: str, standalone: bool) -> None: ...
+    def start(self, tag: str, attrs: Any) -> None: ...
+    def data(self, text: str) -> None: ...
+    def end(self, tag: str, join: Callable[[Iterable[str], str], str] = ...) -> None: ...
+    def end_dispatch(self, tag: str, data: str) -> None: ...
+    dispatch: Mapping[str, Callable[[Unmarshaller, str], None]]
+    def end_nil(self, data: str): ...
+    def end_boolean(self, data: str) -> None: ...
+    def end_int(self, data: str) -> None: ...
+    def end_double(self, data: str) -> None: ...
+    def end_string(self, data: str) -> None: ...
+    def end_array(self, data: str) -> None: ...
+    def end_struct(self, data: str) -> None: ...
+    def end_base64(self, data: str) -> None: ...
+    def end_dateTime(self, data: str) -> None: ...
+    def end_value(self, data: str) -> None: ...
+    def end_params(self, data: str) -> None: ...
+    def end_fault(self, data: str) -> None: ...
+    def end_methodName(self, data: str) -> None: ...
+
+class _MultiCallMethod:
+    def __init__(self, call_list: List[Tuple[str, Tuple[Any, ...]]], name: str) -> None: ...
+
+class MultiCallIterator:
+    def __init__(self, results: List[Any]) -> None: ...
+
+class MultiCall:
+    def __init__(self, server: ServerProxy) -> None: ...
+    def __getattr__(self, name: str) -> _MultiCallMethod: ...
+    def __call__(self) -> MultiCallIterator: ...
+
+def getparser(use_datetime: bool = ...) -> Tuple[Union[ExpatParser, SlowParser], Unmarshaller]: ...
+def dumps(
+    params: Union[Tuple[Any, ...], Fault],
+    methodname: Optional[str] = ...,
+    methodresponse: Optional[bool] = ...,
+    encoding: Optional[str] = ...,
+    allow_none: bool = ...,
+) -> str: ...
+def loads(data: str, use_datetime: bool = ...) -> Tuple[Tuple[Any, ...], Optional[str]]: ...
+def gzip_encode(data: str) -> str: ...
+def gzip_decode(data: str, max_decode: int = ...) -> str: ...
+
+class GzipDecodedResponse(GzipFile):
+    stringio: StringIO[Any]
+    def __init__(self, response: HTTPResponse) -> None: ...
+    def close(self): ...
+
+class _Method:
+    def __init__(self, send: Callable[[str, Tuple[Any, ...]], Any], name: str) -> None: ...
+    def __getattr__(self, name: str) -> _Method: ...
+    def __call__(self, *args: Any) -> Any: ...
+
+class Transport:
+    user_agent: str
+    accept_gzip_encoding: bool
+    encode_threshold: Optional[int]
+    def __init__(self, use_datetime: bool = ...) -> None: ...
+    def request(self, host: _hostDesc, handler: str, request_body: str, verbose: bool = ...) -> Tuple[Any, ...]: ...
+    verbose: bool
+    def single_request(self, host: _hostDesc, handler: str, request_body: str, verbose: bool = ...) -> Tuple[Any, ...]: ...
+    def getparser(self) -> Tuple[Union[ExpatParser, SlowParser], Unmarshaller]: ...
+    def get_host_info(self, host: _hostDesc) -> Tuple[str, Optional[List[Tuple[str, str]]], Optional[Mapping[Any, Any]]]: ...
+    def make_connection(self, host: _hostDesc) -> HTTPConnection: ...
+    def close(self) -> None: ...
+    def send_request(self, connection: HTTPConnection, handler: str, request_body: str) -> None: ...
+    def send_host(self, connection: HTTPConnection, host: str) -> None: ...
+    def send_user_agent(self, connection: HTTPConnection) -> None: ...
+    def send_content(self, connection: HTTPConnection, request_body: str) -> None: ...
+    def parse_response(self, response: HTTPResponse) -> Tuple[Any, ...]: ...
+
+class SafeTransport(Transport):
+    def __init__(self, use_datetime: bool = ..., context: Optional[SSLContext] = ...) -> None: ...
+    def make_connection(self, host: _hostDesc) -> HTTPSConnection: ...
+
+class ServerProxy:
+    def __init__(
+        self,
+        uri: str,
+        transport: Optional[Transport] = ...,
+        encoding: Optional[str] = ...,
+        verbose: bool = ...,
+        allow_none: bool = ...,
+        use_datetime: bool = ...,
+        context: Optional[SSLContext] = ...,
+    ) -> None: ...
+    def __getattr__(self, name: str) -> _Method: ...
+    def __call__(self, attr: str) -> Optional[Transport]: ...
+
+Server = ServerProxy

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

@@ -0,0 +1,327 @@
+import sys
+import typing
+from typing import (
+    AbstractSet,
+    Any,
+    AsyncGenerator as AsyncGenerator,
+    AsyncIterable as AsyncIterable,
+    AsyncIterator as AsyncIterator,
+    Awaitable as Awaitable,
+    ByteString as ByteString,
+    Callable as Callable,
+    Collection as Collection,
+    Container as Container,
+    Coroutine as Coroutine,
+    Dict,
+    Generator as Generator,
+    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 as 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.
+if sys.version_info >= (3, 7):
+    def namedtuple(
+        typename: str,
+        field_names: Union[str, Iterable[str]],
+        *,
+        rename: bool = ...,
+        module: Optional[str] = ...,
+        defaults: Optional[Iterable[Any]] = ...,
+    ) -> Type[Tuple[Any, ...]]: ...
+
+else:
+    def namedtuple(
+        typename: str,
+        field_names: Union[str, Iterable[str]],
+        *,
+        verbose: bool = ...,
+        rename: bool = ...,
+        module: Optional[str] = ...,
+    ) -> Type[Tuple[Any, ...]]: ...
+
+class UserDict(MutableMapping[_KT, _VT]):
+    data: Dict[_KT, _VT]
+    def __init__(self, __dict: Optional[Mapping[_KT, _VT]] = ..., **kwargs: _VT) -> None: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: _KT) -> _VT: ...
+    def __setitem__(self, key: _KT, item: _VT) -> None: ...
+    def __delitem__(self, key: _KT) -> None: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def __contains__(self, key: object) -> bool: ...
+    def copy(self: _S) -> _S: ...
+    @classmethod
+    def fromkeys(cls: Type[_S], iterable: Iterable[_KT], value: Optional[_VT] = ...) -> _S: ...
+
+class UserList(MutableSequence[_T]):
+    data: List[_T]
+    def __init__(self, initlist: Optional[Iterable[_T]] = ...) -> None: ...
+    def __lt__(self, other: object) -> bool: ...
+    def __le__(self, other: object) -> bool: ...
+    def __gt__(self, other: object) -> bool: ...
+    def __ge__(self, other: object) -> bool: ...
+    def __contains__(self, item: object) -> bool: ...
+    def __len__(self) -> int: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __getitem__(self, i: slice) -> MutableSequence[_T]: ...
+    @overload
+    def __setitem__(self, i: int, o: _T) -> None: ...
+    @overload
+    def __setitem__(self, i: slice, o: Iterable[_T]) -> None: ...
+    def __delitem__(self, i: Union[int, slice]) -> None: ...
+    def __add__(self: _S, other: Iterable[_T]) -> _S: ...
+    def __iadd__(self: _S, other: Iterable[_T]) -> _S: ...
+    def __mul__(self: _S, n: int) -> _S: ...
+    def __imul__(self: _S, n: int) -> _S: ...
+    def append(self, item: _T) -> None: ...
+    def insert(self, i: int, item: _T) -> None: ...
+    def pop(self, i: int = ...) -> _T: ...
+    def remove(self, item: _T) -> None: ...
+    def clear(self) -> None: ...
+    def copy(self: _S) -> _S: ...
+    def count(self, item: _T) -> int: ...
+    def index(self, item: _T, *args: Any) -> int: ...
+    def reverse(self) -> None: ...
+    def sort(self, *args: Any, **kwds: Any) -> None: ...
+    def extend(self, other: Iterable[_T]) -> None: ...
+
+_UserStringT = TypeVar("_UserStringT", bound=UserString)
+
+class UserString(Sequence[str]):
+    data: str
+    def __init__(self, seq: object) -> None: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __complex__(self) -> complex: ...
+    def __getnewargs__(self) -> Tuple[str]: ...
+    def __lt__(self, string: Union[str, UserString]) -> bool: ...
+    def __le__(self, string: Union[str, UserString]) -> bool: ...
+    def __gt__(self, string: Union[str, UserString]) -> bool: ...
+    def __ge__(self, string: Union[str, UserString]) -> bool: ...
+    def __contains__(self, char: object) -> bool: ...
+    def __len__(self) -> int: ...
+    # It should return a str to implement Sequence correctly, but it doesn't.
+    def __getitem__(self: _UserStringT, i: Union[int, slice]) -> _UserStringT: ...  # type: ignore
+    def __add__(self: _UserStringT, other: object) -> _UserStringT: ...
+    def __mul__(self: _UserStringT, n: int) -> _UserStringT: ...
+    def __mod__(self: _UserStringT, args: Any) -> _UserStringT: ...
+    def capitalize(self: _UserStringT) -> _UserStringT: ...
+    def casefold(self: _UserStringT) -> _UserStringT: ...
+    def center(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ...
+    def count(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
+    if sys.version_info >= (3, 8):
+        def encode(self: _UserStringT, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> bytes: ...
+    else:
+        def encode(self: _UserStringT, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> _UserStringT: ...
+    def endswith(self, suffix: Union[str, Tuple[str, ...]], start: int = ..., end: int = ...) -> bool: ...
+    def expandtabs(self: _UserStringT, tabsize: int = ...) -> _UserStringT: ...
+    def find(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
+    def format(self, *args: Any, **kwds: Any) -> str: ...
+    def format_map(self, mapping: Mapping[str, Any]) -> str: ...
+    def index(self, sub: str, start: int = ..., end: int = ...) -> int: ...
+    def isalpha(self) -> bool: ...
+    def isalnum(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, seq: Iterable[str]) -> str: ...
+    def ljust(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ...
+    def lower(self: _UserStringT) -> _UserStringT: ...
+    def lstrip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ...
+    @staticmethod
+    @overload
+    def maketrans(x: Union[Dict[int, _T], Dict[str, _T], Dict[Union[str, int], _T]]) -> Dict[int, _T]: ...
+    @staticmethod
+    @overload
+    def maketrans(x: str, y: str, z: str = ...) -> Dict[int, Union[int, None]]: ...
+    def partition(self, sep: str) -> Tuple[str, str, str]: ...
+    if sys.version_info >= (3, 9):
+        def removeprefix(self: _UserStringT, __prefix: Union[str, UserString]) -> _UserStringT: ...
+        def removesuffix(self: _UserStringT, __suffix: Union[str, UserString]) -> _UserStringT: ...
+    def replace(
+        self: _UserStringT, old: Union[str, UserString], new: Union[str, UserString], maxsplit: int = ...
+    ) -> _UserStringT: ...
+    def rfind(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
+    def rindex(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ...
+    def rjust(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ...
+    def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
+    def rstrip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ...
+    def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+    def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+    def splitlines(self, keepends: bool = ...) -> List[str]: ...
+    def startswith(self, prefix: Union[str, Tuple[str, ...]], start: int = ..., end: int = ...) -> bool: ...
+    def strip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ...
+    def swapcase(self: _UserStringT) -> _UserStringT: ...
+    def title(self: _UserStringT) -> _UserStringT: ...
+    def translate(self: _UserStringT, *args: Any) -> _UserStringT: ...
+    def upper(self: _UserStringT) -> _UserStringT: ...
+    def zfill(self: _UserStringT, width: int) -> _UserStringT: ...
+
+class deque(MutableSequence[_T], Generic[_T]):
+    @property
+    def maxlen(self) -> Optional[int]: ...
+    def __init__(self, iterable: Iterable[_T] = ..., maxlen: Optional[int] = ...) -> None: ...
+    def append(self, x: _T) -> None: ...
+    def appendleft(self, x: _T) -> None: ...
+    def clear(self) -> None: ...
+    def copy(self) -> deque[_T]: ...
+    def count(self, x: _T) -> int: ...
+    def extend(self, iterable: Iterable[_T]) -> None: ...
+    def extendleft(self, iterable: Iterable[_T]) -> None: ...
+    def insert(self, i: int, x: _T) -> None: ...
+    def index(self, x: _T, start: int = ..., stop: int = ...) -> int: ...
+    def pop(self) -> _T: ...  # type: ignore
+    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: ...
+    # These methods of deque don't really take slices, but we need to
+    # define them as taking a slice to satisfy MutableSequence.
+    @overload
+    def __getitem__(self, index: int) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice) -> MutableSequence[_T]: ...
+    @overload
+    def __setitem__(self, i: int, x: _T) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
+    @overload
+    def __delitem__(self, i: int) -> None: ...
+    @overload
+    def __delitem__(self, s: slice) -> None: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __reversed__(self) -> Iterator[_T]: ...
+    def __iadd__(self: _S, iterable: Iterable[_T]) -> _S: ...
+    def __add__(self, other: deque[_T]) -> deque[_T]: ...
+    def __mul__(self, other: int) -> deque[_T]: ...
+    def __imul__(self, other: int) -> None: ...
+
+class Counter(Dict[_T, int], Generic[_T]):
+    @overload
+    def __init__(self, __iterable: None = ..., **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, __iterable: None = ...) -> None: ...
+    @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, __m: None = ..., **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]: ...  # type: ignore
+    def __pos__(self) -> Counter[_T]: ...
+    def __neg__(self) -> 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]: ...  # type: ignore
+
+class _OrderedDictKeysView(KeysView[_KT], Reversible[_KT]):
+    def __reversed__(self) -> Iterator[_KT]: ...
+
+class _OrderedDictItemsView(ItemsView[_KT, _VT], Reversible[Tuple[_KT, _VT]]):
+    def __reversed__(self) -> Iterator[Tuple[_KT, _VT]]: ...
+
+class _OrderedDictValuesView(ValuesView[_VT], Reversible[_VT]):
+    def __reversed__(self) -> Iterator[_VT]: ...
+
+class OrderedDict(Dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]):
+    def popitem(self, last: bool = ...) -> Tuple[_KT, _VT]: ...
+    def move_to_end(self, key: _KT, last: bool = ...) -> None: ...
+    def copy(self: _S) -> _S: ...
+    def __reversed__(self) -> Iterator[_KT]: ...
+    def keys(self) -> _OrderedDictKeysView[_KT]: ...
+    def items(self) -> _OrderedDictItemsView[_KT, _VT]: ...
+    def values(self) -> _OrderedDictValuesView[_VT]: ...
+
+class defaultdict(Dict[_KT, _VT], Generic[_KT, _VT]):
+    default_factory: Optional[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: ...
+    # TODO __reversed__
+    def copy(self: _S) -> _S: ...
+
+class ChainMap(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
+    def __init__(self, *maps: Mapping[_KT, _VT]) -> None: ...
+    @property
+    def maps(self) -> List[Mapping[_KT, _VT]]: ...
+    def new_child(self, m: Mapping[_KT, _VT] = ...) -> typing.ChainMap[_KT, _VT]: ...
+    @property
+    def parents(self) -> typing.ChainMap[_KT, _VT]: ...
+    def __setitem__(self, k: _KT, v: _VT) -> None: ...
+    def __delitem__(self, v: _KT) -> None: ...
+    def __getitem__(self, k: _KT) -> _VT: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def __len__(self) -> int: ...
+    def __missing__(self, key: _KT) -> _VT: ...  # undocumented

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

@@ -0,0 +1,27 @@
+from . import (
+    AsyncGenerator as AsyncGenerator,
+    AsyncIterable as AsyncIterable,
+    AsyncIterator as AsyncIterator,
+    Awaitable as Awaitable,
+    ByteString as ByteString,
+    Callable as Callable,
+    Collection as Collection,
+    Container as Container,
+    Coroutine as Coroutine,
+    Generator as Generator,
+    Hashable as Hashable,
+    ItemsView as ItemsView,
+    Iterable as Iterable,
+    Iterator as Iterator,
+    KeysView as KeysView,
+    Mapping as Mapping,
+    MappingView as MappingView,
+    MutableMapping as MutableMapping,
+    MutableSequence as MutableSequence,
+    MutableSet as MutableSet,
+    Reversible as Reversible,
+    Sequence as Sequence,
+    Set as Set,
+    Sized as Sized,
+    ValuesView as ValuesView,
+)

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/dbm/ndbm.pyi

@@ -0,0 +1,34 @@
+from types import TracebackType
+from typing import List, Optional, Type, TypeVar, Union, overload
+
+_T = TypeVar("_T")
+_KeyType = Union[str, bytes]
+_ValueType = Union[str, bytes]
+
+class error(OSError): ...
+
+library: str = ...
+
+# Actual typename dbm, not exposed by the implementation
+class _dbm:
+    def close(self) -> None: ...
+    def __getitem__(self, item: _KeyType) -> bytes: ...
+    def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
+    def __delitem__(self, key: _KeyType) -> None: ...
+    def __len__(self) -> int: ...
+    def __del__(self) -> None: ...
+    def __enter__(self) -> _dbm: ...
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+    ) -> None: ...
+    @overload
+    def get(self, k: _KeyType) -> Optional[bytes]: ...
+    @overload
+    def get(self, k: _KeyType, default: Union[bytes, _T]) -> Union[bytes, _T]: ...
+    def keys(self) -> List[bytes]: ...
+    def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
+    # Don't exist at runtime
+    __new__: None  # type: ignore
+    __init__: None  # type: ignore
+
+def open(__filename: str, __flags: str = ..., __mode: int = ...) -> _dbm: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/config.pyi

@@ -0,0 +1,17 @@
+from abc import abstractmethod
+from distutils.cmd import Command
+from typing import ClassVar, List, Optional, Tuple
+
+DEFAULT_PYPIRC: str
+
+class PyPIRCCommand(Command):
+    DEFAULT_REPOSITORY: ClassVar[str]
+    DEFAULT_REALM: ClassVar[str]
+    repository: None
+    realm: None
+    user_options: ClassVar[List[Tuple[str, Optional[str], str]]]
+    boolean_options: ClassVar[List[str]]
+    def initialize_options(self) -> None: ...
+    def finalize_options(self) -> None: ...
+    @abstractmethod
+    def run(self) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/core.pyi

@@ -0,0 +1,48 @@
+from distutils.cmd import Command as Command
+from distutils.dist import Distribution as Distribution
+from distutils.extension import Extension as Extension
+from typing import Any, List, Mapping, Optional, Tuple, Type, Union
+
+def setup(
+    *,
+    name: str = ...,
+    version: str = ...,
+    description: str = ...,
+    long_description: str = ...,
+    author: str = ...,
+    author_email: str = ...,
+    maintainer: str = ...,
+    maintainer_email: str = ...,
+    url: str = ...,
+    download_url: str = ...,
+    packages: List[str] = ...,
+    py_modules: List[str] = ...,
+    scripts: List[str] = ...,
+    ext_modules: List[Extension] = ...,
+    classifiers: List[str] = ...,
+    distclass: Type[Distribution] = ...,
+    script_name: str = ...,
+    script_args: List[str] = ...,
+    options: Mapping[str, Any] = ...,
+    license: str = ...,
+    keywords: Union[List[str], str] = ...,
+    platforms: Union[List[str], str] = ...,
+    cmdclass: Mapping[str, Type[Command]] = ...,
+    data_files: List[Tuple[str, List[str]]] = ...,
+    package_dir: Mapping[str, str] = ...,
+    obsoletes: List[str] = ...,
+    provides: List[str] = ...,
+    requires: List[str] = ...,
+    command_packages: List[str] = ...,
+    command_options: Mapping[str, Mapping[str, Tuple[Any, Any]]] = ...,
+    package_data: Mapping[str, List[str]] = ...,
+    include_package_data: bool = ...,
+    libraries: List[str] = ...,
+    headers: List[str] = ...,
+    ext_package: str = ...,
+    include_dirs: List[str] = ...,
+    password: str = ...,
+    fullname: str = ...,
+    **attrs: Any,
+) -> None: ...
+def run_setup(script_name: str, script_args: Optional[List[str]] = ..., stop_after: str = ...) -> Distribution: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/debug.pyi

@@ -0,0 +1 @@
+DEBUG: bool

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/dep_util.pyi

@@ -0,0 +1,5 @@
+from typing import List, Tuple
+
+def newer(source: str, target: str) -> bool: ...
+def newer_pairwise(sources: List[str], targets: List[str]) -> List[Tuple[str, str]]: ...
+def newer_group(sources: List[str], target: str, missing: str = ...) -> bool: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/fancy_getopt.pyi

@@ -0,0 +1,21 @@
+from typing import Any, List, Mapping, Optional, Tuple, Union, overload
+
+_Option = Tuple[str, Optional[str], str]
+_GR = Tuple[List[str], OptionDummy]
+
+def fancy_getopt(
+    options: List[_Option], negative_opt: Mapping[_Option, _Option], object: Any, args: Optional[List[str]]
+) -> Union[List[str], _GR]: ...
+def wrap_text(text: str, width: int) -> List[str]: ...
+
+class FancyGetopt:
+    def __init__(self, option_table: Optional[List[_Option]] = ...) -> None: ...
+    # TODO kinda wrong, `getopt(object=object())` is invalid
+    @overload
+    def getopt(self, args: Optional[List[str]] = ...) -> _GR: ...
+    @overload
+    def getopt(self, args: Optional[List[str]], object: Any) -> List[str]: ...
+    def get_option_order(self) -> List[Tuple[str, str]]: ...
+    def generate_help(self, header: Optional[str] = ...) -> List[str]: ...
+
+class OptionDummy: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/filelist.pyi

@@ -0,0 +1 @@
+class FileList: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/log.pyi

@@ -0,0 +1,25 @@
+from typing import Any
+
+DEBUG: int
+INFO: int
+WARN: int
+ERROR: int
+FATAL: int
+
+class Log:
+    def __init__(self, threshold: int = ...) -> None: ...
+    def log(self, level: int, msg: str, *args: Any) -> None: ...
+    def debug(self, msg: str, *args: Any) -> None: ...
+    def info(self, msg: str, *args: Any) -> None: ...
+    def warn(self, msg: str, *args: Any) -> None: ...
+    def error(self, msg: str, *args: Any) -> None: ...
+    def fatal(self, msg: str, *args: Any) -> None: ...
+
+def log(level: int, msg: str, *args: Any) -> None: ...
+def debug(msg: str, *args: Any) -> None: ...
+def info(msg: str, *args: Any) -> None: ...
+def warn(msg: str, *args: Any) -> None: ...
+def error(msg: str, *args: Any) -> None: ...
+def fatal(msg: str, *args: Any) -> None: ...
+def set_threshold(level: int) -> int: ...
+def set_verbosity(v: int) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/sysconfig.pyi

@@ -0,0 +1,14 @@
+from distutils.ccompiler import CCompiler
+from typing import Mapping, Optional, Union
+
+PREFIX: str
+EXEC_PREFIX: str
+
+def get_config_var(name: str) -> Union[int, str, None]: ...
+def get_config_vars(*args: str) -> Mapping[str, Union[int, str]]: ...
+def get_config_h_filename() -> str: ...
+def get_makefile_filename() -> str: ...
+def get_python_inc(plat_specific: bool = ..., prefix: Optional[str] = ...) -> str: ...
+def get_python_lib(plat_specific: bool = ..., standard_lib: bool = ..., prefix: Optional[str] = ...) -> str: ...
+def customize_compiler(compiler: CCompiler) -> None: ...
+def set_python_build() -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/text_file.pyi

@@ -0,0 +1,21 @@
+from typing import IO, List, Optional, Tuple, Union
+
+class TextFile:
+    def __init__(
+        self,
+        filename: Optional[str] = ...,
+        file: Optional[IO[str]] = ...,
+        *,
+        strip_comments: bool = ...,
+        lstrip_ws: bool = ...,
+        rstrip_ws: bool = ...,
+        skip_blanks: bool = ...,
+        join_lines: bool = ...,
+        collapse_join: bool = ...,
+    ) -> None: ...
+    def open(self, filename: str) -> None: ...
+    def close(self) -> None: ...
+    def warn(self, msg: str, line: Union[List[int], Tuple[int, int], int] = ...) -> None: ...
+    def readline(self) -> Optional[str]: ...
+    def readlines(self) -> List[str]: ...
+    def unreadline(self, line: str) -> str: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/util.pyi

@@ -0,0 +1,23 @@
+from typing import Any, Callable, List, Mapping, Optional, Tuple
+
+def get_platform() -> str: ...
+def convert_path(pathname: str) -> str: ...
+def change_root(new_root: str, pathname: str) -> str: ...
+def check_environ() -> None: ...
+def subst_vars(s: str, local_vars: Mapping[str, str]) -> None: ...
+def split_quoted(s: str) -> List[str]: ...
+def execute(
+    func: Callable[..., None], args: Tuple[Any, ...], msg: Optional[str] = ..., verbose: bool = ..., dry_run: bool = ...
+) -> None: ...
+def strtobool(val: str) -> bool: ...
+def byte_compile(
+    py_files: List[str],
+    optimize: int = ...,
+    force: bool = ...,
+    prefix: Optional[str] = ...,
+    base_dir: Optional[str] = ...,
+    verbose: bool = ...,
+    dry_run: bool = ...,
+    direct: Optional[bool] = ...,
+) -> None: ...
+def rfc822_escape(header: str) -> str: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/distutils/version.pyi

@@ -0,0 +1,38 @@
+from abc import abstractmethod
+from typing import Optional, Pattern, Tuple, TypeVar, Union
+
+_T = TypeVar("_T", bound=Version)
+
+class Version:
+    def __repr__(self) -> str: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __lt__(self: _T, other: Union[_T, str]) -> bool: ...
+    def __le__(self: _T, other: Union[_T, str]) -> bool: ...
+    def __gt__(self: _T, other: Union[_T, str]) -> bool: ...
+    def __ge__(self: _T, other: Union[_T, str]) -> bool: ...
+    @abstractmethod
+    def __init__(self, vstring: Optional[str] = ...) -> None: ...
+    @abstractmethod
+    def parse(self: _T, vstring: str) -> _T: ...
+    @abstractmethod
+    def __str__(self) -> str: ...
+    @abstractmethod
+    def _cmp(self: _T, other: Union[_T, str]) -> bool: ...
+
+class StrictVersion(Version):
+    version_re: Pattern[str]
+    version: Tuple[int, int, int]
+    prerelease: Optional[Tuple[str, int]]
+    def __init__(self, vstring: Optional[str] = ...) -> None: ...
+    def parse(self: _T, vstring: str) -> _T: ...
+    def __str__(self) -> str: ...
+    def _cmp(self: _T, other: Union[_T, str]) -> bool: ...
+
+class LooseVersion(Version):
+    component_re: Pattern[str]
+    vstring: str
+    version: Tuple[Union[str, int], ...]
+    def __init__(self, vstring: Optional[str] = ...) -> None: ...
+    def parse(self: _T, vstring: str) -> _T: ...
+    def __str__(self) -> str: ...
+    def _cmp(self: _T, other: Union[_T, str]) -> bool: ...

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

@@ -0,0 +1,23 @@
+from email.message import Message
+from email.policy import Policy
+from typing import IO, Callable
+
+def message_from_string(s: str, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
+def message_from_bytes(s: bytes, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
+def message_from_file(fp: IO[str], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
+def message_from_binary_file(fp: IO[bytes], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
+
+# Names in __all__ with no definition:
+#   base64mime
+#   charset
+#   encoders
+#   errors
+#   feedparser
+#   generator
+#   header
+#   iterators
+#   message
+#   mime
+#   parser
+#   quoprimime
+#   utils

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

@@ -0,0 +1,28 @@
+from typing import Any, Iterator, List, Optional
+
+QP: int  # undocumented
+BASE64: int  # undocumented
+SHORTEST: int  # undocumented
+
+class Charset:
+    input_charset: str
+    header_encoding: int
+    body_encoding: int
+    output_charset: Optional[str]
+    input_codec: Optional[str]
+    output_codec: Optional[str]
+    def __init__(self, input_charset: str = ...) -> None: ...
+    def get_body_encoding(self) -> str: ...
+    def get_output_charset(self) -> Optional[str]: ...
+    def header_encode(self, string: str) -> str: ...
+    def header_encode_lines(self, string: str, maxlengths: Iterator[int]) -> List[str]: ...
+    def body_encode(self, string: str) -> str: ...
+    def __str__(self) -> str: ...
+    def __eq__(self, other: Any) -> bool: ...
+    def __ne__(self, other: Any) -> bool: ...
+
+def add_charset(
+    charset: str, header_enc: Optional[int] = ..., body_enc: Optional[int] = ..., output_charset: Optional[str] = ...
+) -> None: ...
+def add_alias(alias: str, canonical: str) -> None: ...
+def add_codec(charset: str, codecname: str) -> None: ...

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

@@ -0,0 +1,11 @@
+from email.message import Message
+from typing import Any, Callable
+
+class ContentManager:
+    def __init__(self) -> None: ...
+    def get_content(self, msg: Message, *args: Any, **kw: Any) -> Any: ...
+    def set_content(self, msg: Message, obj: Any, *args: Any, **kw: Any) -> Any: ...
+    def add_get_handler(self, key: str, handler: Callable[..., Any]) -> None: ...
+    def add_set_handler(self, typekey: type, handler: Callable[..., Any]) -> None: ...
+
+raw_data_manager: ContentManager

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

@@ -0,0 +1,6 @@
+from email.message import Message
+
+def encode_base64(msg: Message) -> None: ...
+def encode_quopri(msg: Message) -> None: ...
+def encode_7or8bit(msg: Message) -> None: ...
+def encode_noop(msg: Message) -> None: ...

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

@@ -0,0 +1,17 @@
+class MessageError(Exception): ...
+class MessageParseError(MessageError): ...
+class HeaderParseError(MessageParseError): ...
+class BoundaryError(MessageParseError): ...
+class MultipartConversionError(MessageError, TypeError): ...
+class MessageDefect(ValueError): ...
+class NoBoundaryInMultipartDefect(MessageDefect): ...
+class StartBoundaryNotFoundDefect(MessageDefect): ...
+class FirstHeaderLineIsContinuationDefect(MessageDefect): ...
+class MisplacedEnvelopeHeaderDefect(MessageDefect): ...
+class MultipartInvariantViolationDefect(MessageDefect): ...
+class InvalidBase64PaddingDefect(MessageDefect): ...
+class InvalidBase64CharactersDefect(MessageDefect): ...
+class CloseBoundaryNotFoundDefect(MessageDefect): ...
+class MissingHeaderBodySeparatorDefect(MessageDefect): ...
+
+MalformedHeaderDefect = MissingHeaderBodySeparatorDefect

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

@@ -0,0 +1,21 @@
+from email.message import Message
+from email.policy import Policy
+from typing import Callable, Generic, TypeVar, overload
+
+_M = TypeVar("_M", bound=Message)
+
+class FeedParser(Generic[_M]):
+    @overload
+    def __init__(self: FeedParser[Message], _factory: None = ..., *, policy: Policy = ...) -> None: ...
+    @overload
+    def __init__(self, _factory: Callable[[], _M], *, policy: Policy = ...) -> None: ...
+    def feed(self, data: str) -> None: ...
+    def close(self) -> _M: ...
+
+class BytesFeedParser(Generic[_M]):
+    @overload
+    def __init__(self: BytesFeedParser[Message], _factory: None = ..., *, policy: Policy = ...) -> None: ...
+    @overload
+    def __init__(self, _factory: Callable[[], _M], *, policy: Policy = ...) -> None: ...
+    def feed(self, data: bytes) -> None: ...
+    def close(self) -> _M: ...

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

@@ -0,0 +1,18 @@
+from email.message import Message
+from email.policy import Policy
+from typing import BinaryIO, Optional, TextIO
+
+class Generator:
+    def clone(self, fp: TextIO) -> Generator: ...
+    def write(self, s: str) -> None: ...
+    def __init__(self, outfp: TextIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, policy: Policy = ...) -> None: ...
+    def flatten(self, msg: Message, unixfrom: bool = ..., linesep: Optional[str] = ...) -> None: ...
+
+class BytesGenerator:
+    def clone(self, fp: BinaryIO) -> BytesGenerator: ...
+    def write(self, s: str) -> None: ...
+    def __init__(self, outfp: BinaryIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, policy: Policy = ...) -> None: ...
+    def flatten(self, msg: Message, unixfrom: bool = ..., linesep: Optional[str] = ...) -> None: ...
+
+class DecodedGenerator(Generator):
+    def __init__(self, outfp: TextIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, fmt: Optional[str] = ...) -> None: ...

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

@@ -0,0 +1,26 @@
+from email.charset import Charset
+from typing import Any, List, Optional, Tuple, Union
+
+class Header:
+    def __init__(
+        self,
+        s: Union[bytes, str, None] = ...,
+        charset: Union[Charset, str, None] = ...,
+        maxlinelen: Optional[int] = ...,
+        header_name: Optional[str] = ...,
+        continuation_ws: str = ...,
+        errors: str = ...,
+    ) -> None: ...
+    def append(self, s: Union[bytes, str], charset: Union[Charset, str, None] = ..., errors: str = ...) -> None: ...
+    def encode(self, splitchars: str = ..., maxlinelen: Optional[int] = ..., linesep: str = ...) -> str: ...
+    def __str__(self) -> str: ...
+    def __eq__(self, other: Any) -> bool: ...
+    def __ne__(self, other: Any) -> bool: ...
+
+def decode_header(header: Union[Header, str]) -> List[Tuple[bytes, Optional[str]]]: ...
+def make_header(
+    decoded_seq: List[Tuple[bytes, Optional[str]]],
+    maxlinelen: Optional[int] = ...,
+    header_name: Optional[str] = ...,
+    continuation_ws: str = ...,
+) -> Header: ...

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

@@ -0,0 +1,90 @@
+from datetime import datetime as _datetime
+from email.errors import MessageDefect
+from email.policy import Policy
+from typing import Any, Dict, Mapping, Optional, Tuple, Union
+
+class BaseHeader(str):
+    @property
+    def name(self) -> str: ...
+    @property
+    def defects(self) -> Tuple[MessageDefect, ...]: ...
+    @property
+    def max_count(self) -> Optional[int]: ...
+    def __new__(cls, name: str, value: Any) -> BaseHeader: ...
+    def init(self, *args: Any, **kw: Any) -> None: ...
+    def fold(self, *, policy: Policy) -> str: ...
+
+class UnstructuredHeader:
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class UniqueUnstructuredHeader(UnstructuredHeader): ...
+
+class DateHeader:
+    datetime: _datetime
+    @classmethod
+    def parse(cls, string: Union[str, _datetime], kwds: Dict[str, Any]) -> None: ...
+
+class UniqueDateHeader(DateHeader): ...
+
+class AddressHeader:
+    groups: Tuple[Group, ...]
+    addresses: Tuple[Address, ...]
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class UniqueAddressHeader(AddressHeader): ...
+
+class SingleAddressHeader(AddressHeader):
+    @property
+    def address(self) -> Address: ...
+
+class UniqueSingleAddressHeader(SingleAddressHeader): ...
+
+class MIMEVersionHeader:
+    version: Optional[str]
+    major: Optional[int]
+    minor: Optional[int]
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class ParameterizedMIMEHeader:
+    params: Mapping[str, Any]
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class ContentTypeHeader(ParameterizedMIMEHeader):
+    content_type: str
+    maintype: str
+    subtype: str
+
+class ContentDispositionHeader(ParameterizedMIMEHeader):
+    content_disposition: str
+
+class ContentTransferEncodingHeader:
+    cte: str
+    @classmethod
+    def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ...
+
+class HeaderRegistry:
+    def __init__(self, base_class: BaseHeader = ..., default_class: BaseHeader = ..., use_default_map: bool = ...) -> None: ...
+    def map_to_type(self, name: str, cls: BaseHeader) -> None: ...
+    def __getitem__(self, name: str) -> BaseHeader: ...
+    def __call__(self, name: str, value: Any) -> BaseHeader: ...
+
+class Address:
+    display_name: str
+    username: str
+    domain: str
+    @property
+    def addr_spec(self) -> str: ...
+    def __init__(
+        self, display_name: str = ..., username: Optional[str] = ..., domain: Optional[str] = ..., addr_spec: Optional[str] = ...
+    ) -> None: ...
+    def __str__(self) -> str: ...
+
+class Group:
+    display_name: Optional[str]
+    addresses: Tuple[Address, ...]
+    def __init__(self, display_name: Optional[str] = ..., addresses: Optional[Tuple[Address, ...]] = ...) -> None: ...
+    def __str__(self) -> str: ...

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

@@ -0,0 +1,5 @@
+from email.message import Message
+from typing import Iterator, Optional
+
+def body_line_iterator(msg: Message, decode: bool = ...) -> Iterator[str]: ...
+def typed_subpart_iterator(msg: Message, maintype: str = ..., subtype: Optional[str] = ...) -> Iterator[str]: ...

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

@@ -0,0 +1,87 @@
+from email.charset import Charset
+from email.contentmanager import ContentManager
+from email.errors import MessageDefect
+from email.policy import Policy
+from typing import Any, Generator, Iterator, List, Optional, Sequence, Tuple, TypeVar, Union
+
+_T = TypeVar("_T")
+
+_PayloadType = Union[List[Message], str, bytes]
+_CharsetType = Union[Charset, str, None]
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+_ParamType = Union[str, Tuple[Optional[str], Optional[str], str]]
+_HeaderType = Any
+
+class Message:
+    preamble: Optional[str]
+    epilogue: Optional[str]
+    defects: List[MessageDefect]
+    def __str__(self) -> str: ...
+    def is_multipart(self) -> bool: ...
+    def set_unixfrom(self, unixfrom: str) -> None: ...
+    def get_unixfrom(self) -> Optional[str]: ...
+    def attach(self, payload: Message) -> None: ...
+    def get_payload(self, i: int = ..., decode: bool = ...) -> Any: ...  # returns Optional[_PayloadType]
+    def set_payload(self, payload: _PayloadType, charset: _CharsetType = ...) -> None: ...
+    def set_charset(self, charset: _CharsetType) -> None: ...
+    def get_charset(self) -> _CharsetType: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, name: str) -> bool: ...
+    def __getitem__(self, name: str) -> _HeaderType: ...
+    def __setitem__(self, name: str, val: _HeaderType) -> None: ...
+    def __delitem__(self, name: str) -> None: ...
+    def keys(self) -> List[str]: ...
+    def values(self) -> List[_HeaderType]: ...
+    def items(self) -> List[Tuple[str, _HeaderType]]: ...
+    def get(self, name: str, failobj: _T = ...) -> Union[_HeaderType, _T]: ...
+    def get_all(self, name: str, failobj: _T = ...) -> Union[List[_HeaderType], _T]: ...
+    def add_header(self, _name: str, _value: str, **_params: _ParamsType) -> None: ...
+    def replace_header(self, _name: str, _value: _HeaderType) -> None: ...
+    def get_content_type(self) -> str: ...
+    def get_content_maintype(self) -> str: ...
+    def get_content_subtype(self) -> str: ...
+    def get_default_type(self) -> str: ...
+    def set_default_type(self, ctype: str) -> None: ...
+    def get_params(self, failobj: _T = ..., header: str = ..., unquote: bool = ...) -> Union[List[Tuple[str, str]], _T]: ...
+    def get_param(self, param: str, failobj: _T = ..., header: str = ..., unquote: bool = ...) -> Union[_T, _ParamType]: ...
+    def del_param(self, param: str, header: str = ..., requote: bool = ...) -> None: ...
+    def set_type(self, type: str, header: str = ..., requote: bool = ...) -> None: ...
+    def get_filename(self, failobj: _T = ...) -> Union[_T, str]: ...
+    def get_boundary(self, failobj: _T = ...) -> Union[_T, str]: ...
+    def set_boundary(self, boundary: str) -> None: ...
+    def get_content_charset(self, failobj: _T = ...) -> Union[_T, str]: ...
+    def get_charsets(self, failobj: _T = ...) -> Union[_T, List[str]]: ...
+    def walk(self) -> Generator[Message, None, None]: ...
+    def get_content_disposition(self) -> Optional[str]: ...
+    def as_string(self, unixfrom: bool = ..., maxheaderlen: int = ..., policy: Optional[Policy] = ...) -> str: ...
+    def as_bytes(self, unixfrom: bool = ..., policy: Optional[Policy] = ...) -> bytes: ...
+    def __bytes__(self) -> bytes: ...
+    def set_param(
+        self,
+        param: str,
+        value: str,
+        header: str = ...,
+        requote: bool = ...,
+        charset: str = ...,
+        language: str = ...,
+        replace: bool = ...,
+    ) -> None: ...
+    def __init__(self, policy: Policy = ...) -> None: ...
+
+class MIMEPart(Message):
+    def get_body(self, preferencelist: Sequence[str] = ...) -> Optional[Message]: ...
+    def iter_attachments(self) -> Iterator[Message]: ...
+    def iter_parts(self) -> Iterator[Message]: ...
+    def get_content(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> Any: ...
+    def set_content(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
+    def make_related(self, boundary: Optional[str] = ...) -> None: ...
+    def make_alternative(self, boundary: Optional[str] = ...) -> None: ...
+    def make_mixed(self, boundary: Optional[str] = ...) -> None: ...
+    def add_related(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
+    def add_alternative(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
+    def add_attachment(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ...
+    def clear(self) -> None: ...
+    def clear_content(self) -> None: ...
+    def is_attachment(self) -> bool: ...
+
+class EmailMessage(MIMEPart): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/email/mime/application.pyi

@@ -0,0 +1,16 @@
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+from typing import Callable, Optional, Tuple, Union
+
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+
+class MIMEApplication(MIMENonMultipart):
+    def __init__(
+        self,
+        _data: Union[str, bytes],
+        _subtype: str = ...,
+        _encoder: Callable[[MIMEApplication], None] = ...,
+        *,
+        policy: Optional[Policy] = ...,
+        **_params: _ParamsType,
+    ) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/email/mime/base.pyi

@@ -0,0 +1,8 @@
+import email.message
+from email.policy import Policy
+from typing import Optional, Tuple, Union
+
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+
+class MIMEBase(email.message.Message):
+    def __init__(self, _maintype: str, _subtype: str, *, policy: Optional[Policy] = ..., **_params: _ParamsType) -> None: ...

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

@@ -0,0 +1,7 @@
+from email.message import Message
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+from typing import Optional
+
+class MIMEMessage(MIMENonMultipart):
+    def __init__(self, _msg: Message, _subtype: str = ..., *, policy: Optional[Policy] = ...) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/email/mime/multipart.pyi

@@ -0,0 +1,17 @@
+from email.message import Message
+from email.mime.base import MIMEBase
+from email.policy import Policy
+from typing import Optional, Sequence, Tuple, Union
+
+_ParamsType = Union[str, None, Tuple[str, Optional[str], str]]
+
+class MIMEMultipart(MIMEBase):
+    def __init__(
+        self,
+        _subtype: str = ...,
+        boundary: Optional[str] = ...,
+        _subparts: Optional[Sequence[Message]] = ...,
+        *,
+        policy: Optional[Policy] = ...,
+        **_params: _ParamsType,
+    ) -> None: ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/email/mime/text.pyi

@@ -0,0 +1,8 @@
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+from typing import Optional
+
+class MIMEText(MIMENonMultipart):
+    def __init__(
+        self, _text: str, _subtype: str = ..., _charset: Optional[str] = ..., *, policy: Optional[Policy] = ...
+    ) -> None: ...

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

@@ -0,0 +1,27 @@
+import email.feedparser
+from email.message import Message
+from email.policy import Policy
+from typing import BinaryIO, Callable, TextIO
+
+FeedParser = email.feedparser.FeedParser
+BytesFeedParser = email.feedparser.BytesFeedParser
+
+class Parser:
+    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ...
+    def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
+
+class HeaderParser(Parser):
+    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ...
+    def parsestr(self, text: str, headersonly: bool = ...) -> Message: ...
+
+class BytesHeaderParser(BytesParser):
+    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ...
+    def parsebytes(self, text: bytes, headersonly: bool = ...) -> Message: ...
+
+class BytesParser:
+    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ...
+    def parsebytes(self, text: bytes, headersonly: bool = ...) -> Message: ...

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

@@ -0,0 +1,54 @@
+from abc import abstractmethod
+from email.contentmanager import ContentManager
+from email.errors import MessageDefect
+from email.header import Header
+from email.message import Message
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+class Policy:
+    max_line_length: Optional[int]
+    linesep: str
+    cte_type: str
+    raise_on_defect: bool
+    mange_from: bool
+    def __init__(self, **kw: Any) -> None: ...
+    def clone(self, **kw: Any) -> Policy: ...
+    def handle_defect(self, obj: Message, defect: MessageDefect) -> None: ...
+    def register_defect(self, obj: Message, defect: MessageDefect) -> None: ...
+    def header_max_count(self, name: str) -> Optional[int]: ...
+    @abstractmethod
+    def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ...
+    @abstractmethod
+    def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ...
+    @abstractmethod
+    def header_fetch_parse(self, name: str, value: str) -> str: ...
+    @abstractmethod
+    def fold(self, name: str, value: str) -> str: ...
+    @abstractmethod
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+class Compat32(Policy):
+    def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ...
+    def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ...
+    def header_fetch_parse(self, name: str, value: str) -> Union[str, Header]: ...  # type: ignore
+    def fold(self, name: str, value: str) -> str: ...
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+compat32: Compat32
+
+class EmailPolicy(Policy):
+    utf8: bool
+    refold_source: str
+    header_factory: Callable[[str, str], str]
+    content_manager: ContentManager
+    def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ...
+    def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ...
+    def header_fetch_parse(self, name: str, value: str) -> str: ...
+    def fold(self, name: str, value: str) -> str: ...
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+default: EmailPolicy
+SMTP: EmailPolicy
+SMTPUTF8: EmailPolicy
+HTTP: EmailPolicy
+strict: EmailPolicy

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

@@ -0,0 +1,40 @@
+import datetime
+import sys
+from email.charset import Charset
+from typing import List, Optional, Tuple, Union, overload
+
+_ParamType = Union[str, Tuple[Optional[str], Optional[str], str]]
+_PDTZ = Tuple[int, int, int, int, int, int, int, int, int, Optional[int]]
+
+def quote(str: str) -> str: ...
+def unquote(str: str) -> str: ...
+def parseaddr(address: Optional[str]) -> Tuple[str, str]: ...
+def formataddr(pair: Tuple[Optional[str], str], charset: Union[str, Charset] = ...) -> str: ...
+def getaddresses(fieldvalues: List[str]) -> List[Tuple[str, str]]: ...
+@overload
+def parsedate(date: None) -> None: ...
+@overload
+def parsedate(date: str) -> Optional[Tuple[int, int, int, int, int, int, int, int, int]]: ...
+@overload
+def parsedate_tz(date: None) -> None: ...
+@overload
+def parsedate_tz(date: str) -> Optional[_PDTZ]: ...
+
+if sys.version_info >= (3, 10):
+    @overload
+    def parsedate_to_datetime(date: None) -> None: ...
+    @overload
+    def parsedate_to_datetime(date: str) -> datetime.datetime: ...
+
+else:
+    def parsedate_to_datetime(date: str) -> datetime.datetime: ...
+
+def mktime_tz(tuple: _PDTZ) -> int: ...
+def formatdate(timeval: Optional[float] = ..., localtime: bool = ..., usegmt: bool = ...) -> str: ...
+def format_datetime(dt: datetime.datetime, usegmt: bool = ...) -> str: ...
+def localtime(dt: Optional[datetime.datetime] = ...) -> datetime.datetime: ...
+def make_msgid(idstring: Optional[str] = ..., domain: Optional[str] = ...) -> str: ...
+def decode_rfc2231(s: str) -> Tuple[Optional[str], Optional[str], str]: ...
+def encode_rfc2231(s: str, charset: Optional[str] = ..., language: Optional[str] = ...) -> str: ...
+def collapse_rfc2231_value(value: _ParamType, errors: str = ..., fallback_charset: str = ...) -> str: ...
+def decode_params(params: List[Tuple[str, str]]) -> List[Tuple[str, _ParamType]]: ...

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

@@ -0,0 +1,123 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing import AbstractSet, Optional
+
+class _Hash(object):
+    digest_size: int
+    block_size: int
+
+    # [Python documentation note] Changed in version 3.4: The name attribute has
+    # been present in CPython since its inception, but until Python 3.4 was not
+    # formally specified, so may not exist on some platforms
+    name: str
+    def __init__(self, data: ReadableBuffer = ...) -> None: ...
+    def copy(self) -> _Hash: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, __data: ReadableBuffer) -> None: ...
+
+if sys.version_info >= (3, 9):
+    def md5(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
+    def sha1(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
+    def sha224(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
+    def sha256(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
+    def sha384(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
+    def sha512(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ...
+
+elif sys.version_info >= (3, 8):
+    def md5(string: ReadableBuffer = ...) -> _Hash: ...
+    def sha1(string: ReadableBuffer = ...) -> _Hash: ...
+    def sha224(string: ReadableBuffer = ...) -> _Hash: ...
+    def sha256(string: ReadableBuffer = ...) -> _Hash: ...
+    def sha384(string: ReadableBuffer = ...) -> _Hash: ...
+    def sha512(string: ReadableBuffer = ...) -> _Hash: ...
+
+else:
+    def md5(__string: ReadableBuffer = ...) -> _Hash: ...
+    def sha1(__string: ReadableBuffer = ...) -> _Hash: ...
+    def sha224(__string: ReadableBuffer = ...) -> _Hash: ...
+    def sha256(__string: ReadableBuffer = ...) -> _Hash: ...
+    def sha384(__string: ReadableBuffer = ...) -> _Hash: ...
+    def sha512(__string: ReadableBuffer = ...) -> _Hash: ...
+
+def new(name: str, data: ReadableBuffer = ...) -> _Hash: ...
+
+algorithms_guaranteed: AbstractSet[str]
+algorithms_available: AbstractSet[str]
+
+def pbkdf2_hmac(
+    hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: Optional[int] = ...
+) -> bytes: ...
+
+class _VarLenHash(object):
+    digest_size: int
+    block_size: int
+    name: str
+    def __init__(self, data: ReadableBuffer = ...) -> None: ...
+    def copy(self) -> _VarLenHash: ...
+    def digest(self, __length: int) -> bytes: ...
+    def hexdigest(self, __length: int) -> str: ...
+    def update(self, __data: ReadableBuffer) -> None: ...
+
+sha3_224 = _Hash
+sha3_256 = _Hash
+sha3_384 = _Hash
+sha3_512 = _Hash
+shake_128 = _VarLenHash
+shake_256 = _VarLenHash
+
+def scrypt(
+    password: ReadableBuffer,
+    *,
+    salt: Optional[ReadableBuffer] = ...,
+    n: Optional[int] = ...,
+    r: Optional[int] = ...,
+    p: Optional[int] = ...,
+    maxmem: int = ...,
+    dklen: int = ...,
+) -> bytes: ...
+
+class _BlakeHash(_Hash):
+    MAX_DIGEST_SIZE: int
+    MAX_KEY_SIZE: int
+    PERSON_SIZE: int
+    SALT_SIZE: int
+
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            __data: ReadableBuffer = ...,
+            *,
+            digest_size: int = ...,
+            key: ReadableBuffer = ...,
+            salt: ReadableBuffer = ...,
+            person: ReadableBuffer = ...,
+            fanout: int = ...,
+            depth: int = ...,
+            leaf_size: int = ...,
+            node_offset: int = ...,
+            node_depth: int = ...,
+            inner_size: int = ...,
+            last_node: bool = ...,
+            usedforsecurity: bool = ...,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            __data: ReadableBuffer = ...,
+            *,
+            digest_size: int = ...,
+            key: ReadableBuffer = ...,
+            salt: ReadableBuffer = ...,
+            person: ReadableBuffer = ...,
+            fanout: int = ...,
+            depth: int = ...,
+            leaf_size: int = ...,
+            node_offset: int = ...,
+            node_depth: int = ...,
+            inner_size: int = ...,
+            last_node: bool = ...,
+        ) -> None: ...
+
+blake2b = _BlakeHash
+blake2s = _BlakeHash

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/http/client.pyi

@@ -0,0 +1,211 @@
+import email.message
+import io
+import ssl
+import sys
+import types
+from socket import socket
+from typing import (
+    IO,
+    Any,
+    BinaryIO,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Protocol,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+_DataType = Union[bytes, IO[Any], Iterable[bytes], str]
+_T = TypeVar("_T")
+
+HTTP_PORT: int
+HTTPS_PORT: int
+
+CONTINUE: int
+SWITCHING_PROTOCOLS: int
+PROCESSING: int
+
+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
+
+MULTIPLE_CHOICES: int
+MOVED_PERMANENTLY: int
+FOUND: int
+SEE_OTHER: int
+NOT_MODIFIED: int
+USE_PROXY: int
+TEMPORARY_REDIRECT: int
+
+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
+PRECONDITION_REQUIRED: int
+TOO_MANY_REQUESTS: int
+REQUEST_HEADER_FIELDS_TOO_LARGE: int
+
+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
+NETWORK_AUTHENTICATION_REQUIRED: int
+
+responses: Dict[int, str]
+
+class HTTPMessage(email.message.Message): ...
+
+def parse_headers(fp: io.BufferedIOBase, _class: Callable[[], email.message.Message] = ...) -> HTTPMessage: ...
+
+class HTTPResponse(io.BufferedIOBase, BinaryIO):
+    msg: HTTPMessage
+    headers: HTTPMessage
+    version: int
+    debuglevel: int
+    closed: bool
+    status: int
+    reason: str
+    def __init__(self, sock: socket, debuglevel: int = ..., method: Optional[str] = ..., url: Optional[str] = ...) -> None: ...
+    def read(self, amt: Optional[int] = ...) -> bytes: ...
+    @overload
+    def getheader(self, name: str) -> Optional[str]: ...
+    @overload
+    def getheader(self, name: str, default: _T) -> Union[str, _T]: ...
+    def getheaders(self) -> List[Tuple[str, str]]: ...
+    def fileno(self) -> int: ...
+    def isclosed(self) -> bool: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+    def __enter__(self) -> HTTPResponse: ...
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[types.TracebackType]
+    ) -> Optional[bool]: ...
+    def info(self) -> email.message.Message: ...
+    def geturl(self) -> str: ...
+    def getcode(self) -> int: ...
+    def begin(self) -> None: ...
+
+# This is an API stub only for the class below, not a class itself.
+# urllib.request uses it for a parameter.
+class _HTTPConnectionProtocol(Protocol):
+    if sys.version_info >= (3, 7):
+        def __call__(
+            self,
+            host: str,
+            port: Optional[int] = ...,
+            timeout: float = ...,
+            source_address: Optional[Tuple[str, int]] = ...,
+            blocksize: int = ...,
+        ) -> HTTPConnection: ...
+    else:
+        def __call__(
+            self, host: str, port: Optional[int] = ..., timeout: float = ..., source_address: Optional[Tuple[str, int]] = ...
+        ) -> HTTPConnection: ...
+
+class HTTPConnection:
+    timeout: Optional[float]
+    host: str
+    port: int
+    sock: Any
+    if sys.version_info >= (3, 7):
+        def __init__(
+            self,
+            host: str,
+            port: Optional[int] = ...,
+            timeout: Optional[float] = ...,
+            source_address: Optional[Tuple[str, int]] = ...,
+            blocksize: int = ...,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            host: str,
+            port: Optional[int] = ...,
+            timeout: Optional[float] = ...,
+            source_address: Optional[Tuple[str, int]] = ...,
+        ) -> None: ...
+    def request(
+        self,
+        method: str,
+        url: str,
+        body: Optional[_DataType] = ...,
+        headers: Mapping[str, str] = ...,
+        *,
+        encode_chunked: bool = ...,
+    ) -> None: ...
+    def getresponse(self) -> HTTPResponse: ...
+    def set_debuglevel(self, level: int) -> None: ...
+    def set_tunnel(self, host: str, port: Optional[int] = ..., headers: Optional[Mapping[str, str]] = ...) -> None: ...
+    def connect(self) -> None: ...
+    def close(self) -> None: ...
+    def putrequest(self, method: str, url: str, skip_host: bool = ..., skip_accept_encoding: bool = ...) -> None: ...
+    def putheader(self, header: str, *argument: str) -> None: ...
+    def endheaders(self, message_body: Optional[_DataType] = ..., *, encode_chunked: bool = ...) -> None: ...
+    def send(self, data: _DataType) -> None: ...
+
+class HTTPSConnection(HTTPConnection):
+    def __init__(
+        self,
+        host: str,
+        port: Optional[int] = ...,
+        key_file: Optional[str] = ...,
+        cert_file: Optional[str] = ...,
+        timeout: Optional[float] = ...,
+        source_address: Optional[Tuple[str, int]] = ...,
+        *,
+        context: Optional[ssl.SSLContext] = ...,
+        check_hostname: Optional[bool] = ...,
+    ) -> None: ...
+
+class HTTPException(Exception): ...
+
+error = HTTPException
+
+class NotConnected(HTTPException): ...
+class InvalidURL(HTTPException): ...
+class UnknownProtocol(HTTPException): ...
+class UnknownTransferEncoding(HTTPException): ...
+class UnimplementedFileMode(HTTPException): ...
+class IncompleteRead(HTTPException): ...
+class ImproperConnectionState(HTTPException): ...
+class CannotSendRequest(ImproperConnectionState): ...
+class CannotSendHeader(ImproperConnectionState): ...
+class ResponseNotReady(ImproperConnectionState): ...
+class BadStatusLine(HTTPException): ...
+class LineTooLong(HTTPException): ...
+class RemoteDisconnected(ConnectionResetError, BadStatusLine): ...

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/jedi/third_party/typeshed/stdlib/3/importlib/util.pyi

@@ -0,0 +1,40 @@
+import importlib.abc
+import importlib.machinery
+import os
+import types
+from typing import Any, Callable, List, Optional, Union
+
+def module_for_loader(fxn: Callable[..., types.ModuleType]) -> Callable[..., types.ModuleType]: ...
+def set_loader(fxn: Callable[..., types.ModuleType]) -> Callable[..., types.ModuleType]: ...
+def set_package(fxn: Callable[..., types.ModuleType]) -> Callable[..., types.ModuleType]: ...
+def resolve_name(name: str, package: str) -> str: ...
+
+MAGIC_NUMBER: bytes
+
+def cache_from_source(path: str, debug_override: Optional[bool] = ..., *, optimization: Optional[Any] = ...) -> str: ...
+def source_from_cache(path: str) -> str: ...
+def decode_source(source_bytes: bytes) -> str: ...
+def find_spec(name: str, package: Optional[str] = ...) -> Optional[importlib.machinery.ModuleSpec]: ...
+def spec_from_loader(
+    name: str,
+    loader: Optional[importlib.abc.Loader],
+    *,
+    origin: Optional[str] = ...,
+    loader_state: Optional[Any] = ...,
+    is_package: Optional[bool] = ...,
+) -> importlib.machinery.ModuleSpec: ...
+def spec_from_file_location(
+    name: str,
+    location: Union[str, bytes, os.PathLike[str], os.PathLike[bytes]],
+    *,
+    loader: Optional[importlib.abc.Loader] = ...,
+    submodule_search_locations: Optional[List[str]] = ...,
+) -> importlib.machinery.ModuleSpec: ...
+def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ...
+
+class LazyLoader(importlib.abc.Loader):
+    def __init__(self, loader: importlib.abc.Loader) -> None: ...
+    @classmethod
+    def factory(cls, loader: importlib.abc.Loader) -> Callable[..., LazyLoader]: ...
+    def create_module(self, spec: importlib.machinery.ModuleSpec) -> Optional[types.ModuleType]: ...
+    def exec_module(self, module: types.ModuleType) -> None: ...