Add files using upload-large-folder tool

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3.9/graphlib.pyi

@@ -0,0 +1,16 @@
+from _typeshed import SupportsItems
+from typing import Generic, Iterable, Optional, Tuple, TypeVar
+
+_T = TypeVar("_T")
+
+class TopologicalSorter(Generic[_T]):
+    def __init__(self, graph: Optional[SupportsItems[_T, Iterable[_T]]] = ...) -> None: ...
+    def add(self, node: _T, *predecessors: _T) -> None: ...
+    def prepare(self) -> None: ...
+    def is_active(self) -> bool: ...
+    def __bool__(self) -> bool: ...
+    def done(self, *nodes: _T) -> None: ...
+    def get_ready(self) -> Tuple[_T, ...]: ...
+    def static_order(self) -> Iterable[_T]: ...
+
+class CycleError(ValueError): ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3.9/zoneinfo/__init__.pyi

@@ -0,0 +1,32 @@
+import os
+import typing
+from datetime import tzinfo
+from typing import Any, AnyStr, Iterable, Optional, Protocol, Sequence, Set, Type, Union
+
+_T = typing.TypeVar("_T", bound="ZoneInfo")
+
+class _IOBytes(Protocol):
+    def read(self, __size: int) -> bytes: ...
+    def seek(self, __size: int, __whence: int = ...) -> Any: ...
+
+class ZoneInfo(tzinfo):
+    @property
+    def key(self) -> str: ...
+    def __init__(self, key: str) -> None: ...
+    @classmethod
+    def no_cache(cls: Type[_T], key: str) -> _T: ...
+    @classmethod
+    def from_file(cls: Type[_T], __fobj: _IOBytes, key: Optional[str] = ...) -> _T: ...
+    @classmethod
+    def clear_cache(cls, *, only_keys: Iterable[str] = ...) -> None: ...
+
+# Note: Both here and in clear_cache, the types allow the use of `str` where
+# a sequence of strings is required. This should be remedied if a solution
+# to this typing bug is found: https://github.com/python/typing/issues/256
+def reset_tzpath(to: Optional[Sequence[Union[os.PathLike[AnyStr], str]]] = ...) -> None: ...
+def available_timezones() -> Set[str]: ...
+
+TZPATH: Sequence[str]
+
+class ZoneInfoNotFoundError(KeyError): ...
+class InvalidTZPathWarning(RuntimeWarning): ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_ast.pyi

@@ -0,0 +1,376 @@
+import sys
+import typing
+from typing import Any, ClassVar, Optional
+
+PyCF_ONLY_AST: int
+if sys.version_info >= (3, 8):
+    PyCF_TYPE_COMMENTS: int
+    PyCF_ALLOW_TOP_LEVEL_AWAIT: int
+
+_identifier = str
+
+class AST:
+    _attributes: ClassVar[typing.Tuple[str, ...]]
+    _fields: ClassVar[typing.Tuple[str, ...]]
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    # TODO: Not all nodes have all of the following attributes
+    lineno: int
+    col_offset: int
+    if sys.version_info >= (3, 8):
+        end_lineno: Optional[int]
+        end_col_offset: Optional[int]
+        type_comment: Optional[str]
+
+class mod(AST): ...
+
+if sys.version_info >= (3, 8):
+    class type_ignore(AST): ...
+    class TypeIgnore(type_ignore): ...
+    class FunctionType(mod):
+        argtypes: typing.List[expr]
+        returns: expr
+
+class Module(mod):
+    body: typing.List[stmt]
+    if sys.version_info >= (3, 8):
+        type_ignores: typing.List[TypeIgnore]
+
+class Interactive(mod):
+    body: typing.List[stmt]
+
+class Expression(mod):
+    body: expr
+
+class stmt(AST): ...
+
+class FunctionDef(stmt):
+    name: _identifier
+    args: arguments
+    body: typing.List[stmt]
+    decorator_list: typing.List[expr]
+    returns: Optional[expr]
+
+class AsyncFunctionDef(stmt):
+    name: _identifier
+    args: arguments
+    body: typing.List[stmt]
+    decorator_list: typing.List[expr]
+    returns: Optional[expr]
+
+class ClassDef(stmt):
+    name: _identifier
+    bases: typing.List[expr]
+    keywords: typing.List[keyword]
+    body: typing.List[stmt]
+    decorator_list: typing.List[expr]
+
+class Return(stmt):
+    value: Optional[expr]
+
+class Delete(stmt):
+    targets: typing.List[expr]
+
+class Assign(stmt):
+    targets: typing.List[expr]
+    value: expr
+
+class AugAssign(stmt):
+    target: expr
+    op: operator
+    value: expr
+
+class AnnAssign(stmt):
+    target: expr
+    annotation: expr
+    value: Optional[expr]
+    simple: int
+
+class For(stmt):
+    target: expr
+    iter: expr
+    body: typing.List[stmt]
+    orelse: typing.List[stmt]
+
+class AsyncFor(stmt):
+    target: expr
+    iter: expr
+    body: typing.List[stmt]
+    orelse: typing.List[stmt]
+
+class While(stmt):
+    test: expr
+    body: typing.List[stmt]
+    orelse: typing.List[stmt]
+
+class If(stmt):
+    test: expr
+    body: typing.List[stmt]
+    orelse: typing.List[stmt]
+
+class With(stmt):
+    items: typing.List[withitem]
+    body: typing.List[stmt]
+
+class AsyncWith(stmt):
+    items: typing.List[withitem]
+    body: typing.List[stmt]
+
+class Raise(stmt):
+    exc: Optional[expr]
+    cause: Optional[expr]
+
+class Try(stmt):
+    body: typing.List[stmt]
+    handlers: typing.List[ExceptHandler]
+    orelse: typing.List[stmt]
+    finalbody: typing.List[stmt]
+
+class Assert(stmt):
+    test: expr
+    msg: Optional[expr]
+
+class Import(stmt):
+    names: typing.List[alias]
+
+class ImportFrom(stmt):
+    module: Optional[_identifier]
+    names: typing.List[alias]
+    level: int
+
+class Global(stmt):
+    names: typing.List[_identifier]
+
+class Nonlocal(stmt):
+    names: typing.List[_identifier]
+
+class Expr(stmt):
+    value: expr
+
+class Pass(stmt): ...
+class Break(stmt): ...
+class Continue(stmt): ...
+class expr(AST): ...
+
+class BoolOp(expr):
+    op: boolop
+    values: typing.List[expr]
+
+class BinOp(expr):
+    left: expr
+    op: operator
+    right: expr
+
+class UnaryOp(expr):
+    op: unaryop
+    operand: expr
+
+class Lambda(expr):
+    args: arguments
+    body: expr
+
+class IfExp(expr):
+    test: expr
+    body: expr
+    orelse: expr
+
+class Dict(expr):
+    keys: typing.List[Optional[expr]]
+    values: typing.List[expr]
+
+class Set(expr):
+    elts: typing.List[expr]
+
+class ListComp(expr):
+    elt: expr
+    generators: typing.List[comprehension]
+
+class SetComp(expr):
+    elt: expr
+    generators: typing.List[comprehension]
+
+class DictComp(expr):
+    key: expr
+    value: expr
+    generators: typing.List[comprehension]
+
+class GeneratorExp(expr):
+    elt: expr
+    generators: typing.List[comprehension]
+
+class Await(expr):
+    value: expr
+
+class Yield(expr):
+    value: Optional[expr]
+
+class YieldFrom(expr):
+    value: expr
+
+class Compare(expr):
+    left: expr
+    ops: typing.List[cmpop]
+    comparators: typing.List[expr]
+
+class Call(expr):
+    func: expr
+    args: typing.List[expr]
+    keywords: typing.List[keyword]
+
+class FormattedValue(expr):
+    value: expr
+    conversion: Optional[int]
+    format_spec: Optional[expr]
+
+class JoinedStr(expr):
+    values: typing.List[expr]
+
+if sys.version_info < (3, 8):
+    class Num(expr):  # Deprecated in 3.8; use Constant
+        n: complex
+    class Str(expr):  # Deprecated in 3.8; use Constant
+        s: str
+    class Bytes(expr):  # Deprecated in 3.8; use Constant
+        s: bytes
+    class NameConstant(expr):  # Deprecated in 3.8; use Constant
+        value: Any
+    class Ellipsis(expr): ...  # Deprecated in 3.8; use Constant
+
+class Constant(expr):
+    value: Any  # None, str, bytes, bool, int, float, complex, Ellipsis
+    kind: Optional[str]
+    # Aliases for value, for backwards compatibility
+    s: Any
+    n: complex
+
+if sys.version_info >= (3, 8):
+    class NamedExpr(expr):
+        target: expr
+        value: expr
+
+class Attribute(expr):
+    value: expr
+    attr: _identifier
+    ctx: expr_context
+
+if sys.version_info >= (3, 9):
+    _SliceT = expr
+else:
+    class slice(AST): ...
+    _SliceT = slice
+
+class Slice(_SliceT):
+    lower: Optional[expr]
+    upper: Optional[expr]
+    step: Optional[expr]
+
+if sys.version_info < (3, 9):
+    class ExtSlice(slice):
+        dims: typing.List[slice]
+    class Index(slice):
+        value: expr
+
+class Subscript(expr):
+    value: expr
+    slice: _SliceT
+    ctx: expr_context
+
+class Starred(expr):
+    value: expr
+    ctx: expr_context
+
+class Name(expr):
+    id: _identifier
+    ctx: expr_context
+
+class List(expr):
+    elts: typing.List[expr]
+    ctx: expr_context
+
+class Tuple(expr):
+    elts: typing.List[expr]
+    ctx: expr_context
+
+class expr_context(AST): ...
+
+if sys.version_info < (3, 9):
+    class AugLoad(expr_context): ...
+    class AugStore(expr_context): ...
+    class Param(expr_context): ...
+    class Suite(mod):
+        body: typing.List[stmt]
+
+class Del(expr_context): ...
+class Load(expr_context): ...
+class Store(expr_context): ...
+class boolop(AST): ...
+class And(boolop): ...
+class Or(boolop): ...
+class operator(AST): ...
+class Add(operator): ...
+class BitAnd(operator): ...
+class BitOr(operator): ...
+class BitXor(operator): ...
+class Div(operator): ...
+class FloorDiv(operator): ...
+class LShift(operator): ...
+class Mod(operator): ...
+class Mult(operator): ...
+class MatMult(operator): ...
+class Pow(operator): ...
+class RShift(operator): ...
+class Sub(operator): ...
+class unaryop(AST): ...
+class Invert(unaryop): ...
+class Not(unaryop): ...
+class UAdd(unaryop): ...
+class USub(unaryop): ...
+class cmpop(AST): ...
+class Eq(cmpop): ...
+class Gt(cmpop): ...
+class GtE(cmpop): ...
+class In(cmpop): ...
+class Is(cmpop): ...
+class IsNot(cmpop): ...
+class Lt(cmpop): ...
+class LtE(cmpop): ...
+class NotEq(cmpop): ...
+class NotIn(cmpop): ...
+
+class comprehension(AST):
+    target: expr
+    iter: expr
+    ifs: typing.List[expr]
+    is_async: int
+
+class excepthandler(AST): ...
+
+class ExceptHandler(excepthandler):
+    type: Optional[expr]
+    name: Optional[_identifier]
+    body: typing.List[stmt]
+
+class arguments(AST):
+    if sys.version_info >= (3, 8):
+        posonlyargs: typing.List[arg]
+    args: typing.List[arg]
+    vararg: Optional[arg]
+    kwonlyargs: typing.List[arg]
+    kw_defaults: typing.List[Optional[expr]]
+    kwarg: Optional[arg]
+    defaults: typing.List[expr]
+
+class arg(AST):
+    arg: _identifier
+    annotation: Optional[expr]
+
+class keyword(AST):
+    arg: Optional[_identifier]
+    value: expr
+
+class alias(AST):
+    name: _identifier
+    asname: Optional[_identifier]
+
+class withitem(AST):
+    context_expr: expr
+    optional_vars: Optional[expr]

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_compat_pickle.pyi

@@ -0,0 +1,10 @@
+from typing import Dict, Tuple
+
+IMPORT_MAPPING: Dict[str, str]
+NAME_MAPPING: Dict[Tuple[str, str], Tuple[str, str]]
+PYTHON2_EXCEPTIONS: Tuple[str, ...]
+MULTIPROCESSING_EXCEPTIONS: Tuple[str, ...]
+REVERSE_IMPORT_MAPPING: Dict[str, str]
+REVERSE_NAME_MAPPING: Dict[Tuple[str, str], Tuple[str, str]]
+PYTHON3_OSERROR_EXCEPTIONS: Tuple[str, ...]
+PYTHON3_IMPORTERROR_EXCEPTIONS: Tuple[str, ...]

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_compression.pyi

@@ -0,0 +1,23 @@
+from _typeshed import WriteableBuffer
+from io import BufferedIOBase, RawIOBase
+from typing import Any, Callable, Tuple, Type, Union
+
+BUFFER_SIZE: Any
+
+class BaseStream(BufferedIOBase): ...
+
+class DecompressReader(RawIOBase):
+    def __init__(
+        self,
+        fp: RawIOBase,
+        decomp_factory: Callable[..., object],
+        trailing_error: Union[Type[Exception], Tuple[Type[Exception], ...]] = ...,
+        **decomp_args: Any,
+    ) -> None: ...
+    def readable(self) -> bool: ...
+    def close(self) -> None: ...
+    def seekable(self) -> bool: ...
+    def readinto(self, b: WriteableBuffer) -> int: ...
+    def read(self, size: int = ...) -> bytes: ...
+    def seek(self, offset: int, whence: int = ...) -> int: ...
+    def tell(self) -> int: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_dummy_thread.pyi

@@ -0,0 +1,21 @@
+from typing import Any, Callable, Dict, NoReturn, Optional, Tuple
+
+TIMEOUT_MAX: int
+error = RuntimeError
+
+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] = ..., timeout: int = ...) -> bool: ...
+    def __enter__(self, waitflag: Optional[bool] = ..., timeout: int = ...) -> bool: ...
+    def __exit__(self, typ: Any, val: Any, tb: Any) -> None: ...
+    def release(self) -> bool: ...
+    def locked(self) -> bool: ...
+
+def interrupt_main() -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_imp.pyi

@@ -0,0 +1,17 @@
+import types
+from importlib.machinery import ModuleSpec
+from typing import Any, List
+
+def create_builtin(__spec: ModuleSpec) -> types.ModuleType: ...
+def create_dynamic(__spec: ModuleSpec, __file: Any = ...) -> None: ...
+def acquire_lock() -> None: ...
+def exec_builtin(__mod: types.ModuleType) -> int: ...
+def exec_dynamic(__mod: types.ModuleType) -> int: ...
+def extension_suffixes() -> List[str]: ...
+def get_frozen_object(__name: str) -> types.CodeType: ...
+def init_frozen(__name: str) -> types.ModuleType: ...
+def is_builtin(__name: str) -> int: ...
+def is_frozen(__name: str) -> bool: ...
+def is_frozen_package(__name: str) -> bool: ...
+def lock_held() -> bool: ...
+def release_lock() -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_importlib_modulespec.pyi

@@ -0,0 +1,50 @@
+# ModuleSpec, ModuleType, Loader are part of a dependency cycle.
+# They are officially defined/exported in other places:
+#
+# - ModuleType in types
+# - Loader in importlib.abc
+# - ModuleSpec in importlib.machinery (3.4 and later only)
+#
+# _Loader is the PEP-451-defined interface for a loader type/object.
+
+from abc import ABCMeta
+from typing import Any, Dict, List, Optional, Protocol
+
+class _Loader(Protocol):
+    def load_module(self, fullname: str) -> ModuleType: ...
+
+class ModuleSpec:
+    def __init__(
+        self,
+        name: str,
+        loader: Optional[Loader],
+        *,
+        origin: Optional[str] = ...,
+        loader_state: Any = ...,
+        is_package: Optional[bool] = ...,
+    ) -> None: ...
+    name: str
+    loader: Optional[_Loader]
+    origin: Optional[str]
+    submodule_search_locations: Optional[List[str]]
+    loader_state: Any
+    cached: Optional[str]
+    parent: Optional[str]
+    has_location: bool
+
+class ModuleType:
+    __name__: str
+    __file__: str
+    __dict__: Dict[str, Any]
+    __loader__: Optional[_Loader]
+    __package__: Optional[str]
+    __spec__: Optional[ModuleSpec]
+    def __init__(self, name: str, doc: Optional[str] = ...) -> None: ...
+
+class Loader(metaclass=ABCMeta):
+    def load_module(self, fullname: str) -> ModuleType: ...
+    def module_repr(self, module: ModuleType) -> str: ...
+    def create_module(self, spec: ModuleSpec) -> Optional[ModuleType]: ...
+    # Not defined on the actual class for backwards-compatibility reasons,
+    # but expected in new code.
+    def exec_module(self, module: ModuleType) -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_json.pyi

@@ -0,0 +1,38 @@
+from typing import Any, Callable, Dict, Optional, Tuple
+
+class make_encoder:
+    sort_keys: Any
+    skipkeys: Any
+    key_separator: Any
+    indent: Any
+    markers: Any
+    default: Any
+    encoder: Any
+    item_separator: Any
+    def __init__(
+        self,
+        markers: Optional[Dict[int, Any]],
+        default: Callable[[Any], Any],
+        encoder: Callable[[str], str],
+        indent: Optional[int],
+        key_separator: str,
+        item_separator: str,
+        sort_keys: bool,
+        skipkeys: bool,
+        allow_nan: bool,
+    ) -> None: ...
+    def __call__(self, obj: object, _current_indent_level: int) -> Any: ...
+
+class make_scanner:
+    object_hook: Any
+    object_pairs_hook: Any
+    parse_int: Any
+    parse_constant: Any
+    parse_float: Any
+    strict: bool
+    # TODO: 'context' needs the attrs above (ducktype), but not __call__.
+    def __init__(self, context: make_scanner) -> None: ...
+    def __call__(self, string: str, index: int) -> Tuple[Any, int]: ...
+
+def encode_basestring_ascii(s: str) -> str: ...
+def scanstring(string: str, end: int, strict: bool = ...) -> Tuple[str, int]: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_markupbase.pyi

@@ -0,0 +1,8 @@
+from typing import Tuple
+
+class ParserBase:
+    def __init__(self) -> None: ...
+    def error(self, message: str) -> None: ...
+    def reset(self) -> None: ...
+    def getpos(self) -> Tuple[int, int]: ...
+    def unknown_decl(self, data: str) -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_operator.pyi

@@ -0,0 +1,60 @@
+# In reality the import is the other way around, but this way we can keep the operator stub in 2and3
+from operator import (
+    abs as abs,
+    add as add,
+    and_ as and_,
+    attrgetter as attrgetter,
+    concat as concat,
+    contains as contains,
+    countOf as countOf,
+    delitem as delitem,
+    eq as eq,
+    floordiv as floordiv,
+    ge as ge,
+    getitem as getitem,
+    gt as gt,
+    iadd as iadd,
+    iand as iand,
+    iconcat as iconcat,
+    ifloordiv as ifloordiv,
+    ilshift as ilshift,
+    imatmul as imatmul,
+    imod as imod,
+    imul as imul,
+    index as index,
+    indexOf as indexOf,
+    inv as inv,
+    invert as invert,
+    ior as ior,
+    ipow as ipow,
+    irshift as irshift,
+    is_ as is_,
+    is_not as is_not,
+    isub as isub,
+    itemgetter as itemgetter,
+    itruediv as itruediv,
+    ixor as ixor,
+    le as le,
+    length_hint as length_hint,
+    lshift as lshift,
+    lt as lt,
+    matmul as matmul,
+    methodcaller as methodcaller,
+    mod as mod,
+    mul as mul,
+    ne as ne,
+    neg as neg,
+    not_ as not_,
+    or_ as or_,
+    pos as pos,
+    pow as pow,
+    rshift as rshift,
+    setitem as setitem,
+    sub as sub,
+    truediv as truediv,
+    truth as truth,
+    xor as xor,
+)
+from typing import AnyStr
+
+def _compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_osx_support.pyi

@@ -0,0 +1,33 @@
+from typing import Dict, Iterable, List, Optional, Sequence, Tuple, TypeVar, Union
+
+_T = TypeVar("_T")
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+__all__: List[str]
+
+_UNIVERSAL_CONFIG_VARS: Tuple[str, ...]  # undocumented
+_COMPILER_CONFIG_VARS: Tuple[str, ...]  # undocumented
+_INITPRE: str  # undocumented
+
+def _find_executable(executable: str, path: Optional[str] = ...) -> Optional[str]: ...  # undocumented
+def _read_output(commandstring: str) -> Optional[str]: ...  # undocumented
+def _find_build_tool(toolname: str) -> str: ...  # undocumented
+
+_SYSTEM_VERSION: Optional[str]  # undocumented
+
+def _get_system_version() -> str: ...  # undocumented
+def _remove_original_values(_config_vars: Dict[str, str]) -> None: ...  # undocumented
+def _save_modified_value(_config_vars: Dict[str, str], cv: str, newvalue: str) -> None: ...  # undocumented
+def _supports_universal_builds() -> bool: ...  # undocumented
+def _find_appropriate_compiler(_config_vars: Dict[str, str]) -> Dict[str, str]: ...  # undocumented
+def _remove_universal_flags(_config_vars: Dict[str, str]) -> Dict[str, str]: ...  # undocumented
+def _remove_unsupported_archs(_config_vars: Dict[str, str]) -> Dict[str, str]: ...  # undocumented
+def _override_all_archs(_config_vars: Dict[str, str]) -> Dict[str, str]: ...  # undocumented
+def _check_for_unavailable_sdk(_config_vars: Dict[str, str]) -> Dict[str, str]: ...  # undocumented
+def compiler_fixup(compiler_so: Iterable[str], cc_args: Sequence[str]) -> List[str]: ...
+def customize_config_vars(_config_vars: Dict[str, str]) -> Dict[str, str]: ...
+def customize_compiler(_config_vars: Dict[str, str]) -> Dict[str, str]: ...
+def get_platform_osx(
+    _config_vars: Dict[str, str], osname: _T, release: _K, machine: _V
+) -> Tuple[Union[str, _T], Union[str, _K], Union[str, _V]]: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_posixsubprocess.pyi

@@ -0,0 +1,24 @@
+# NOTE: These are incomplete!
+
+from typing import Callable, Sequence, Tuple
+
+def cloexec_pipe() -> Tuple[int, int]: ...
+def fork_exec(
+    args: Sequence[str],
+    executable_list: Sequence[bytes],
+    close_fds: bool,
+    fds_to_keep: Sequence[int],
+    cwd: str,
+    env_list: Sequence[bytes],
+    p2cread: int,
+    p2cwrite: int,
+    c2pred: int,
+    c2pwrite: int,
+    errread: int,
+    errwrite: int,
+    errpipe_read: int,
+    errpipe_write: int,
+    restore_signals: int,
+    start_new_session: int,
+    preexec_fn: Callable[[], None],
+) -> int: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_pydecimal.pyi

@@ -0,0 +1,3 @@
+# This is a slight lie, the implementations aren't exactly identical
+# However, in all likelihood, the differences are inconsequential
+from decimal import *

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_sitebuiltins.pyi

@@ -0,0 +1,16 @@
+from typing import ClassVar, Iterable, NoReturn, Optional
+from typing_extensions import Literal
+
+class Quitter:
+    name: str
+    eof: str
+    def __init__(self, name: str, eof: str) -> None: ...
+    def __call__(self, code: Optional[int] = ...) -> NoReturn: ...
+
+class _Printer:
+    MAXLINES: ClassVar[Literal[23]]
+    def __init__(self, name: str, data: str, files: Iterable[str] = ..., dirs: Iterable[str] = ...) -> None: ...
+    def __call__(self) -> None: ...
+
+class _Helper:
+    def __call__(self, request: object) -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_stat.pyi

@@ -0,0 +1,65 @@
+SF_APPEND: int
+SF_ARCHIVED: int
+SF_IMMUTABLE: int
+SF_NOUNLINK: int
+SF_SNAPSHOT: int
+ST_ATIME: int
+ST_CTIME: int
+ST_DEV: int
+ST_GID: int
+ST_INO: int
+ST_MODE: int
+ST_MTIME: int
+ST_NLINK: int
+ST_SIZE: int
+ST_UID: int
+S_ENFMT: int
+S_IEXEC: int
+S_IFBLK: int
+S_IFCHR: int
+S_IFDIR: int
+S_IFDOOR: int
+S_IFIFO: int
+S_IFLNK: int
+S_IFPORT: int
+S_IFREG: int
+S_IFSOCK: int
+S_IFWHT: int
+S_IREAD: int
+S_IRGRP: int
+S_IROTH: int
+S_IRUSR: int
+S_IRWXG: int
+S_IRWXO: int
+S_IRWXU: int
+S_ISGID: int
+S_ISUID: int
+S_ISVTX: int
+S_IWGRP: int
+S_IWOTH: int
+S_IWRITE: int
+S_IWUSR: int
+S_IXGRP: int
+S_IXOTH: int
+S_IXUSR: int
+UF_APPEND: int
+UF_COMPRESSED: int
+UF_HIDDEN: int
+UF_IMMUTABLE: int
+UF_NODUMP: int
+UF_NOUNLINK: int
+UF_OPAQUE: int
+
+def S_IMODE(mode: int) -> int: ...
+def S_IFMT(mode: int) -> int: ...
+def S_ISBLK(mode: int) -> bool: ...
+def S_ISCHR(mode: int) -> bool: ...
+def S_ISDIR(mode: int) -> bool: ...
+def S_ISDOOR(mode: int) -> bool: ...
+def S_ISFIFO(mode: int) -> bool: ...
+def S_ISLNK(mode: int) -> bool: ...
+def S_ISPORT(mode: int) -> bool: ...
+def S_ISREG(mode: int) -> bool: ...
+def S_ISSOCK(mode: int) -> bool: ...
+def S_ISWHT(mode: int) -> bool: ...
+def filemode(mode: int) -> str: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_thread.pyi

@@ -0,0 +1,41 @@
+import sys
+from threading import Thread
+from types import TracebackType
+from typing import Any, Callable, Dict, NoReturn, Optional, Tuple, Type
+
+error = RuntimeError
+
+def _count() -> int: ...
+
+_dangling: Any
+
+class LockType:
+    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
+    def release(self) -> None: ...
+    def locked(self) -> bool: ...
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]
+    ) -> None: ...
+
+def start_new_thread(function: Callable[..., Any], args: Tuple[Any, ...], kwargs: Dict[str, Any] = ...) -> int: ...
+def interrupt_main() -> None: ...
+def exit() -> NoReturn: ...
+def allocate_lock() -> LockType: ...
+def get_ident() -> int: ...
+def stack_size(size: int = ...) -> int: ...
+
+TIMEOUT_MAX: float
+
+if sys.version_info >= (3, 8):
+    def get_native_id() -> int: ...  # only available on some platforms
+    class _ExceptHookArgs(Tuple[Type[BaseException], Optional[BaseException], Optional[TracebackType], Optional[Thread]]):
+        @property
+        def exc_type(self) -> Type[BaseException]: ...
+        @property
+        def exc_value(self) -> Optional[BaseException]: ...
+        @property
+        def exc_traceback(self) -> Optional[TracebackType]: ...
+        @property
+        def thread(self) -> Optional[Thread]: ...
+    _excepthook: Callable[[_ExceptHookArgs], Any]

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_threading_local.pyi

@@ -0,0 +1,16 @@
+from typing import Any, Dict, Tuple
+from weakref import ReferenceType
+
+localdict = Dict[Any, Any]
+
+class _localimpl:
+    key: str
+    dicts: Dict[int, Tuple[ReferenceType[Any], localdict]]
+    def __init__(self) -> None: ...
+    def get_dict(self) -> localdict: ...
+    def create_dict(self) -> localdict: ...
+
+class local:
+    def __getattribute__(self, name: str) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+    def __delattr__(self, name: str) -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_tkinter.pyi

@@ -0,0 +1,93 @@
+from typing import Any, Tuple, Union
+
+# _tkinter is meant to be only used internally by tkinter, but some tkinter
+# functions e.g. return _tkinter.Tcl_Obj objects. Tcl_Obj represents a Tcl
+# object that hasn't been converted to a string.
+#
+# There are not many ways to get Tcl_Objs from tkinter, and I'm not sure if the
+# only existing ways are supposed to return Tcl_Objs as opposed to returning
+# strings. Here's one of these things that return Tcl_Objs:
+#
+#    >>> import tkinter
+#    >>> text = tkinter.Text()
+#    >>> text.tag_add('foo', '1.0', 'end')
+#    >>> text.tag_ranges('foo')
+#    (<textindex object: '1.0'>, <textindex object: '2.0'>)
+class Tcl_Obj:
+    string: str  # str(tclobj) returns this
+    typename: str
+
+class TclError(Exception): ...
+
+# This class allows running Tcl code. Tkinter uses it internally a lot, and
+# it's often handy to drop a piece of Tcl code into a tkinter program. Example:
+#
+#    >>> import tkinter, _tkinter
+#    >>> tkapp = tkinter.Tk().tk
+#    >>> isinstance(tkapp, _tkinter.TkappType)
+#    True
+#    >>> tkapp.call('set', 'foo', (1,2,3))
+#    (1, 2, 3)
+#    >>> tkapp.eval('return $foo')
+#    '1 2 3'
+#    >>>
+#
+# call args can be pretty much anything. Also, call(some_tuple) is same as call(*some_tuple).
+#
+# eval always returns str because _tkinter_tkapp_eval_impl in _tkinter.c calls
+# Tkapp_UnicodeResult, and it returns a string when it succeeds.
+class TkappType:
+    # Please keep in sync with tkinter.Tk
+    def call(self, __command: Union[str, Tuple[Any, ...]], *args: Any) -> Any: ...
+    def eval(self, __script: str) -> str: ...
+    adderrorinfo: Any
+    createcommand: Any
+    createfilehandler: Any
+    createtimerhandler: Any
+    deletecommand: Any
+    deletefilehandler: Any
+    dooneevent: Any
+    evalfile: Any
+    exprboolean: Any
+    exprdouble: Any
+    exprlong: Any
+    exprstring: Any
+    getboolean: Any
+    getdouble: Any
+    getint: Any
+    getvar: Any
+    globalgetvar: Any
+    globalsetvar: Any
+    globalunsetvar: Any
+    interpaddr: Any
+    loadtk: Any
+    mainloop: Any
+    quit: Any
+    record: Any
+    setvar: Any
+    split: Any
+    splitlist: Any
+    unsetvar: Any
+    wantobjects: Any
+    willdispatch: Any
+
+ALL_EVENTS: int
+FILE_EVENTS: int
+IDLE_EVENTS: int
+TIMER_EVENTS: int
+WINDOW_EVENTS: int
+
+DONT_WAIT: int
+EXCEPTION: int
+READABLE: int
+WRITABLE: int
+
+TCL_VERSION: str
+TK_VERSION: str
+
+# TODO: figure out what these are (with e.g. help()) and get rid of Any
+TkttType: Any
+_flatten: Any
+create: Any
+getbusywaitinterval: Any
+setbusywaitinterval: Any

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/_winapi.pyi

@@ -0,0 +1,134 @@
+import sys
+from typing import Any, Dict, NoReturn, Optional, Sequence, Tuple, Union, overload
+from typing_extensions import Literal
+
+CREATE_NEW_CONSOLE: int
+CREATE_NEW_PROCESS_GROUP: int
+DUPLICATE_CLOSE_SOURCE: int
+DUPLICATE_SAME_ACCESS: int
+ERROR_ALREADY_EXISTS: int
+ERROR_BROKEN_PIPE: int
+ERROR_IO_PENDING: int
+ERROR_MORE_DATA: int
+ERROR_NETNAME_DELETED: int
+ERROR_NO_DATA: int
+ERROR_NO_SYSTEM_RESOURCES: int
+ERROR_OPERATION_ABORTED: int
+ERROR_PIPE_BUSY: int
+ERROR_PIPE_CONNECTED: int
+ERROR_SEM_TIMEOUT: int
+FILE_FLAG_FIRST_PIPE_INSTANCE: int
+FILE_FLAG_OVERLAPPED: int
+FILE_GENERIC_READ: int
+FILE_GENERIC_WRITE: int
+GENERIC_READ: int
+GENERIC_WRITE: int
+INFINITE: int
+NMPWAIT_WAIT_FOREVER: int
+NULL: int
+OPEN_EXISTING: int
+PIPE_ACCESS_DUPLEX: int
+PIPE_ACCESS_INBOUND: int
+PIPE_READMODE_MESSAGE: int
+PIPE_TYPE_MESSAGE: int
+PIPE_UNLIMITED_INSTANCES: int
+PIPE_WAIT: int
+PROCESS_ALL_ACCESS: int
+PROCESS_DUP_HANDLE: int
+STARTF_USESHOWWINDOW: int
+STARTF_USESTDHANDLES: int
+STD_ERROR_HANDLE: int
+STD_INPUT_HANDLE: int
+STD_OUTPUT_HANDLE: int
+STILL_ACTIVE: int
+SW_HIDE: int
+WAIT_ABANDONED_0: int
+WAIT_OBJECT_0: int
+WAIT_TIMEOUT: int
+
+def CloseHandle(__handle: int) -> None: ...
+@overload
+def ConnectNamedPipe(handle: int, overlapped: Literal[True]) -> Overlapped: ...
+@overload
+def ConnectNamedPipe(handle: int, overlapped: Literal[False] = ...) -> None: ...
+@overload
+def ConnectNamedPipe(handle: int, overlapped: bool) -> Optional[Overlapped]: ...
+def CreateFile(
+    __file_name: str,
+    __desired_access: int,
+    __share_mode: int,
+    __security_attributes: int,
+    __creation_disposition: int,
+    __flags_and_attributes: int,
+    __template_file: int,
+) -> int: ...
+def CreateJunction(__src_path: str, __dst_path: str) -> None: ...
+def CreateNamedPipe(
+    __name: str,
+    __open_mode: int,
+    __pipe_mode: int,
+    __max_instances: int,
+    __out_buffer_size: int,
+    __in_buffer_size: int,
+    __default_timeout: int,
+    __security_attributes: int,
+) -> int: ...
+def CreatePipe(__pipe_attrs: Any, __size: int) -> Tuple[int, int]: ...
+def CreateProcess(
+    __application_name: Optional[str],
+    __command_line: Optional[str],
+    __proc_attrs: Any,
+    __thread_attrs: Any,
+    __inherit_handles: bool,
+    __creation_flags: int,
+    __env_mapping: Dict[str, str],
+    __current_directory: Optional[str],
+    __startup_info: Any,
+) -> Tuple[int, int, int, int]: ...
+def DuplicateHandle(
+    __source_process_handle: int,
+    __source_handle: int,
+    __target_process_handle: int,
+    __desired_access: int,
+    __inherit_handle: bool,
+    __options: int = ...,
+) -> int: ...
+def ExitProcess(__ExitCode: int) -> NoReturn: ...
+
+if sys.version_info >= (3, 7):
+    def GetACP() -> int: ...
+    def GetFileType(handle: int) -> int: ...
+
+def GetCurrentProcess() -> int: ...
+def GetExitCodeProcess(__process: int) -> int: ...
+def GetLastError() -> int: ...
+def GetModuleFileName(__module_handle: int) -> str: ...
+def GetStdHandle(__std_handle: int) -> int: ...
+def GetVersion() -> int: ...
+def OpenProcess(__desired_access: int, __inherit_handle: bool, __process_id: int) -> int: ...
+def PeekNamedPipe(__handle: int, __size: int = ...) -> Union[Tuple[int, int], Tuple[bytes, int, int]]: ...
+@overload
+def ReadFile(handle: int, size: int, overlapped: Literal[True]) -> Tuple[Overlapped, int]: ...
+@overload
+def ReadFile(handle: int, size: int, overlapped: Literal[False] = ...) -> Tuple[bytes, int]: ...
+@overload
+def ReadFile(handle: int, size: int, overlapped: Union[int, bool]) -> Tuple[Any, int]: ...
+def SetNamedPipeHandleState(
+    __named_pipe: int, __mode: Optional[int], __max_collection_count: Optional[int], __collect_data_timeout: Optional[int]
+) -> None: ...
+def TerminateProcess(__handle: int, __exit_code: int) -> None: ...
+def WaitForMultipleObjects(__handle_seq: Sequence[int], __wait_flag: bool, __milliseconds: int = ...) -> int: ...
+def WaitForSingleObject(__handle: int, __milliseconds: int) -> int: ...
+def WaitNamedPipe(__name: str, __timeout: int) -> None: ...
+@overload
+def WriteFile(handle: int, buffer: bytes, overlapped: Literal[True]) -> Tuple[Overlapped, int]: ...
+@overload
+def WriteFile(handle: int, buffer: bytes, overlapped: Literal[False] = ...) -> Tuple[int, int]: ...
+@overload
+def WriteFile(handle: int, buffer: bytes, overlapped: Union[int, bool]) -> Tuple[Any, int]: ...
+
+class Overlapped:
+    event: int = ...
+    def GetOverlappedResult(self, __wait: bool) -> Tuple[int, int]: ...
+    def cancel(self) -> None: ...
+    def getbuffer(self) -> Optional[bytes]: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/abc.pyi

@@ -0,0 +1,20 @@
+from typing import Any, Callable, Type, TypeVar
+
+_T = TypeVar("_T")
+_FuncT = TypeVar("_FuncT", bound=Callable[..., Any])
+
+# These definitions have special processing in mypy
+class ABCMeta(type):
+    def register(cls: ABCMeta, subclass: Type[_T]) -> Type[_T]: ...
+
+def abstractmethod(callable: _FuncT) -> _FuncT: ...
+
+class abstractproperty(property): ...
+
+# These two are deprecated and not supported by mypy
+def abstractstaticmethod(callable: _FuncT) -> _FuncT: ...
+def abstractclassmethod(callable: _FuncT) -> _FuncT: ...
+
+class ABC(metaclass=ABCMeta): ...
+
+def get_cache_token() -> object: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/ast.pyi

@@ -0,0 +1,207 @@
+# Rename typing to _typing, as not to conflict with typing imported
+# from _ast below when loaded in an unorthodox way by the Dropbox
+# internal Bazel integration.
+
+# The same unorthodox Bazel integration causes issues with sys, which
+# is imported in both modules. unfortunately we can't just rename sys,
+# since mypy only supports version checks with a sys that is named
+# sys.
+import sys
+import typing as _typing
+from typing import Any, Iterator, Optional, TypeVar, Union, overload
+from typing_extensions import Literal
+
+from _ast import *  # type: ignore
+
+if sys.version_info >= (3, 8):
+    class Num(Constant):
+        value: complex
+    class Str(Constant):
+        value: str
+        # Aliases for value, for backwards compatibility
+        s: str
+    class Bytes(Constant):
+        value: bytes
+        # Aliases for value, for backwards compatibility
+        s: bytes
+    class NameConstant(Constant): ...
+    class Ellipsis(Constant): ...
+
+if sys.version_info >= (3, 9):
+    class slice(AST): ...
+    class ExtSlice(slice): ...
+    class Index(slice): ...
+    class Suite(mod): ...
+    class AugLoad(expr_context): ...
+    class AugStore(expr_context): ...
+    class Param(expr_context): ...
+
+class NodeVisitor:
+    def visit(self, node: AST) -> Any: ...
+    def generic_visit(self, node: AST) -> Any: ...
+    def visit_Module(self, node: Module) -> Any: ...
+    def visit_Interactive(self, node: Interactive) -> Any: ...
+    def visit_Expression(self, node: Expression) -> Any: ...
+    def visit_FunctionDef(self, node: FunctionDef) -> Any: ...
+    def visit_AsyncFunctionDef(self, node: AsyncFunctionDef) -> Any: ...
+    def visit_ClassDef(self, node: ClassDef) -> Any: ...
+    def visit_Return(self, node: Return) -> Any: ...
+    def visit_Delete(self, node: Delete) -> Any: ...
+    def visit_Assign(self, node: Assign) -> Any: ...
+    def visit_AugAssign(self, node: AugAssign) -> Any: ...
+    def visit_AnnAssign(self, node: AnnAssign) -> Any: ...
+    def visit_For(self, node: For) -> Any: ...
+    def visit_AsyncFor(self, node: AsyncFor) -> Any: ...
+    def visit_While(self, node: While) -> Any: ...
+    def visit_If(self, node: If) -> Any: ...
+    def visit_With(self, node: With) -> Any: ...
+    def visit_AsyncWith(self, node: AsyncWith) -> Any: ...
+    def visit_Raise(self, node: Raise) -> Any: ...
+    def visit_Try(self, node: Try) -> Any: ...
+    def visit_Assert(self, node: Assert) -> Any: ...
+    def visit_Import(self, node: Import) -> Any: ...
+    def visit_ImportFrom(self, node: ImportFrom) -> Any: ...
+    def visit_Global(self, node: Global) -> Any: ...
+    def visit_Nonlocal(self, node: Nonlocal) -> Any: ...
+    def visit_Expr(self, node: Expr) -> Any: ...
+    def visit_Pass(self, node: Pass) -> Any: ...
+    def visit_Break(self, node: Break) -> Any: ...
+    def visit_Continue(self, node: Continue) -> Any: ...
+    def visit_Slice(self, node: Slice) -> Any: ...
+    def visit_BoolOp(self, node: BoolOp) -> Any: ...
+    def visit_BinOp(self, node: BinOp) -> Any: ...
+    def visit_UnaryOp(self, node: UnaryOp) -> Any: ...
+    def visit_Lambda(self, node: Lambda) -> Any: ...
+    def visit_IfExp(self, node: IfExp) -> Any: ...
+    def visit_Dict(self, node: Dict) -> Any: ...
+    def visit_Set(self, node: Set) -> Any: ...
+    def visit_ListComp(self, node: ListComp) -> Any: ...
+    def visit_SetComp(self, node: SetComp) -> Any: ...
+    def visit_DictComp(self, node: DictComp) -> Any: ...
+    def visit_GeneratorExp(self, node: GeneratorExp) -> Any: ...
+    def visit_Await(self, node: Await) -> Any: ...
+    def visit_Yield(self, node: Yield) -> Any: ...
+    def visit_YieldFrom(self, node: YieldFrom) -> Any: ...
+    def visit_Compare(self, node: Compare) -> Any: ...
+    def visit_Call(self, node: Call) -> Any: ...
+    def visit_FormattedValue(self, node: FormattedValue) -> Any: ...
+    def visit_JoinedStr(self, node: JoinedStr) -> Any: ...
+    def visit_Constant(self, node: Constant) -> Any: ...
+    if sys.version_info >= (3, 8):
+        def visit_NamedExpr(self, node: NamedExpr) -> Any: ...
+    def visit_Attribute(self, node: Attribute) -> Any: ...
+    def visit_Subscript(self, node: Subscript) -> Any: ...
+    def visit_Starred(self, node: Starred) -> Any: ...
+    def visit_Name(self, node: Name) -> Any: ...
+    def visit_List(self, node: List) -> Any: ...
+    def visit_Tuple(self, node: Tuple) -> Any: ...
+    def visit_Del(self, node: Del) -> Any: ...
+    def visit_Load(self, node: Load) -> Any: ...
+    def visit_Store(self, node: Store) -> Any: ...
+    def visit_And(self, node: And) -> Any: ...
+    def visit_Or(self, node: Or) -> Any: ...
+    def visit_Add(self, node: Add) -> Any: ...
+    def visit_BitAnd(self, node: BitAnd) -> Any: ...
+    def visit_BitOr(self, node: BitOr) -> Any: ...
+    def visit_BitXor(self, node: BitXor) -> Any: ...
+    def visit_Div(self, node: Div) -> Any: ...
+    def visit_FloorDiv(self, node: FloorDiv) -> Any: ...
+    def visit_LShift(self, node: LShift) -> Any: ...
+    def visit_Mod(self, node: Mod) -> Any: ...
+    def visit_Mult(self, node: Mult) -> Any: ...
+    def visit_MatMult(self, node: MatMult) -> Any: ...
+    def visit_Pow(self, node: Pow) -> Any: ...
+    def visit_RShift(self, node: RShift) -> Any: ...
+    def visit_Sub(self, node: Sub) -> Any: ...
+    def visit_Invert(self, node: Invert) -> Any: ...
+    def visit_Not(self, node: Not) -> Any: ...
+    def visit_UAdd(self, node: UAdd) -> Any: ...
+    def visit_USub(self, node: USub) -> Any: ...
+    def visit_Eq(self, node: Eq) -> Any: ...
+    def visit_Gt(self, node: Gt) -> Any: ...
+    def visit_GtE(self, node: GtE) -> Any: ...
+    def visit_In(self, node: In) -> Any: ...
+    def visit_Is(self, node: Is) -> Any: ...
+    def visit_IsNot(self, node: IsNot) -> Any: ...
+    def visit_Lt(self, node: Lt) -> Any: ...
+    def visit_LtE(self, node: LtE) -> Any: ...
+    def visit_NotEq(self, node: NotEq) -> Any: ...
+    def visit_NotIn(self, node: NotIn) -> Any: ...
+    def visit_comprehension(self, node: comprehension) -> Any: ...
+    def visit_ExceptHandler(self, node: ExceptHandler) -> Any: ...
+    def visit_arguments(self, node: arguments) -> Any: ...
+    def visit_arg(self, node: arg) -> Any: ...
+    def visit_keyword(self, node: keyword) -> Any: ...
+    def visit_alias(self, node: alias) -> Any: ...
+    def visit_withitem(self, node: withitem) -> Any: ...
+    # visit methods for deprecated nodes
+    def visit_ExtSlice(self, node: ExtSlice) -> Any: ...
+    def visit_Index(self, node: Index) -> Any: ...
+    def visit_Suite(self, node: Suite) -> Any: ...
+    def visit_AugLoad(self, node: AugLoad) -> Any: ...
+    def visit_AugStore(self, node: AugStore) -> Any: ...
+    def visit_Param(self, node: Param) -> Any: ...
+    def visit_Num(self, node: Num) -> Any: ...
+    def visit_Str(self, node: Str) -> Any: ...
+    def visit_Bytes(self, node: Bytes) -> Any: ...
+    def visit_NameConstant(self, node: NameConstant) -> Any: ...
+    def visit_Ellipsis(self, node: Ellipsis) -> Any: ...
+
+class NodeTransformer(NodeVisitor):
+    def generic_visit(self, node: AST) -> AST: ...
+    # TODO: Override the visit_* methods with better return types.
+    #       The usual return type is Optional[AST], but Iterable[AST]
+    #       is also allowed in some cases -- this needs to be mapped.
+
+_T = TypeVar("_T", bound=AST)
+
+if sys.version_info >= (3, 8):
+    @overload
+    def parse(
+        source: Union[str, bytes],
+        filename: Union[str, bytes] = ...,
+        mode: Literal["exec"] = ...,
+        *,
+        type_comments: bool = ...,
+        feature_version: Union[None, int, _typing.Tuple[int, int]] = ...,
+    ) -> Module: ...
+    @overload
+    def parse(
+        source: Union[str, bytes],
+        filename: Union[str, bytes] = ...,
+        mode: str = ...,
+        *,
+        type_comments: bool = ...,
+        feature_version: Union[None, int, _typing.Tuple[int, int]] = ...,
+    ) -> AST: ...
+
+else:
+    @overload
+    def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: Literal["exec"] = ...) -> Module: ...
+    @overload
+    def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ...) -> AST: ...
+
+if sys.version_info >= (3, 9):
+    def unparse(ast_obj: AST) -> str: ...
+
+def copy_location(new_node: _T, old_node: AST) -> _T: ...
+
+if sys.version_info >= (3, 9):
+    def dump(
+        node: AST, annotate_fields: bool = ..., include_attributes: bool = ..., *, indent: Union[int, str, None] = ...
+    ) -> str: ...
+
+else:
+    def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ...
+
+def fix_missing_locations(node: _T) -> _T: ...
+def get_docstring(node: AST, clean: bool = ...) -> Optional[str]: ...
+def increment_lineno(node: _T, n: int = ...) -> _T: ...
+def iter_child_nodes(node: AST) -> Iterator[AST]: ...
+def iter_fields(node: AST) -> Iterator[_typing.Tuple[str, Any]]: ...
+def literal_eval(node_or_string: Union[str, AST]) -> Any: ...
+
+if sys.version_info >= (3, 8):
+    def get_source_segment(source: str, node: AST, *, padded: bool = ...) -> Optional[str]: ...
+
+def walk(node: AST) -> Iterator[AST]: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/atexit.pyi

@@ -0,0 +1,7 @@
+from typing import Any, Callable
+
+def _clear() -> None: ...
+def _ncallbacks() -> int: ...
+def _run_exitfuncs() -> None: ...
+def register(func: Callable[..., Any], *args: Any, **kwargs: Any) -> Callable[..., Any]: ...
+def unregister(func: Callable[..., Any]) -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/compileall.pyi

@@ -0,0 +1,108 @@
+import sys
+from _typeshed import AnyPath
+from typing import Any, Optional, Pattern
+
+if sys.version_info >= (3, 7):
+    from py_compile import PycInvalidationMode
+
+if sys.version_info >= (3, 9):
+    def compile_dir(
+        dir: AnyPath,
+        maxlevels: Optional[int] = ...,
+        ddir: Optional[AnyPath] = ...,
+        force: bool = ...,
+        rx: Optional[Pattern[Any]] = ...,
+        quiet: int = ...,
+        legacy: bool = ...,
+        optimize: int = ...,
+        workers: int = ...,
+        invalidation_mode: Optional[PycInvalidationMode] = ...,
+        *,
+        stripdir: Optional[str] = ...,  # TODO: change to Optional[AnyPath] once https://bugs.python.org/issue40447 is resolved
+        prependdir: Optional[AnyPath] = ...,
+        limit_sl_dest: Optional[AnyPath] = ...,
+        hardlink_dupes: bool = ...,
+    ) -> int: ...
+    def compile_file(
+        fullname: AnyPath,
+        ddir: Optional[AnyPath] = ...,
+        force: bool = ...,
+        rx: Optional[Pattern[Any]] = ...,
+        quiet: int = ...,
+        legacy: bool = ...,
+        optimize: int = ...,
+        invalidation_mode: Optional[PycInvalidationMode] = ...,
+        *,
+        stripdir: Optional[str] = ...,  # TODO: change to Optional[AnyPath] once https://bugs.python.org/issue40447 is resolved
+        prependdir: Optional[AnyPath] = ...,
+        limit_sl_dest: Optional[AnyPath] = ...,
+        hardlink_dupes: bool = ...,
+    ) -> int: ...
+
+elif sys.version_info >= (3, 7):
+    def compile_dir(
+        dir: AnyPath,
+        maxlevels: int = ...,
+        ddir: Optional[AnyPath] = ...,
+        force: bool = ...,
+        rx: Optional[Pattern[Any]] = ...,
+        quiet: int = ...,
+        legacy: bool = ...,
+        optimize: int = ...,
+        workers: int = ...,
+        invalidation_mode: Optional[PycInvalidationMode] = ...,
+    ) -> int: ...
+    def compile_file(
+        fullname: AnyPath,
+        ddir: Optional[AnyPath] = ...,
+        force: bool = ...,
+        rx: Optional[Pattern[Any]] = ...,
+        quiet: int = ...,
+        legacy: bool = ...,
+        optimize: int = ...,
+        invalidation_mode: Optional[PycInvalidationMode] = ...,
+    ) -> int: ...
+
+else:
+    # rx can be any object with a 'search' method; once we have Protocols we can change the type
+    def compile_dir(
+        dir: AnyPath,
+        maxlevels: int = ...,
+        ddir: Optional[AnyPath] = ...,
+        force: bool = ...,
+        rx: Optional[Pattern[Any]] = ...,
+        quiet: int = ...,
+        legacy: bool = ...,
+        optimize: int = ...,
+        workers: int = ...,
+    ) -> int: ...
+    def compile_file(
+        fullname: AnyPath,
+        ddir: Optional[AnyPath] = ...,
+        force: bool = ...,
+        rx: Optional[Pattern[Any]] = ...,
+        quiet: int = ...,
+        legacy: bool = ...,
+        optimize: int = ...,
+    ) -> int: ...
+
+if sys.version_info >= (3, 7):
+    def compile_path(
+        skip_curdir: bool = ...,
+        maxlevels: int = ...,
+        force: bool = ...,
+        quiet: int = ...,
+        legacy: bool = ...,
+        optimize: int = ...,
+        invalidation_mode: Optional[PycInvalidationMode] = ...,
+    ) -> int: ...
+
+else:
+    def compile_path(
+        skip_curdir: bool = ...,
+        maxlevels: int = ...,
+        force: bool = ...,
+        quiet: int = ...,
+        legacy: bool = ...,
+        optimize: int = ...,
+    ) -> int: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/copyreg.pyi

@@ -0,0 +1,16 @@
+from typing import Any, Callable, Hashable, List, Optional, SupportsInt, Tuple, TypeVar, Union
+
+_Type = TypeVar("_Type", bound=type)
+_Reduce = Union[Tuple[Callable[..., _Type], Tuple[Any, ...]], Tuple[Callable[..., _Type], Tuple[Any, ...], Optional[Any]]]
+
+__all__: List[str]
+
+def pickle(
+    ob_type: _Type,
+    pickle_function: Callable[[_Type], Union[str, _Reduce[_Type]]],
+    constructor_ob: Optional[Callable[[_Reduce[_Type]], _Type]] = ...,
+) -> None: ...
+def constructor(object: Callable[[_Reduce[_Type]], _Type]) -> None: ...
+def add_extension(module: Hashable, name: Hashable, code: SupportsInt) -> None: ...
+def remove_extension(module: Hashable, name: Hashable, code: int) -> None: ...
+def clear_extension_cache() -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/enum.pyi

@@ -0,0 +1,73 @@
+import sys
+from abc import ABCMeta
+from typing import Any, Dict, Iterator, List, Mapping, Type, TypeVar, Union
+
+_T = TypeVar("_T")
+_S = TypeVar("_S", bound=Type[Enum])
+
+# Note: EnumMeta actually subclasses type directly, not ABCMeta.
+# This is a temporary workaround to allow multiple creation of enums with builtins
+# such as str as mixins, which due to the handling of ABCs of builtin types, cause
+# spurious inconsistent metaclass structure. See #1595.
+# Structurally: Iterable[T], Reversible[T], Container[T] where T is the enum itself
+class EnumMeta(ABCMeta):
+    def __iter__(self: Type[_T]) -> Iterator[_T]: ...
+    def __reversed__(self: Type[_T]) -> Iterator[_T]: ...
+    def __contains__(self: Type[_T], member: object) -> bool: ...
+    def __getitem__(self: Type[_T], name: str) -> _T: ...
+    @property
+    def __members__(self: Type[_T]) -> Mapping[str, _T]: ...
+    def __len__(self) -> int: ...
+
+class Enum(metaclass=EnumMeta):
+    name: str
+    value: Any
+    _name_: str
+    _value_: Any
+    _member_names_: List[str]  # undocumented
+    _member_map_: Dict[str, Enum]  # undocumented
+    _value2member_map_: Dict[int, Enum]  # undocumented
+    if sys.version_info >= (3, 7):
+        _ignore_: Union[str, List[str]]
+    _order_: str
+    __order__: str
+    @classmethod
+    def _missing_(cls, value: object) -> Any: ...
+    @staticmethod
+    def _generate_next_value_(name: str, start: int, count: int, last_values: List[Any]) -> Any: ...
+    def __new__(cls: Type[_T], value: object) -> _T: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __dir__(self) -> List[str]: ...
+    def __format__(self, format_spec: str) -> str: ...
+    def __hash__(self) -> Any: ...
+    def __reduce_ex__(self, proto: object) -> Any: ...
+
+class IntEnum(int, Enum):
+    value: int
+
+def unique(enumeration: _S) -> _S: ...
+
+_auto_null: Any
+
+# subclassing IntFlag so it picks up all implemented base functions, best modeling behavior of enum.auto()
+class auto(IntFlag):
+    value: Any
+
+class Flag(Enum):
+    def __contains__(self: _T, other: _T) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __bool__(self) -> bool: ...
+    def __or__(self: _T, other: _T) -> _T: ...
+    def __and__(self: _T, other: _T) -> _T: ...
+    def __xor__(self: _T, other: _T) -> _T: ...
+    def __invert__(self: _T) -> _T: ...
+
+class IntFlag(int, Flag):
+    def __or__(self: _T, other: Union[int, _T]) -> _T: ...
+    def __and__(self: _T, other: Union[int, _T]) -> _T: ...
+    def __xor__(self: _T, other: Union[int, _T]) -> _T: ...
+    __ror__ = __or__
+    __rand__ = __and__
+    __rxor__ = __xor__

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/faulthandler.pyi

@@ -0,0 +1,13 @@
+import sys
+from _typeshed import FileDescriptorLike
+
+def cancel_dump_traceback_later() -> None: ...
+def disable() -> None: ...
+def dump_traceback(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ...
+def dump_traceback_later(timeout: float, repeat: bool = ..., file: FileDescriptorLike = ..., exit: bool = ...) -> None: ...
+def enable(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ...
+def is_enabled() -> bool: ...
+
+if sys.platform != "win32":
+    def register(signum: int, file: FileDescriptorLike = ..., all_threads: bool = ..., chain: bool = ...) -> None: ...
+    def unregister(signum: int) -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/fcntl.pyi

@@ -0,0 +1,99 @@
+import sys
+from _typeshed import FileDescriptorLike
+from array import array
+from typing import Any, Union, overload
+from typing_extensions import Literal
+
+FASYNC: int
+FD_CLOEXEC: int
+DN_ACCESS: int
+DN_ATTRIB: int
+DN_CREATE: int
+DN_DELETE: int
+DN_MODIFY: int
+DN_MULTISHOT: int
+DN_RENAME: int
+F_DUPFD: int
+F_DUPFD_CLOEXEC: int
+F_FULLFSYNC: int
+F_EXLCK: int
+F_GETFD: int
+F_GETFL: int
+F_GETLEASE: int
+F_GETLK: int
+F_GETLK64: int
+F_GETOWN: int
+F_NOCACHE: int
+F_GETSIG: int
+F_NOTIFY: int
+F_RDLCK: int
+F_SETFD: int
+F_SETFL: int
+F_SETLEASE: int
+F_SETLK: int
+F_SETLK64: int
+F_SETLKW: int
+F_SETLKW64: int
+if sys.version_info >= (3, 9) and sys.platform == "linux":
+    F_OFD_GETLK: int
+    F_OFD_SETLK: int
+    F_OFD_SETLKW: int
+F_SETOWN: int
+F_SETSIG: int
+F_SHLCK: int
+F_UNLCK: int
+F_WRLCK: int
+I_ATMARK: int
+I_CANPUT: int
+I_CKBAND: int
+I_FDINSERT: int
+I_FIND: int
+I_FLUSH: int
+I_FLUSHBAND: int
+I_GETBAND: int
+I_GETCLTIME: int
+I_GETSIG: int
+I_GRDOPT: int
+I_GWROPT: int
+I_LINK: int
+I_LIST: int
+I_LOOK: int
+I_NREAD: int
+I_PEEK: int
+I_PLINK: int
+I_POP: int
+I_PUNLINK: int
+I_PUSH: int
+I_RECVFD: int
+I_SENDFD: int
+I_SETCLTIME: int
+I_SETSIG: int
+I_SRDOPT: int
+I_STR: int
+I_SWROPT: int
+I_UNLINK: int
+LOCK_EX: int
+LOCK_MAND: int
+LOCK_NB: int
+LOCK_READ: int
+LOCK_RW: int
+LOCK_SH: int
+LOCK_UN: int
+LOCK_WRITE: int
+@overload
+def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: int = ...) -> int: ...
+@overload
+def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: bytes) -> bytes: ...
+
+_ReadOnlyBuffer = bytes
+_WritableBuffer = Union[bytearray, memoryview, array]
+@overload
+def ioctl(__fd: FileDescriptorLike, __request: int, __arg: int = ..., __mutate_flag: bool = ...) -> int: ...
+@overload
+def ioctl(__fd: FileDescriptorLike, __request: int, __arg: _WritableBuffer, __mutate_flag: Literal[True] = ...) -> int: ...
+@overload
+def ioctl(__fd: FileDescriptorLike, __request: int, __arg: _WritableBuffer, __mutate_flag: Literal[False]) -> bytes: ...
+@overload
+def ioctl(__fd: FileDescriptorLike, __request: int, __arg: _ReadOnlyBuffer, __mutate_flag: bool = ...) -> bytes: ...
+def flock(__fd: FileDescriptorLike, __operation: int) -> None: ...
+def lockf(__fd: FileDescriptorLike, __cmd: int, __len: int = ..., __start: int = ..., __whence: int = ...) -> Any: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/gc.pyi

@@ -0,0 +1,40 @@
+import sys
+from typing import Any, Dict, List, Optional, Tuple
+
+DEBUG_COLLECTABLE: int
+DEBUG_LEAK: int
+DEBUG_SAVEALL: int
+DEBUG_STATS: int
+DEBUG_UNCOLLECTABLE: int
+callbacks: List[Any]
+garbage: List[Any]
+
+def collect(generation: int = ...) -> int: ...
+def disable() -> None: ...
+def enable() -> None: ...
+def get_count() -> Tuple[int, int, int]: ...
+def get_debug() -> int: ...
+
+if sys.version_info >= (3, 8):
+    def get_objects(generation: Optional[int] = ...) -> List[Any]: ...
+
+else:
+    def get_objects() -> List[Any]: ...
+
+if sys.version_info >= (3, 7):
+    def freeze() -> None: ...
+    def unfreeze() -> None: ...
+    def get_freeze_count() -> int: ...
+
+def get_referents(*objs: Any) -> List[Any]: ...
+def get_referrers(*objs: Any) -> List[Any]: ...
+def get_stats() -> List[Dict[str, Any]]: ...
+def get_threshold() -> Tuple[int, int, int]: ...
+def is_tracked(__obj: Any) -> bool: ...
+
+if sys.version_info >= (3, 9):
+    def is_finalized(__obj: Any) -> bool: ...
+
+def isenabled() -> bool: ...
+def set_debug(__flags: int) -> None: ...
+def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ...) -> None: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/getpass.pyi

@@ -0,0 +1,6 @@
+from typing import Optional, TextIO
+
+def getpass(prompt: str = ..., stream: Optional[TextIO] = ...) -> str: ...
+def getuser() -> str: ...
+
+class GetPassWarning(UserWarning): ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/gettext.pyi

@@ -0,0 +1,80 @@
+import sys
+from _typeshed import StrPath
+from typing import IO, Any, Container, Iterable, Optional, Sequence, Type, TypeVar, overload
+from typing_extensions import Literal
+
+class NullTranslations:
+    def __init__(self, fp: Optional[IO[str]] = ...) -> None: ...
+    def _parse(self, fp: IO[str]) -> None: ...
+    def add_fallback(self, fallback: NullTranslations) -> None: ...
+    def gettext(self, message: str) -> str: ...
+    def lgettext(self, message: str) -> str: ...
+    def ngettext(self, msgid1: str, msgid2: str, n: int) -> str: ...
+    def lngettext(self, msgid1: str, msgid2: str, n: int) -> str: ...
+    if sys.version_info >= (3, 8):
+        def pgettext(self, context: str, message: str) -> str: ...
+        def npgettext(self, context: str, msgid1: str, msgid2: str, n: int) -> str: ...
+    def info(self) -> Any: ...
+    def charset(self) -> Any: ...
+    def output_charset(self) -> Any: ...
+    def set_output_charset(self, charset: str) -> None: ...
+    def install(self, names: Optional[Container[str]] = ...) -> None: ...
+
+class GNUTranslations(NullTranslations):
+    LE_MAGIC: int
+    BE_MAGIC: int
+    CONTEXT: str
+    VERSIONS: Sequence[int]
+
+def find(domain: str, localedir: Optional[StrPath] = ..., languages: Optional[Iterable[str]] = ..., all: bool = ...) -> Any: ...
+
+_T = TypeVar("_T")
+@overload
+def translation(
+    domain: str,
+    localedir: Optional[StrPath] = ...,
+    languages: Optional[Iterable[str]] = ...,
+    class_: None = ...,
+    fallback: bool = ...,
+    codeset: Optional[str] = ...,
+) -> NullTranslations: ...
+@overload
+def translation(
+    domain: str,
+    localedir: Optional[StrPath] = ...,
+    languages: Optional[Iterable[str]] = ...,
+    class_: Type[_T] = ...,
+    fallback: Literal[False] = ...,
+    codeset: Optional[str] = ...,
+) -> _T: ...
+@overload
+def translation(
+    domain: str,
+    localedir: Optional[StrPath] = ...,
+    languages: Optional[Iterable[str]] = ...,
+    class_: Type[_T] = ...,
+    fallback: Literal[True] = ...,
+    codeset: Optional[str] = ...,
+) -> Any: ...
+def install(
+    domain: str, localedir: Optional[StrPath] = ..., codeset: Optional[str] = ..., names: Optional[Container[str]] = ...
+) -> None: ...
+def textdomain(domain: Optional[str] = ...) -> str: ...
+def bindtextdomain(domain: str, localedir: Optional[StrPath] = ...) -> str: ...
+def bind_textdomain_codeset(domain: str, codeset: Optional[str] = ...) -> str: ...
+def dgettext(domain: str, message: str) -> str: ...
+def ldgettext(domain: str, message: str) -> str: ...
+def dngettext(domain: str, msgid1: str, msgid2: str, n: int) -> str: ...
+def ldngettext(domain: str, msgid1: str, msgid2: str, n: int) -> str: ...
+def gettext(message: str) -> str: ...
+def lgettext(message: str) -> str: ...
+def ngettext(msgid1: str, msgid2: str, n: int) -> str: ...
+def lngettext(msgid1: str, msgid2: str, n: int) -> str: ...
+
+if sys.version_info >= (3, 8):
+    def pgettext(context: str, message: str) -> str: ...
+    def dpgettext(domain: str, context: str, message: str) -> str: ...
+    def npgettext(context: str, msgid1: str, msgid2: str, n: int) -> str: ...
+    def dnpgettext(domain: str, context: str, msgid1: str, msgid2: str, n: int) -> str: ...
+
+Catalog = translation

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/glob.pyi

@@ -0,0 +1,8 @@
+from typing import AnyStr, Iterator, List, Union
+
+def glob0(dirname: AnyStr, pattern: AnyStr) -> List[AnyStr]: ...
+def glob1(dirname: AnyStr, pattern: AnyStr) -> List[AnyStr]: ...
+def glob(pathname: AnyStr, *, recursive: bool = ...) -> List[AnyStr]: ...
+def iglob(pathname: AnyStr, *, recursive: bool = ...) -> Iterator[AnyStr]: ...
+def escape(pathname: AnyStr) -> AnyStr: ...
+def has_magic(s: Union[str, bytes]) -> bool: ...  # undocumented

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/gzip.pyi

@@ -0,0 +1,94 @@
+import _compression
+import sys
+import zlib
+from _typeshed import AnyPath, ReadableBuffer
+from typing import IO, Optional, TextIO, Union, overload
+from typing_extensions import Literal
+
+_OpenBinaryMode = Literal["r", "rb", "a", "ab", "w", "wb", "x", "xb"]
+_OpenTextMode = Literal["rt", "at", "wt", "xt"]
+@overload
+def open(
+    filename: Union[AnyPath, IO[bytes]],
+    mode: _OpenBinaryMode = ...,
+    compresslevel: int = ...,
+    encoding: None = ...,
+    errors: None = ...,
+    newline: None = ...,
+) -> GzipFile: ...
+@overload
+def open(
+    filename: AnyPath,
+    mode: _OpenTextMode,
+    compresslevel: int = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+) -> TextIO: ...
+@overload
+def open(
+    filename: Union[AnyPath, IO[bytes]],
+    mode: str,
+    compresslevel: int = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+) -> Union[GzipFile, TextIO]: ...
+
+class _PaddedFile:
+    file: IO[bytes]
+    def __init__(self, f: IO[bytes], prepend: bytes = ...) -> None: ...
+    def read(self, size: int) -> bytes: ...
+    def prepend(self, prepend: bytes = ...) -> None: ...
+    def seek(self, off: int) -> int: ...
+    def seekable(self) -> bool: ...
+
+if sys.version_info >= (3, 8):
+    class BadGzipFile(OSError): ...
+
+class GzipFile(_compression.BaseStream):
+    myfileobj: Optional[IO[bytes]]
+    mode: str
+    name: str
+    compress: zlib._Compress
+    fileobj: IO[bytes]
+    def __init__(
+        self,
+        filename: Optional[AnyPath] = ...,
+        mode: Optional[str] = ...,
+        compresslevel: int = ...,
+        fileobj: Optional[IO[bytes]] = ...,
+        mtime: Optional[float] = ...,
+    ) -> None: ...
+    @property
+    def filename(self) -> str: ...
+    @property
+    def mtime(self) -> Optional[int]: ...
+    crc: int
+    def write(self, data: ReadableBuffer) -> int: ...
+    def read(self, size: Optional[int] = ...) -> bytes: ...
+    def read1(self, size: int = ...) -> bytes: ...
+    def peek(self, n: int) -> bytes: ...
+    @property
+    def closed(self) -> bool: ...
+    def close(self) -> None: ...
+    def flush(self, zlib_mode: int = ...) -> None: ...
+    def fileno(self) -> int: ...
+    def rewind(self) -> None: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def seek(self, offset: int, whence: int = ...) -> int: ...
+    def readline(self, size: Optional[int] = ...) -> bytes: ...
+
+class _GzipReader(_compression.DecompressReader):
+    def __init__(self, fp: IO[bytes]) -> None: ...
+    def read(self, size: int = ...) -> bytes: ...
+
+if sys.version_info >= (3, 8):
+    def compress(data: bytes, compresslevel: int = ..., *, mtime: Optional[float] = ...) -> bytes: ...
+
+else:
+    def compress(data: bytes, compresslevel: int = ...) -> bytes: ...
+
+def decompress(data: bytes) -> bytes: ...

lib/python3.12/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

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/heapq.pyi

@@ -0,0 +1,14 @@
+from _typeshed import SupportsLessThan
+from typing import Any, Callable, Iterable, List, Optional, TypeVar
+
+_T = TypeVar("_T")
+
+def heappush(__heap: List[_T], __item: _T) -> None: ...
+def heappop(__heap: List[_T]) -> _T: ...
+def heappushpop(__heap: List[_T], __item: _T) -> _T: ...
+def heapify(__heap: List[_T]) -> None: ...
+def heapreplace(__heap: List[_T], __item: _T) -> _T: ...
+def merge(*iterables: Iterable[_T], key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> Iterable[_T]: ...
+def nlargest(n: int, iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsLessThan]] = ...) -> List[_T]: ...
+def nsmallest(n: int, iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsLessThan]] = ...) -> List[_T]: ...
+def _heapify_max(__x: List[_T]) -> None: ...  # undocumented

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/imp.pyi

@@ -0,0 +1,64 @@
+import os
+import types
+from _typeshed import StrPath
+from typing import IO, Any, List, Optional, Protocol, Tuple, TypeVar, Union
+
+from _imp import (
+    acquire_lock as acquire_lock,
+    create_dynamic as create_dynamic,
+    get_frozen_object as get_frozen_object,
+    init_frozen as init_frozen,
+    is_builtin as is_builtin,
+    is_frozen as is_frozen,
+    is_frozen_package as is_frozen_package,
+    lock_held as lock_held,
+    release_lock as release_lock,
+)
+
+_T = TypeVar("_T")
+
+SEARCH_ERROR: int
+PY_SOURCE: int
+PY_COMPILED: int
+C_EXTENSION: int
+PY_RESOURCE: int
+PKG_DIRECTORY: int
+C_BUILTIN: int
+PY_FROZEN: int
+PY_CODERESOURCE: int
+IMP_HOOK: int
+
+def new_module(name: str) -> types.ModuleType: ...
+def get_magic() -> bytes: ...
+def get_tag() -> str: ...
+def cache_from_source(path: StrPath, debug_override: Optional[bool] = ...) -> str: ...
+def source_from_cache(path: StrPath) -> str: ...
+def get_suffixes() -> List[Tuple[str, str, int]]: ...
+
+class NullImporter:
+    def __init__(self, path: StrPath) -> None: ...
+    def find_module(self, fullname: Any) -> None: ...
+
+# Technically, a text file has to support a slightly different set of operations than a binary file,
+# but we ignore that here.
+class _FileLike(Protocol):
+    closed: bool
+    mode: str
+    def read(self) -> Union[str, bytes]: ...
+    def close(self) -> Any: ...
+    def __enter__(self) -> Any: ...
+    def __exit__(self, *args: Any) -> Any: ...
+
+# PathLike doesn't work for the pathname argument here
+def load_source(name: str, pathname: str, file: Optional[_FileLike] = ...) -> types.ModuleType: ...
+def load_compiled(name: str, pathname: str, file: Optional[_FileLike] = ...) -> types.ModuleType: ...
+def load_package(name: str, path: StrPath) -> types.ModuleType: ...
+def load_module(name: str, file: Optional[_FileLike], filename: str, details: Tuple[str, str, int]) -> types.ModuleType: ...
+
+# IO[Any] is a TextIOWrapper if name is a .py file, and a FileIO otherwise.
+def find_module(
+    name: str, path: Union[None, List[str], List[os.PathLike[str]], List[StrPath]] = ...
+) -> Tuple[IO[Any], str, Tuple[str, str, int]]: ...
+def reload(module: types.ModuleType) -> types.ModuleType: ...
+def init_builtin(name: str) -> Optional[types.ModuleType]: ...
+def load_dynamic(name: str, path: str, file: Any = ...) -> types.ModuleType: ...  # file argument is ignored

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/inspect.pyi

@@ -0,0 +1,309 @@
+import enum
+import sys
+from collections import OrderedDict
+from types import CodeType, FrameType, FunctionType, MethodType, ModuleType, TracebackType
+from typing import (
+    AbstractSet,
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    Generator,
+    List,
+    Mapping,
+    NamedTuple,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+)
+from typing_extensions import Literal
+
+#
+# Types and members
+#
+class EndOfBlock(Exception): ...
+
+class BlockFinder:
+    indent: int
+    islambda: bool
+    started: bool
+    passline: bool
+    indecorator: bool
+    decoratorhasargs: bool
+    last: int
+    def tokeneater(self, type: int, token: str, srowcol: Tuple[int, int], erowcol: Tuple[int, int], line: str) -> None: ...
+
+CO_OPTIMIZED: int
+CO_NEWLOCALS: int
+CO_VARARGS: int
+CO_VARKEYWORDS: int
+CO_NESTED: int
+CO_GENERATOR: int
+CO_NOFREE: int
+CO_COROUTINE: int
+CO_ITERABLE_COROUTINE: int
+CO_ASYNC_GENERATOR: int
+TPFLAGS_IS_ABSTRACT: int
+
+def getmembers(object: object, predicate: Optional[Callable[[Any], bool]] = ...) -> List[Tuple[str, Any]]: ...
+def getmodulename(path: str) -> Optional[str]: ...
+def ismodule(object: object) -> bool: ...
+def isclass(object: object) -> bool: ...
+def ismethod(object: object) -> bool: ...
+def isfunction(object: object) -> bool: ...
+
+if sys.version_info >= (3, 8):
+    def isgeneratorfunction(obj: object) -> bool: ...
+    def iscoroutinefunction(obj: object) -> bool: ...
+
+else:
+    def isgeneratorfunction(object: object) -> bool: ...
+    def iscoroutinefunction(object: object) -> bool: ...
+
+def isgenerator(object: object) -> bool: ...
+def iscoroutine(object: object) -> bool: ...
+def isawaitable(object: object) -> bool: ...
+
+if sys.version_info >= (3, 8):
+    def isasyncgenfunction(obj: object) -> bool: ...
+
+else:
+    def isasyncgenfunction(object: object) -> bool: ...
+
+def isasyncgen(object: object) -> bool: ...
+def istraceback(object: object) -> bool: ...
+def isframe(object: object) -> bool: ...
+def iscode(object: object) -> bool: ...
+def isbuiltin(object: object) -> bool: ...
+def isroutine(object: object) -> bool: ...
+def isabstract(object: object) -> bool: ...
+def ismethoddescriptor(object: object) -> bool: ...
+def isdatadescriptor(object: object) -> bool: ...
+def isgetsetdescriptor(object: object) -> bool: ...
+def ismemberdescriptor(object: object) -> bool: ...
+
+#
+# Retrieving source code
+#
+_SourceObjectType = Union[ModuleType, Type[Any], MethodType, FunctionType, TracebackType, FrameType, CodeType, Callable[..., Any]]
+
+def findsource(object: _SourceObjectType) -> Tuple[List[str], int]: ...
+def getabsfile(object: _SourceObjectType, _filename: Optional[str] = ...) -> str: ...
+def getblock(lines: Sequence[str]) -> Sequence[str]: ...
+def getdoc(object: object) -> Optional[str]: ...
+def getcomments(object: object) -> Optional[str]: ...
+def getfile(object: _SourceObjectType) -> str: ...
+def getmodule(object: object, _filename: Optional[str] = ...) -> Optional[ModuleType]: ...
+def getsourcefile(object: _SourceObjectType) -> Optional[str]: ...
+def getsourcelines(object: _SourceObjectType) -> Tuple[List[str], int]: ...
+def getsource(object: _SourceObjectType) -> str: ...
+def cleandoc(doc: str) -> str: ...
+def indentsize(line: str) -> int: ...
+
+#
+# Introspecting callables with the Signature object
+#
+def signature(obj: Callable[..., Any], *, follow_wrapped: bool = ...) -> Signature: ...
+
+class Signature:
+    def __init__(self, parameters: Optional[Sequence[Parameter]] = ..., *, return_annotation: Any = ...) -> None: ...
+    # TODO: can we be more specific here?
+    empty: object = ...
+
+    parameters: Mapping[str, Parameter]
+
+    # TODO: can we be more specific here?
+    return_annotation: Any
+    def bind(self, *args: Any, **kwargs: Any) -> BoundArguments: ...
+    def bind_partial(self, *args: Any, **kwargs: Any) -> BoundArguments: ...
+    def replace(self, *, parameters: Optional[Sequence[Parameter]] = ..., return_annotation: Any = ...) -> Signature: ...
+    @classmethod
+    def from_callable(cls, obj: Callable[..., Any], *, follow_wrapped: bool = ...) -> Signature: ...
+
+# The name is the same as the enum's name in CPython
+class _ParameterKind(enum.IntEnum):
+    POSITIONAL_ONLY: int
+    POSITIONAL_OR_KEYWORD: int
+    VAR_POSITIONAL: int
+    KEYWORD_ONLY: int
+    VAR_KEYWORD: int
+
+    if sys.version_info >= (3, 8):
+        description: str
+
+class Parameter:
+    def __init__(self, name: str, kind: _ParameterKind, *, default: Any = ..., annotation: Any = ...) -> None: ...
+    empty: Any = ...
+    name: str
+    default: Any
+    annotation: Any
+
+    kind: _ParameterKind
+    POSITIONAL_ONLY: ClassVar[Literal[_ParameterKind.POSITIONAL_ONLY]]
+    POSITIONAL_OR_KEYWORD: ClassVar[Literal[_ParameterKind.POSITIONAL_OR_KEYWORD]]
+    VAR_POSITIONAL: ClassVar[Literal[_ParameterKind.VAR_POSITIONAL]]
+    KEYWORD_ONLY: ClassVar[Literal[_ParameterKind.KEYWORD_ONLY]]
+    VAR_KEYWORD: ClassVar[Literal[_ParameterKind.VAR_KEYWORD]]
+    def replace(
+        self, *, name: Optional[str] = ..., kind: Optional[_ParameterKind] = ..., default: Any = ..., annotation: Any = ...
+    ) -> Parameter: ...
+
+class BoundArguments:
+    arguments: OrderedDict[str, Any]
+    args: Tuple[Any, ...]
+    kwargs: Dict[str, Any]
+    signature: Signature
+    def __init__(self, signature: Signature, arguments: OrderedDict[str, Any]) -> None: ...
+    def apply_defaults(self) -> None: ...
+
+#
+# Classes and functions
+#
+
+# TODO: The actual return type should be List[_ClassTreeItem] but mypy doesn't
+# seem to be supporting this at the moment:
+# _ClassTreeItem = Union[List[_ClassTreeItem], Tuple[type, Tuple[type, ...]]]
+def getclasstree(classes: List[type], unique: bool = ...) -> Any: ...
+
+class ArgSpec(NamedTuple):
+    args: List[str]
+    varargs: Optional[str]
+    keywords: Optional[str]
+    defaults: Tuple[Any, ...]
+
+class Arguments(NamedTuple):
+    args: List[str]
+    varargs: Optional[str]
+    varkw: Optional[str]
+
+def getargs(co: CodeType) -> Arguments: ...
+def getargspec(func: object) -> ArgSpec: ...
+
+class FullArgSpec(NamedTuple):
+    args: List[str]
+    varargs: Optional[str]
+    varkw: Optional[str]
+    defaults: Optional[Tuple[Any, ...]]
+    kwonlyargs: List[str]
+    kwonlydefaults: Optional[Dict[str, Any]]
+    annotations: Dict[str, Any]
+
+def getfullargspec(func: object) -> FullArgSpec: ...
+
+class ArgInfo(NamedTuple):
+    args: List[str]
+    varargs: Optional[str]
+    keywords: Optional[str]
+    locals: Dict[str, Any]
+
+def getargvalues(frame: FrameType) -> ArgInfo: ...
+def formatannotation(annotation: object, base_module: Optional[str] = ...) -> str: ...
+def formatannotationrelativeto(object: object) -> Callable[[object], str]: ...
+def formatargspec(
+    args: List[str],
+    varargs: Optional[str] = ...,
+    varkw: Optional[str] = ...,
+    defaults: Optional[Tuple[Any, ...]] = ...,
+    kwonlyargs: Optional[Sequence[str]] = ...,
+    kwonlydefaults: Optional[Dict[str, Any]] = ...,
+    annotations: Dict[str, Any] = ...,
+    formatarg: Callable[[str], str] = ...,
+    formatvarargs: Callable[[str], str] = ...,
+    formatvarkw: Callable[[str], str] = ...,
+    formatvalue: Callable[[Any], str] = ...,
+    formatreturns: Callable[[Any], str] = ...,
+    formatannotation: Callable[[Any], str] = ...,
+) -> str: ...
+def formatargvalues(
+    args: List[str],
+    varargs: Optional[str],
+    varkw: Optional[str],
+    locals: Optional[Dict[str, Any]],
+    formatarg: Optional[Callable[[str], str]] = ...,
+    formatvarargs: Optional[Callable[[str], str]] = ...,
+    formatvarkw: Optional[Callable[[str], str]] = ...,
+    formatvalue: Optional[Callable[[Any], str]] = ...,
+) -> str: ...
+def getmro(cls: type) -> Tuple[type, ...]: ...
+def getcallargs(__func: Callable[..., Any], *args: Any, **kwds: Any) -> Dict[str, Any]: ...
+
+class ClosureVars(NamedTuple):
+    nonlocals: Mapping[str, Any]
+    globals: Mapping[str, Any]
+    builtins: Mapping[str, Any]
+    unbound: AbstractSet[str]
+
+def getclosurevars(func: Callable[..., Any]) -> ClosureVars: ...
+def unwrap(func: Callable[..., Any], *, stop: Optional[Callable[[Any], Any]] = ...) -> Any: ...
+
+#
+# The interpreter stack
+#
+
+class Traceback(NamedTuple):
+    filename: str
+    lineno: int
+    function: str
+    code_context: Optional[List[str]]
+    index: Optional[int]  # type: ignore
+
+class FrameInfo(NamedTuple):
+    frame: FrameType
+    filename: str
+    lineno: int
+    function: str
+    code_context: Optional[List[str]]
+    index: Optional[int]  # type: ignore
+
+def getframeinfo(frame: Union[FrameType, TracebackType], context: int = ...) -> Traceback: ...
+def getouterframes(frame: Any, context: int = ...) -> List[FrameInfo]: ...
+def getinnerframes(tb: TracebackType, context: int = ...) -> List[FrameInfo]: ...
+def getlineno(frame: FrameType) -> int: ...
+def currentframe() -> Optional[FrameType]: ...
+def stack(context: int = ...) -> List[FrameInfo]: ...
+def trace(context: int = ...) -> List[FrameInfo]: ...
+
+#
+# Fetching attributes statically
+#
+
+def getattr_static(obj: object, attr: str, default: Optional[Any] = ...) -> Any: ...
+
+#
+# Current State of Generators and Coroutines
+#
+
+# TODO In the next two blocks of code, can we be more specific regarding the
+# type of the "enums"?
+
+GEN_CREATED: str
+GEN_RUNNING: str
+GEN_SUSPENDED: str
+GEN_CLOSED: str
+
+def getgeneratorstate(generator: Generator[Any, Any, Any]) -> str: ...
+
+CORO_CREATED: str
+CORO_RUNNING: str
+CORO_SUSPENDED: str
+CORO_CLOSED: str
+# TODO can we be more specific than "object"?
+def getcoroutinestate(coroutine: object) -> str: ...
+def getgeneratorlocals(generator: Generator[Any, Any, Any]) -> Dict[str, Any]: ...
+
+# TODO can we be more specific than "object"?
+def getcoroutinelocals(coroutine: object) -> Dict[str, Any]: ...
+
+# Create private type alias to avoid conflict with symbol of same
+# name created in Attribute class.
+_Object = object
+
+class Attribute(NamedTuple):
+    name: str
+    kind: str
+    defining_class: type
+    object: _Object
+
+def classify_class_attrs(cls: type) -> List[Attribute]: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/io.pyi

@@ -0,0 +1,186 @@
+import builtins
+import codecs
+import sys
+from _typeshed import ReadableBuffer, WriteableBuffer
+from types import TracebackType
+from typing import IO, Any, BinaryIO, Callable, Iterable, Iterator, List, Optional, TextIO, Tuple, Type, TypeVar, Union
+
+DEFAULT_BUFFER_SIZE: int
+
+SEEK_SET: int
+SEEK_CUR: int
+SEEK_END: int
+
+_T = TypeVar("_T", bound=IOBase)
+
+open = builtins.open
+
+if sys.version_info >= (3, 8):
+    def open_code(path: str) -> IO[bytes]: ...
+
+BlockingIOError = builtins.BlockingIOError
+
+class UnsupportedOperation(OSError, ValueError): ...
+
+class IOBase:
+    def __iter__(self) -> Iterator[bytes]: ...
+    def __next__(self) -> bytes: ...
+    def __enter__(self: _T) -> _T: ...
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+    ) -> Optional[bool]: ...
+    def close(self) -> None: ...
+    def fileno(self) -> int: ...
+    def flush(self) -> None: ...
+    def isatty(self) -> bool: ...
+    def readable(self) -> bool: ...
+    def readlines(self, __hint: int = ...) -> List[bytes]: ...
+    def seek(self, __offset: int, __whence: int = ...) -> int: ...
+    def seekable(self) -> bool: ...
+    def tell(self) -> int: ...
+    def truncate(self, __size: Optional[int] = ...) -> int: ...
+    def writable(self) -> bool: ...
+    def writelines(self, __lines: Iterable[ReadableBuffer]) -> None: ...
+    def readline(self, __size: Optional[int] = ...) -> bytes: ...
+    def __del__(self) -> None: ...
+    @property
+    def closed(self) -> bool: ...
+    def _checkClosed(self, msg: Optional[str] = ...) -> None: ...  # undocumented
+
+class RawIOBase(IOBase):
+    def readall(self) -> bytes: ...
+    def readinto(self, __buffer: WriteableBuffer) -> Optional[int]: ...
+    def write(self, __b: ReadableBuffer) -> Optional[int]: ...
+    def read(self, __size: int = ...) -> Optional[bytes]: ...
+
+class BufferedIOBase(IOBase):
+    raw: RawIOBase  # This is not part of the BufferedIOBase API and may not exist on some implementations.
+    def detach(self) -> RawIOBase: ...
+    def readinto(self, __buffer: WriteableBuffer) -> int: ...
+    def write(self, __buffer: ReadableBuffer) -> int: ...
+    def readinto1(self, __buffer: WriteableBuffer) -> int: ...
+    def read(self, __size: Optional[int] = ...) -> bytes: ...
+    def read1(self, __size: int = ...) -> bytes: ...
+
+class FileIO(RawIOBase, BinaryIO):
+    mode: str
+    # Technically this is whatever is passed in as file, either a str, a bytes, or an int.
+    name: Union[int, str]  # type: ignore
+    def __init__(
+        self,
+        file: Union[str, bytes, int],
+        mode: str = ...,
+        closefd: bool = ...,
+        opener: Optional[Callable[[Union[int, str], str], int]] = ...,
+    ) -> None: ...
+    @property
+    def closefd(self) -> bool: ...
+    def write(self, __b: ReadableBuffer) -> int: ...
+    def read(self, __size: int = ...) -> bytes: ...
+    def __enter__(self: _T) -> _T: ...
+
+class BytesIO(BufferedIOBase, BinaryIO):
+    def __init__(self, initial_bytes: bytes = ...) -> None: ...
+    # BytesIO does not contain a "name" field. This workaround is necessary
+    # to allow BytesIO sub-classes to add this field, as it is defined
+    # as a read-only property on IO[].
+    name: Any
+    def __enter__(self: _T) -> _T: ...
+    def getvalue(self) -> bytes: ...
+    def getbuffer(self) -> memoryview: ...
+    if sys.version_info >= (3, 7):
+        def read1(self, __size: Optional[int] = ...) -> bytes: ...
+    else:
+        def read1(self, __size: Optional[int]) -> bytes: ...  # type: ignore
+
+class BufferedReader(BufferedIOBase, BinaryIO):
+    def __enter__(self: _T) -> _T: ...
+    def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
+    def peek(self, __size: int = ...) -> bytes: ...
+    if sys.version_info >= (3, 7):
+        def read1(self, __size: int = ...) -> bytes: ...
+    else:
+        def read1(self, __size: int) -> bytes: ...  # type: ignore
+
+class BufferedWriter(BufferedIOBase, BinaryIO):
+    def __enter__(self: _T) -> _T: ...
+    def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
+    def write(self, __buffer: ReadableBuffer) -> int: ...
+
+class BufferedRandom(BufferedReader, BufferedWriter):
+    def __enter__(self: _T) -> _T: ...
+    def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
+    def seek(self, __target: int, __whence: int = ...) -> int: ...
+    if sys.version_info >= (3, 7):
+        def read1(self, __size: int = ...) -> bytes: ...
+    else:
+        def read1(self, __size: int) -> bytes: ...  # type: ignore
+
+class BufferedRWPair(BufferedIOBase):
+    def __init__(self, reader: RawIOBase, writer: RawIOBase, buffer_size: int = ...) -> None: ...
+    def peek(self, __size: int = ...) -> bytes: ...
+
+class TextIOBase(IOBase):
+    encoding: str
+    errors: Optional[str]
+    newlines: Union[str, Tuple[str, ...], None]
+    def __iter__(self) -> Iterator[str]: ...  # type: ignore
+    def __next__(self) -> str: ...  # type: ignore
+    def detach(self) -> BinaryIO: ...
+    def write(self, __s: str) -> int: ...
+    def writelines(self, __lines: Iterable[str]) -> None: ...  # type: ignore
+    def readline(self, __size: int = ...) -> str: ...  # type: ignore
+    def readlines(self, __hint: int = ...) -> List[str]: ...  # type: ignore
+    def read(self, __size: Optional[int] = ...) -> str: ...
+    def tell(self) -> int: ...
+
+class TextIOWrapper(TextIOBase, TextIO):
+    def __init__(
+        self,
+        buffer: IO[bytes],
+        encoding: Optional[str] = ...,
+        errors: Optional[str] = ...,
+        newline: Optional[str] = ...,
+        line_buffering: bool = ...,
+        write_through: bool = ...,
+    ) -> None: ...
+    @property
+    def buffer(self) -> BinaryIO: ...
+    @property
+    def closed(self) -> bool: ...
+    @property
+    def line_buffering(self) -> bool: ...
+    if sys.version_info >= (3, 7):
+        @property
+        def write_through(self) -> bool: ...
+        def reconfigure(
+            self,
+            *,
+            encoding: Optional[str] = ...,
+            errors: Optional[str] = ...,
+            newline: Optional[str] = ...,
+            line_buffering: Optional[bool] = ...,
+            write_through: Optional[bool] = ...,
+        ) -> None: ...
+    # These are inherited from TextIOBase, but must exist in the stub to satisfy mypy.
+    def __enter__(self: _T) -> _T: ...
+    def __iter__(self) -> Iterator[str]: ...  # type: ignore
+    def __next__(self) -> str: ...  # type: ignore
+    def writelines(self, __lines: Iterable[str]) -> None: ...  # type: ignore
+    def readline(self, __size: int = ...) -> str: ...  # type: ignore
+    def readlines(self, __hint: int = ...) -> List[str]: ...  # type: ignore
+    def seek(self, __cookie: int, __whence: int = ...) -> int: ...
+
+class StringIO(TextIOWrapper):
+    def __init__(self, initial_value: Optional[str] = ..., newline: Optional[str] = ...) -> None: ...
+    # StringIO does not contain a "name" field. This workaround is necessary
+    # to allow StringIO sub-classes to add this field, as it is defined
+    # as a read-only property on IO[].
+    name: Any
+    def getvalue(self) -> str: ...
+
+class IncrementalNewlineDecoder(codecs.IncrementalDecoder):
+    def __init__(self, decoder: Optional[codecs.IncrementalDecoder], translate: bool, errors: str = ...) -> None: ...
+    def decode(self, input: Union[bytes, str], final: bool = ...) -> str: ...
+    @property
+    def newlines(self) -> Optional[Union[str, Tuple[str, ...]]]: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/lzma.pyi

@@ -0,0 +1,164 @@
+import io
+from _typeshed import AnyPath, ReadableBuffer
+from typing import IO, Any, Mapping, Optional, Sequence, TextIO, TypeVar, Union, overload
+from typing_extensions import Literal
+
+_OpenBinaryWritingMode = Literal["w", "wb", "x", "xb", "a", "ab"]
+_OpenTextWritingMode = Literal["wt", "xt", "at"]
+
+_PathOrFile = Union[AnyPath, IO[bytes]]
+
+_FilterChain = Sequence[Mapping[str, Any]]
+_T = TypeVar("_T")
+
+FORMAT_AUTO: int
+FORMAT_XZ: int
+FORMAT_ALONE: int
+FORMAT_RAW: int
+CHECK_NONE: int
+CHECK_CRC32: int
+CHECK_CRC64: int
+CHECK_SHA256: int
+CHECK_ID_MAX: int
+CHECK_UNKNOWN: int
+FILTER_LZMA1: int
+FILTER_LZMA2: int
+FILTER_DELTA: int
+FILTER_X86: int
+FILTER_IA64: int
+FILTER_ARM: int
+FILTER_ARMTHUMB: int
+FILTER_SPARC: int
+FILTER_POWERPC: int
+MF_HC3: int
+MF_HC4: int
+MF_BT2: int
+MF_BT3: int
+MF_BT4: int
+MODE_FAST: int
+MODE_NORMAL: int
+PRESET_DEFAULT: int
+PRESET_EXTREME: int
+
+# from _lzma.c
+class LZMADecompressor(object):
+    def __init__(
+        self, format: Optional[int] = ..., memlimit: Optional[int] = ..., filters: Optional[_FilterChain] = ...
+    ) -> None: ...
+    def decompress(self, data: bytes, max_length: int = ...) -> bytes: ...
+    @property
+    def check(self) -> int: ...
+    @property
+    def eof(self) -> bool: ...
+    @property
+    def unused_data(self) -> bytes: ...
+    @property
+    def needs_input(self) -> bool: ...
+
+# from _lzma.c
+class LZMACompressor(object):
+    def __init__(
+        self, format: Optional[int] = ..., check: int = ..., preset: Optional[int] = ..., filters: Optional[_FilterChain] = ...
+    ) -> None: ...
+    def compress(self, data: bytes) -> bytes: ...
+    def flush(self) -> bytes: ...
+
+class LZMAError(Exception): ...
+
+class LZMAFile(io.BufferedIOBase, IO[bytes]):
+    def __init__(
+        self,
+        filename: Optional[_PathOrFile] = ...,
+        mode: str = ...,
+        *,
+        format: Optional[int] = ...,
+        check: int = ...,
+        preset: Optional[int] = ...,
+        filters: Optional[_FilterChain] = ...,
+    ) -> None: ...
+    def __enter__(self: _T) -> _T: ...
+    def close(self) -> None: ...
+    @property
+    def closed(self) -> bool: ...
+    def fileno(self) -> int: ...
+    def seekable(self) -> bool: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def peek(self, size: int = ...) -> bytes: ...
+    def read(self, size: Optional[int] = ...) -> bytes: ...
+    def read1(self, size: int = ...) -> bytes: ...
+    def readline(self, size: Optional[int] = ...) -> bytes: ...
+    def write(self, data: ReadableBuffer) -> int: ...
+    def seek(self, offset: int, whence: int = ...) -> int: ...
+    def tell(self) -> int: ...
+
+@overload
+def open(
+    filename: _PathOrFile,
+    mode: Literal["r", "rb"] = ...,
+    *,
+    format: Optional[int] = ...,
+    check: Literal[-1] = ...,
+    preset: None = ...,
+    filters: Optional[_FilterChain] = ...,
+    encoding: None = ...,
+    errors: None = ...,
+    newline: None = ...,
+) -> LZMAFile: ...
+@overload
+def open(
+    filename: _PathOrFile,
+    mode: _OpenBinaryWritingMode,
+    *,
+    format: Optional[int] = ...,
+    check: int = ...,
+    preset: Optional[int] = ...,
+    filters: Optional[_FilterChain] = ...,
+    encoding: None = ...,
+    errors: None = ...,
+    newline: None = ...,
+) -> LZMAFile: ...
+@overload
+def open(
+    filename: AnyPath,
+    mode: Literal["rt"],
+    *,
+    format: Optional[int] = ...,
+    check: Literal[-1] = ...,
+    preset: None = ...,
+    filters: Optional[_FilterChain] = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+) -> TextIO: ...
+@overload
+def open(
+    filename: AnyPath,
+    mode: _OpenTextWritingMode,
+    *,
+    format: Optional[int] = ...,
+    check: int = ...,
+    preset: Optional[int] = ...,
+    filters: Optional[_FilterChain] = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+) -> TextIO: ...
+@overload
+def open(
+    filename: _PathOrFile,
+    mode: str,
+    *,
+    format: Optional[int] = ...,
+    check: int = ...,
+    preset: Optional[int] = ...,
+    filters: Optional[_FilterChain] = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+) -> Union[LZMAFile, TextIO]: ...
+def compress(
+    data: bytes, format: int = ..., check: int = ..., preset: Optional[int] = ..., filters: Optional[_FilterChain] = ...
+) -> bytes: ...
+def decompress(data: bytes, format: int = ..., memlimit: Optional[int] = ..., filters: Optional[_FilterChain] = ...) -> bytes: ...
+def is_check_supported(check: int) -> bool: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/macurl2path.pyi

@@ -0,0 +1,7 @@
+import sys
+from typing import Union
+
+if sys.version_info < (3, 7):
+    def url2pathname(pathname: str) -> str: ...
+    def pathname2url(pathname: str) -> str: ...
+    def _pncomp2url(component: Union[str, bytes]) -> str: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/ntpath.pyi

@@ -0,0 +1,144 @@
+import os
+import sys
+from _typeshed import AnyPath, BytesPath, StrPath
+from genericpath import exists as exists
+from typing import Any, AnyStr, Optional, Sequence, Tuple, TypeVar, overload
+
+_T = TypeVar("_T")
+
+if sys.version_info >= (3, 6):
+    from builtins import _PathLike
+
+# ----- os.path variables -----
+supports_unicode_filenames: bool
+# aliases (also in os)
+curdir: str
+pardir: str
+sep: str
+if sys.platform == "win32":
+    altsep: str
+else:
+    altsep: Optional[str]
+extsep: str
+pathsep: str
+defpath: str
+devnull: str
+
+# ----- os.path function stubs -----
+if sys.version_info >= (3, 6):
+    # Overloads are necessary to work around python/mypy#3644.
+    @overload
+    def abspath(path: _PathLike[AnyStr]) -> AnyStr: ...
+    @overload
+    def abspath(path: AnyStr) -> AnyStr: ...
+    @overload
+    def basename(p: _PathLike[AnyStr]) -> AnyStr: ...
+    @overload
+    def basename(p: AnyStr) -> AnyStr: ...
+    @overload
+    def dirname(p: _PathLike[AnyStr]) -> AnyStr: ...
+    @overload
+    def dirname(p: AnyStr) -> AnyStr: ...
+    @overload
+    def expanduser(path: _PathLike[AnyStr]) -> AnyStr: ...
+    @overload
+    def expanduser(path: AnyStr) -> AnyStr: ...
+    @overload
+    def expandvars(path: _PathLike[AnyStr]) -> AnyStr: ...
+    @overload
+    def expandvars(path: AnyStr) -> AnyStr: ...
+    @overload
+    def normcase(s: _PathLike[AnyStr]) -> AnyStr: ...
+    @overload
+    def normcase(s: AnyStr) -> AnyStr: ...
+    @overload
+    def normpath(path: _PathLike[AnyStr]) -> AnyStr: ...
+    @overload
+    def normpath(path: AnyStr) -> AnyStr: ...
+    if sys.platform == "win32":
+        @overload
+        def realpath(path: _PathLike[AnyStr]) -> AnyStr: ...
+        @overload
+        def realpath(path: AnyStr) -> AnyStr: ...
+    else:
+        @overload
+        def realpath(filename: _PathLike[AnyStr]) -> AnyStr: ...
+        @overload
+        def realpath(filename: AnyStr) -> AnyStr: ...
+
+else:
+    def abspath(path: AnyStr) -> AnyStr: ...
+    def basename(p: AnyStr) -> AnyStr: ...
+    def dirname(p: AnyStr) -> AnyStr: ...
+    def expanduser(path: AnyStr) -> AnyStr: ...
+    def expandvars(path: AnyStr) -> AnyStr: ...
+    def normcase(s: AnyStr) -> AnyStr: ...
+    def normpath(path: AnyStr) -> AnyStr: ...
+    if sys.platform == "win32":
+        def realpath(path: AnyStr) -> AnyStr: ...
+    else:
+        def realpath(filename: AnyStr) -> AnyStr: ...
+
+if sys.version_info >= (3, 6):
+    # In reality it returns str for sequences of StrPath and bytes for sequences
+    # of BytesPath, but mypy does not accept such a signature.
+    def commonpath(paths: Sequence[AnyPath]) -> Any: ...
+
+elif sys.version_info >= (3, 5):
+    def commonpath(paths: Sequence[AnyStr]) -> AnyStr: ...
+
+# NOTE: Empty lists results in '' (str) regardless of contained type.
+# So, fall back to Any
+def commonprefix(m: Sequence[AnyPath]) -> Any: ...
+def lexists(path: AnyPath) -> bool: ...
+
+# These return float if os.stat_float_times() == True,
+# but int is a subclass of float.
+def getatime(filename: AnyPath) -> float: ...
+def getmtime(filename: AnyPath) -> float: ...
+def getctime(filename: AnyPath) -> float: ...
+def getsize(filename: AnyPath) -> int: ...
+def isabs(s: AnyPath) -> bool: ...
+def isfile(path: AnyPath) -> bool: ...
+def isdir(s: AnyPath) -> bool: ...
+def islink(path: AnyPath) -> bool: ...
+def ismount(path: AnyPath) -> bool: ...
+
+if sys.version_info >= (3, 6):
+    @overload
+    def join(a: StrPath, *paths: StrPath) -> str: ...
+    @overload
+    def join(a: BytesPath, *paths: BytesPath) -> bytes: ...
+
+else:
+    def join(a: AnyStr, *paths: AnyStr) -> AnyStr: ...
+
+@overload
+def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ...
+@overload
+def relpath(path: StrPath, start: Optional[StrPath] = ...) -> str: ...
+def samefile(f1: AnyPath, f2: AnyPath) -> bool: ...
+def sameopenfile(fp1: int, fp2: int) -> bool: ...
+def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ...
+
+if sys.version_info >= (3, 6):
+    @overload
+    def split(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ...
+    @overload
+    def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
+    @overload
+    def splitdrive(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ...
+    @overload
+    def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
+    @overload
+    def splitext(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ...
+    @overload
+    def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
+
+else:
+    def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
+    def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
+    def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...
+
+if sys.version_info < (3, 7) and sys.platform == "win32":
+    def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ...  # deprecated

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/nturl2path.pyi

@@ -0,0 +1,2 @@
+def url2pathname(url: str) -> str: ...
+def pathname2url(p: str) -> str: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/pathlib.pyi

@@ -0,0 +1,178 @@
+import os
+import sys
+from _typeshed import OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, OpenBinaryModeWriting, OpenTextMode
+from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
+from types import TracebackType
+from typing import IO, Any, BinaryIO, Generator, List, Optional, Sequence, Tuple, Type, TypeVar, Union, overload
+from typing_extensions import Literal
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_P = TypeVar("_P", bound=PurePath)
+
+if sys.version_info >= (3, 6):
+    _PurePathBase = os.PathLike[str]
+    _PathLike = os.PathLike[str]
+else:
+    _PurePathBase = object
+    _PathLike = PurePath
+
+class PurePath(_PurePathBase):
+    parts: Tuple[str, ...]
+    drive: str
+    root: str
+    anchor: str
+    name: str
+    suffix: str
+    suffixes: List[str]
+    stem: str
+    def __new__(cls: Type[_P], *args: Union[str, _PathLike]) -> _P: ...
+    def __hash__(self) -> int: ...
+    def __lt__(self, other: PurePath) -> bool: ...
+    def __le__(self, other: PurePath) -> bool: ...
+    def __gt__(self, other: PurePath) -> bool: ...
+    def __ge__(self, other: PurePath) -> bool: ...
+    def __truediv__(self: _P, key: Union[str, _PathLike]) -> _P: ...
+    def __rtruediv__(self: _P, key: Union[str, _PathLike]) -> _P: ...
+    def __bytes__(self) -> bytes: ...
+    def as_posix(self) -> str: ...
+    def as_uri(self) -> str: ...
+    def is_absolute(self) -> bool: ...
+    def is_reserved(self) -> bool: ...
+    if sys.version_info >= (3, 9):
+        def is_relative_to(self, *other: Union[str, os.PathLike[str]]) -> bool: ...
+    def match(self, path_pattern: str) -> bool: ...
+    def relative_to(self: _P, *other: Union[str, _PathLike]) -> _P: ...
+    def with_name(self: _P, name: str) -> _P: ...
+    if sys.version_info >= (3, 9):
+        def with_stem(self: _P, stem: str) -> _P: ...
+    def with_suffix(self: _P, suffix: str) -> _P: ...
+    def joinpath(self: _P, *other: Union[str, _PathLike]) -> _P: ...
+    @property
+    def parents(self: _P) -> Sequence[_P]: ...
+    @property
+    def parent(self: _P) -> _P: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, type: Any) -> GenericAlias: ...
+
+class PurePosixPath(PurePath): ...
+class PureWindowsPath(PurePath): ...
+
+class Path(PurePath):
+    def __new__(cls: Type[_P], *args: Union[str, _PathLike], **kwargs: Any) -> _P: ...
+    def __enter__(self: _P) -> _P: ...
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[TracebackType]
+    ) -> Optional[bool]: ...
+    @classmethod
+    def cwd(cls: Type[_P]) -> _P: ...
+    def stat(self) -> os.stat_result: ...
+    def chmod(self, mode: int) -> None: ...
+    def exists(self) -> bool: ...
+    def glob(self: _P, pattern: str) -> Generator[_P, None, None]: ...
+    def group(self) -> str: ...
+    def is_dir(self) -> bool: ...
+    def is_file(self) -> bool: ...
+    if sys.version_info >= (3, 7):
+        def is_mount(self) -> bool: ...
+    def is_symlink(self) -> bool: ...
+    def is_socket(self) -> bool: ...
+    def is_fifo(self) -> bool: ...
+    def is_block_device(self) -> bool: ...
+    def is_char_device(self) -> bool: ...
+    def iterdir(self: _P) -> Generator[_P, None, None]: ...
+    def lchmod(self, mode: int) -> None: ...
+    def lstat(self) -> os.stat_result: ...
+    def mkdir(self, mode: int = ..., parents: bool = ..., exist_ok: bool = ...) -> None: ...
+    # Adapted from builtins.open
+    # Text mode: always returns a TextIOWrapper
+    @overload
+    def open(
+        self,
+        mode: OpenTextMode = ...,
+        buffering: int = ...,
+        encoding: Optional[str] = ...,
+        errors: Optional[str] = ...,
+        newline: Optional[str] = ...,
+    ) -> TextIOWrapper: ...
+    # Unbuffered binary mode: returns a FileIO
+    @overload
+    def open(
+        self, mode: OpenBinaryMode, buffering: Literal[0], encoding: None = ..., errors: None = ..., newline: None = ...
+    ) -> FileIO: ...
+    # Buffering is on: return BufferedRandom, BufferedReader, or BufferedWriter
+    @overload
+    def open(
+        self,
+        mode: OpenBinaryModeUpdating,
+        buffering: Literal[-1, 1] = ...,
+        encoding: None = ...,
+        errors: None = ...,
+        newline: None = ...,
+    ) -> BufferedRandom: ...
+    @overload
+    def open(
+        self,
+        mode: OpenBinaryModeWriting,
+        buffering: Literal[-1, 1] = ...,
+        encoding: None = ...,
+        errors: None = ...,
+        newline: None = ...,
+    ) -> BufferedWriter: ...
+    @overload
+    def open(
+        self,
+        mode: OpenBinaryModeReading,
+        buffering: Literal[-1, 1] = ...,
+        encoding: None = ...,
+        errors: None = ...,
+        newline: None = ...,
+    ) -> BufferedReader: ...
+    # Buffering cannot be determined: fall back to BinaryIO
+    @overload
+    def open(
+        self, mode: OpenBinaryMode, buffering: int, encoding: None = ..., errors: None = ..., newline: None = ...
+    ) -> BinaryIO: ...
+    # Fallback if mode is not specified
+    @overload
+    def open(
+        self,
+        mode: str,
+        buffering: int = ...,
+        encoding: Optional[str] = ...,
+        errors: Optional[str] = ...,
+        newline: Optional[str] = ...,
+    ) -> IO[Any]: ...
+    def owner(self) -> str: ...
+    if sys.version_info >= (3, 9):
+        def readlink(self: _P) -> _P: ...
+    if sys.version_info >= (3, 8):
+        def rename(self: _P, target: Union[str, PurePath]) -> _P: ...
+        def replace(self: _P, target: Union[str, PurePath]) -> _P: ...
+    else:
+        def rename(self, target: Union[str, PurePath]) -> None: ...
+        def replace(self, target: Union[str, PurePath]) -> None: ...
+    def resolve(self: _P, strict: bool = ...) -> _P: ...
+    def rglob(self: _P, pattern: str) -> Generator[_P, None, None]: ...
+    def rmdir(self) -> None: ...
+    def symlink_to(self, target: Union[str, Path], target_is_directory: bool = ...) -> None: ...
+    def touch(self, mode: int = ..., exist_ok: bool = ...) -> None: ...
+    if sys.version_info >= (3, 8):
+        def unlink(self, missing_ok: bool = ...) -> None: ...
+    else:
+        def unlink(self) -> None: ...
+    @classmethod
+    def home(cls: Type[_P]) -> _P: ...
+    def absolute(self: _P) -> _P: ...
+    def expanduser(self: _P) -> _P: ...
+    def read_bytes(self) -> bytes: ...
+    def read_text(self, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> str: ...
+    def samefile(self, other_path: Union[str, bytes, int, Path]) -> bool: ...
+    def write_bytes(self, data: bytes) -> int: ...
+    def write_text(self, data: str, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> int: ...
+    if sys.version_info >= (3, 8):
+        def link_to(self, target: Union[str, bytes, os.PathLike[str]]) -> None: ...
+
+class PosixPath(Path, PurePosixPath): ...
+class WindowsPath(Path, PureWindowsPath): ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/pipes.pyi

@@ -0,0 +1,15 @@
+import os
+
+class Template:
+    def __init__(self) -> None: ...
+    def reset(self) -> None: ...
+    def clone(self) -> Template: ...
+    def debug(self, flag: bool) -> None: ...
+    def append(self, cmd: str, kind: str) -> None: ...
+    def prepend(self, cmd: str, kind: str) -> None: ...
+    def open(self, file: str, rw: str) -> os._wrap_close: ...
+    def copy(self, file: str, rw: str) -> os._wrap_close: ...
+
+# Not documented, but widely used.
+# Documented as shlex.quote since 3.3.
+def quote(s: str) -> str: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/platform.pyi

@@ -0,0 +1,66 @@
+import sys
+
+if sys.version_info < (3, 9):
+    import os
+
+    DEV_NULL = os.devnull
+from typing import NamedTuple, Optional, Tuple
+
+if sys.version_info >= (3, 8):
+    def libc_ver(
+        executable: Optional[str] = ..., lib: str = ..., version: str = ..., chunksize: int = ...
+    ) -> Tuple[str, str]: ...
+
+else:
+    def libc_ver(executable: str = ..., lib: str = ..., version: str = ..., chunksize: int = ...) -> Tuple[str, str]: ...
+
+if sys.version_info < (3, 8):
+    def linux_distribution(
+        distname: str = ...,
+        version: str = ...,
+        id: str = ...,
+        supported_dists: Tuple[str, ...] = ...,
+        full_distribution_name: bool = ...,
+    ) -> Tuple[str, str, str]: ...
+    def dist(
+        distname: str = ..., version: str = ..., id: str = ..., supported_dists: Tuple[str, ...] = ...
+    ) -> Tuple[str, str, str]: ...
+
+def win32_ver(release: str = ..., version: str = ..., csd: str = ..., ptype: str = ...) -> Tuple[str, str, str, str]: ...
+
+if sys.version_info >= (3, 8):
+    def win32_edition() -> str: ...
+    def win32_is_iot() -> bool: ...
+
+def mac_ver(
+    release: str = ..., versioninfo: Tuple[str, str, str] = ..., machine: str = ...
+) -> Tuple[str, Tuple[str, str, str], str]: ...
+def java_ver(
+    release: str = ..., vendor: str = ..., vminfo: Tuple[str, str, str] = ..., osinfo: Tuple[str, str, str] = ...
+) -> Tuple[str, str, Tuple[str, str, str], Tuple[str, str, str]]: ...
+def system_alias(system: str, release: str, version: str) -> Tuple[str, str, str]: ...
+def architecture(executable: str = ..., bits: str = ..., linkage: str = ...) -> Tuple[str, str]: ...
+
+class uname_result(NamedTuple):
+    system: str
+    node: str
+    release: str
+    version: str
+    machine: str
+    processor: str
+
+def uname() -> uname_result: ...
+def system() -> str: ...
+def node() -> str: ...
+def release() -> str: ...
+def version() -> str: ...
+def machine() -> str: ...
+def processor() -> str: ...
+def python_implementation() -> str: ...
+def python_version() -> str: ...
+def python_version_tuple() -> Tuple[str, str, str]: ...
+def python_branch() -> str: ...
+def python_revision() -> str: ...
+def python_build() -> Tuple[str, str]: ...
+def python_compiler() -> str: ...
+def platform(aliased: bool = ..., terse: bool = ...) -> str: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/posix.pyi

@@ -0,0 +1,165 @@
+import sys
+from builtins import _PathLike  # See comment in builtins
+from os import stat_result as stat_result
+from typing import Dict, List, NamedTuple, Optional, overload
+
+class uname_result(NamedTuple):
+    sysname: str
+    nodename: str
+    release: str
+    version: str
+    machine: str
+
+class times_result(NamedTuple):
+    user: float
+    system: float
+    children_user: float
+    children_system: float
+    elapsed: float
+
+class waitid_result(NamedTuple):
+    si_pid: int
+    si_uid: int
+    si_signo: int
+    si_status: int
+    si_code: int
+
+class sched_param(NamedTuple):
+    sched_priority: int
+
+CLD_CONTINUED: int
+CLD_DUMPED: int
+CLD_EXITED: int
+CLD_TRAPPED: int
+
+EX_CANTCREAT: int
+EX_CONFIG: int
+EX_DATAERR: int
+EX_IOERR: int
+EX_NOHOST: int
+EX_NOINPUT: int
+EX_NOPERM: int
+EX_NOTFOUND: int
+EX_NOUSER: int
+EX_OK: int
+EX_OSERR: int
+EX_OSFILE: int
+EX_PROTOCOL: int
+EX_SOFTWARE: int
+EX_TEMPFAIL: int
+EX_UNAVAILABLE: int
+EX_USAGE: int
+
+F_OK: int
+R_OK: int
+W_OK: int
+X_OK: int
+
+F_LOCK: int
+F_TEST: int
+F_TLOCK: int
+F_ULOCK: int
+
+GRND_NONBLOCK: int
+GRND_RANDOM: int
+NGROUPS_MAX: int
+
+O_APPEND: int
+O_ACCMODE: int
+O_ASYNC: int
+O_CREAT: int
+O_DIRECT: int
+O_DIRECTORY: int
+O_DSYNC: int
+O_EXCL: int
+O_LARGEFILE: int
+O_NDELAY: int
+O_NOATIME: int
+O_NOCTTY: int
+O_NOFOLLOW: int
+O_NONBLOCK: int
+O_RDONLY: int
+O_RDWR: int
+O_RSYNC: int
+O_SYNC: int
+O_TRUNC: int
+O_WRONLY: int
+
+POSIX_FADV_DONTNEED: int
+POSIX_FADV_NOREUSE: int
+POSIX_FADV_NORMAL: int
+POSIX_FADV_RANDOM: int
+POSIX_FADV_SEQUENTIAL: int
+POSIX_FADV_WILLNEED: int
+
+PRIO_PGRP: int
+PRIO_PROCESS: int
+PRIO_USER: int
+
+P_ALL: int
+P_PGID: int
+P_PID: int
+
+RTLD_DEEPBIND: int
+RTLD_GLOBAL: int
+RTLD_LAZY: int
+RTLD_LOCAL: int
+RTLD_NODELETE: int
+RTLD_NOLOAD: int
+RTLD_NOW: int
+
+SCHED_BATCH: int
+SCHED_FIFO: int
+SCHED_IDLE: int
+SCHED_OTHER: int
+SCHED_RESET_ON_FORK: int
+SCHED_RR: int
+
+SEEK_DATA: int
+SEEK_HOLE: int
+
+ST_APPEND: int
+ST_MANDLOCK: int
+ST_NOATIME: int
+ST_NODEV: int
+ST_NODIRATIME: int
+ST_NOEXEC: int
+ST_NOSUID: int
+ST_RDONLY: int
+ST_RELATIME: int
+ST_SYNCHRONOUS: int
+ST_WRITE: int
+
+TMP_MAX: int
+WCONTINUED: int
+
+def WCOREDUMP(__status: int) -> bool: ...
+def WEXITSTATUS(status: int) -> int: ...
+def WIFCONTINUED(status: int) -> bool: ...
+def WIFEXITED(status: int) -> bool: ...
+def WIFSIGNALED(status: int) -> bool: ...
+def WIFSTOPPED(status: int) -> bool: ...
+
+WNOHANG: int
+
+def WSTOPSIG(status: int) -> int: ...
+def WTERMSIG(status: int) -> int: ...
+
+WUNTRACED: int
+
+XATTR_CREATE: int
+XATTR_REPLACE: int
+XATTR_SIZE_MAX: int
+@overload
+def listdir(path: Optional[str] = ...) -> List[str]: ...
+@overload
+def listdir(path: bytes) -> List[bytes]: ...
+@overload
+def listdir(path: int) -> List[str]: ...
+@overload
+def listdir(path: _PathLike[str]) -> List[str]: ...
+
+if sys.platform == "win32":
+    environ: Dict[str, str]
+else:
+    environ: Dict[bytes, bytes]

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/queue.pyi

@@ -0,0 +1,52 @@
+import sys
+from threading import Condition, Lock
+from typing import Any, Generic, Optional, TypeVar
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+
+class Empty(Exception): ...
+class Full(Exception): ...
+
+class Queue(Generic[_T]):
+    maxsize: int
+
+    mutex: Lock  # undocumented
+    not_empty: Condition  # undocumented
+    not_full: Condition  # undocumented
+    all_tasks_done: Condition  # undocumented
+    unfinished_tasks: int  # undocumented
+    queue: Any  # undocumented
+    def __init__(self, maxsize: int = ...) -> None: ...
+    def _init(self, maxsize: int) -> None: ...
+    def empty(self) -> bool: ...
+    def full(self) -> bool: ...
+    def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
+    def get_nowait(self) -> _T: ...
+    def _get(self) -> _T: ...
+    def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
+    def put_nowait(self, item: _T) -> None: ...
+    def _put(self, item: _T) -> None: ...
+    def join(self) -> None: ...
+    def qsize(self) -> int: ...
+    def _qsize(self) -> int: ...
+    def task_done(self) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class PriorityQueue(Queue[_T]): ...
+class LifoQueue(Queue[_T]): ...
+
+if sys.version_info >= (3, 7):
+    class SimpleQueue(Generic[_T]):
+        def __init__(self) -> None: ...
+        def empty(self) -> bool: ...
+        def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ...
+        def get_nowait(self) -> _T: ...
+        def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ...
+        def put_nowait(self, item: _T) -> None: ...
+        def qsize(self) -> int: ...
+        if sys.version_info >= (3, 9):
+            def __class_getitem__(cls, item: Any) -> GenericAlias: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/reprlib.pyi

@@ -0,0 +1,36 @@
+from array import array
+from typing import Any, Callable, Deque, Dict, FrozenSet, List, Set, Tuple
+
+_ReprFunc = Callable[[Any], str]
+
+def recursive_repr(fillvalue: str = ...) -> Callable[[_ReprFunc], _ReprFunc]: ...
+
+class Repr:
+    maxlevel: int
+    maxdict: int
+    maxlist: int
+    maxtuple: int
+    maxset: int
+    maxfrozenset: int
+    maxdeque: int
+    maxarray: int
+    maxlong: int
+    maxstring: int
+    maxother: int
+    def __init__(self) -> None: ...
+    def repr(self, x: Any) -> str: ...
+    def repr1(self, x: Any, level: int) -> str: ...
+    def repr_tuple(self, x: Tuple[Any, ...], level: int) -> str: ...
+    def repr_list(self, x: List[Any], level: int) -> str: ...
+    def repr_array(self, x: array[Any], level: int) -> str: ...
+    def repr_set(self, x: Set[Any], level: int) -> str: ...
+    def repr_frozenset(self, x: FrozenSet[Any], level: int) -> str: ...
+    def repr_deque(self, x: Deque[Any], level: int) -> str: ...
+    def repr_dict(self, x: Dict[Any, Any], level: int) -> str: ...
+    def repr_str(self, x: str, level: int) -> str: ...
+    def repr_int(self, x: int, level: int) -> str: ...
+    def repr_instance(self, x: Any, level: int) -> str: ...
+
+aRepr: Repr
+
+def repr(x: object) -> str: ...

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/resource.pyi

@@ -0,0 +1,55 @@
+import sys
+from typing import NamedTuple, Tuple, overload
+
+RLIMIT_AS: int
+RLIMIT_CORE: int
+RLIMIT_CPU: int
+RLIMIT_DATA: int
+RLIMIT_FSIZE: int
+RLIMIT_MEMLOCK: int
+RLIMIT_NOFILE: int
+RLIMIT_NPROC: int
+RLIMIT_RSS: int
+RLIMIT_STACK: int
+RLIM_INFINITY: int
+RUSAGE_CHILDREN: int
+RUSAGE_SELF: int
+if sys.platform == "linux":
+    RLIMIT_MSGQUEUE: int
+    RLIMIT_NICE: int
+    RLIMIT_OFILE: int
+    RLIMIT_RTPRIO: int
+    RLIMIT_RTTIME: int
+    RLIMIT_SIGPENDING: int
+    RUSAGE_THREAD: int
+
+class _RUsage(NamedTuple):
+    ru_utime: float
+    ru_stime: float
+    ru_maxrss: int
+    ru_ixrss: int
+    ru_idrss: int
+    ru_isrss: int
+    ru_minflt: int
+    ru_majflt: int
+    ru_nswap: int
+    ru_inblock: int
+    ru_oublock: int
+    ru_msgsnd: int
+    ru_msgrcv: int
+    ru_nsignals: int
+    ru_nvcsw: int
+    ru_nivcsw: int
+
+def getpagesize() -> int: ...
+def getrlimit(__resource: int) -> Tuple[int, int]: ...
+def getrusage(__who: int) -> _RUsage: ...
+def setrlimit(__resource: int, __limits: Tuple[int, int]) -> None: ...
+
+if sys.platform == "linux":
+    @overload
+    def prlimit(pid: int, resource: int, limits: Tuple[int, int]) -> Tuple[int, int]: ...
+    @overload
+    def prlimit(pid: int, resource: int) -> Tuple[int, int]: ...
+
+error = OSError

lib/python3.12/site-packages/jedi/third_party/typeshed/stdlib/3/runpy.pyi

@@ -0,0 +1,22 @@
+from types import ModuleType
+from typing import Any, Dict, Optional, TypeVar
+
+_T = TypeVar("_T")
+
+class _TempModule:
+    mod_name: str = ...
+    module: ModuleType = ...
+    def __init__(self, mod_name: str) -> None: ...
+    def __enter__(self: _T) -> _T: ...
+    def __exit__(self, *args: Any) -> None: ...
+
+class _ModifiedArgv0:
+    value: Any = ...
+    def __init__(self, value: Any) -> None: ...
+    def __enter__(self: _T) -> _T: ...
+    def __exit__(self, *args: Any) -> None: ...
+
+def run_module(
+    mod_name: str, init_globals: Optional[Dict[str, Any]] = ..., run_name: Optional[str] = ..., alter_sys: bool = ...
+) -> None: ...
+def run_path(path_name: str, init_globals: Optional[Dict[str, Any]] = ..., run_name: str = ...) -> None: ...