layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/pyclbr.pyi

@@ -0,0 +1,57 @@
+from collections.abc import Mapping, Sequence
+
+__all__ = ["readmodule", "readmodule_ex", "Class", "Function"]
+
+class _Object:
+    module: str
+    name: str
+    file: int
+    lineno: int
+    end_lineno: int | None
+    parent: _Object | None
+
+    # This is a dict at runtime, but we're typing it as Mapping to
+    # avoid variance issues in the subclasses
+    children: Mapping[str, _Object]
+
+    def __init__(
+        self, module: str, name: str, file: str, lineno: int, end_lineno: int | None, parent: _Object | None
+    ) -> None: ...
+
+class Function(_Object):
+    is_async: bool
+    parent: Function | Class | None
+    children: dict[str, Class | Function]
+
+    def __init__(
+        self,
+        module: str,
+        name: str,
+        file: str,
+        lineno: int,
+        parent: Function | Class | None = None,
+        is_async: bool = False,
+        *,
+        end_lineno: int | None = None,
+    ) -> None: ...
+
+class Class(_Object):
+    super: list[Class | str] | None
+    methods: dict[str, int]
+    parent: Class | None
+    children: dict[str, Class | Function]
+
+    def __init__(
+        self,
+        module: str,
+        name: str,
+        super_: list[Class | str] | None,
+        file: str,
+        lineno: int,
+        parent: Class | None = None,
+        *,
+        end_lineno: int | None = None,
+    ) -> None: ...
+
+def readmodule(module: str, path: Sequence[str] | None = None) -> dict[str, Class]: ...
+def readmodule_ex(module: str, path: Sequence[str] | None = None) -> dict[str, Class | Function | list[str]]: ...

package/analyzers/project-map-python/typeshed/stdlib/pydoc.pyi

@@ -0,0 +1,348 @@
+import sys
+from _typeshed import OptExcInfo, StrPath, SupportsWrite, Unused
+from abc import abstractmethod
+from builtins import list as _list  # "list" conflicts with method name
+from collections.abc import Callable, Container, Mapping, MutableMapping
+from reprlib import Repr
+from types import MethodType, ModuleType, TracebackType
+from typing import IO, Any, AnyStr, Final, NoReturn, Protocol, TypeGuard, TypeVar, overload, type_check_only
+from typing_extensions import deprecated
+
+__all__ = ["help"]
+
+_T = TypeVar("_T")
+
+__author__: Final[str]
+__date__: Final[str]
+__version__: Final[str]
+__credits__: Final[str]
+
+@type_check_only
+class _Pager(Protocol):
+    def __call__(self, text: str, title: str = "") -> None: ...
+
+def pathdirs() -> list[str]: ...
+def getdoc(object: object) -> str: ...
+def splitdoc(doc: AnyStr) -> tuple[AnyStr, AnyStr]: ...
+def classname(object: object, modname: str) -> str: ...
+def isdata(object: object) -> bool: ...
+def replace(text: AnyStr, *pairs: AnyStr) -> AnyStr: ...
+def cram(text: str, maxlen: int) -> str: ...
+def stripid(text: str) -> str: ...
+def allmethods(cl: type) -> MutableMapping[str, MethodType]: ...
+def visiblename(name: str, all: Container[str] | None = None, obj: object = None) -> bool: ...
+def classify_class_attrs(object: object) -> list[tuple[str, str, type, str]]: ...
+@deprecated("Deprecated since Python 3.13.")
+def ispackage(path: StrPath) -> bool: ...  # undocumented
+def source_synopsis(file: IO[AnyStr]) -> AnyStr | None: ...
+def synopsis(filename: str, cache: MutableMapping[str, tuple[int, str]] = {}) -> str | None: ...
+
+class ErrorDuringImport(Exception):
+    filename: str
+    exc: type[BaseException] | None
+    value: BaseException | None
+    tb: TracebackType | None
+    if sys.version_info >= (3, 12):
+        @overload
+        def __init__(self, filename: str, exc_info: BaseException) -> None: ...
+        @overload
+        @deprecated("A tuple value for `exc_info` parameter is deprecated since Python 3.12. Use an exception instance.")
+        def __init__(self, filename: str, exc_info: OptExcInfo) -> None: ...
+    else:
+        def __init__(self, filename: str, exc_info: OptExcInfo) -> None: ...
+
+def importfile(path: str) -> ModuleType: ...
+def safeimport(path: str, forceload: bool = ..., cache: MutableMapping[str, ModuleType] = {}) -> ModuleType | None: ...
+
+class Doc:
+    PYTHONDOCS: str
+    if sys.version_info >= (3, 15):
+        STDLIB_DIR: str
+
+    def document(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    def fail(self, object: object, name: str | None = None, *args: Any) -> NoReturn: ...
+    @abstractmethod
+    def docmodule(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docclass(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docroutine(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docother(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docproperty(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    @abstractmethod
+    def docdata(self, object: object, name: str | None = None, *args: Any) -> str: ...
+    if sys.version_info >= (3, 15):
+        def getdocloc(self, object: object, basedir: str | None = None) -> str | None: ...
+    else:
+        def getdocloc(self, object: object, basedir: str = ...) -> str | None: ...
+
+class HTMLRepr(Repr):
+    def __init__(self) -> None: ...
+    def escape(self, text: str) -> str: ...
+    def repr(self, object: object) -> str: ...
+    def repr1(self, x: object, level: complex) -> str: ...
+    def repr_string(self, x: str, level: complex) -> str: ...
+    def repr_str(self, x: str, level: complex) -> str: ...
+    def repr_instance(self, x: object, level: complex) -> str: ...
+    def repr_unicode(self, x: AnyStr, level: complex) -> str: ...
+
+class HTMLDoc(Doc):
+    _repr_instance: HTMLRepr
+    repr = _repr_instance.repr
+    escape = _repr_instance.escape
+    def page(self, title: str, contents: str) -> str: ...
+    if sys.version_info >= (3, 11):
+        def heading(self, title: str, extras: str = "") -> str: ...
+        def section(
+            self,
+            title: str,
+            cls: str,
+            contents: str,
+            width: int = 6,
+            prelude: str = "",
+            marginalia: str | None = None,
+            gap: str = " ",
+        ) -> str: ...
+        def multicolumn(self, list: list[_T], format: Callable[[_T], str]) -> str: ...
+    else:
+        def heading(self, title: str, fgcol: str, bgcol: str, extras: str = "") -> str: ...
+        def section(
+            self,
+            title: str,
+            fgcol: str,
+            bgcol: str,
+            contents: str,
+            width: int = 6,
+            prelude: str = "",
+            marginalia: str | None = None,
+            gap: str = " ",
+        ) -> str: ...
+        def multicolumn(self, list: list[_T], format: Callable[[_T], str], cols: int = 4) -> str: ...
+
+    def bigsection(self, title: str, *args: Any) -> str: ...
+    def preformat(self, text: str) -> str: ...
+    def grey(self, text: str) -> str: ...
+    def namelink(self, name: str, *dicts: MutableMapping[str, str]) -> str: ...
+    def classlink(self, object: object, modname: str) -> str: ...
+    def modulelink(self, object: object) -> str: ...
+    def modpkglink(self, modpkginfo: tuple[str, str, bool, bool]) -> str: ...
+    def markup(
+        self,
+        text: str,
+        escape: Callable[[str], str] | None = None,
+        funcs: Mapping[str, str] = {},
+        classes: Mapping[str, str] = {},
+        methods: Mapping[str, str] = {},
+    ) -> str: ...
+    def formattree(
+        self, tree: list[tuple[type, tuple[type, ...]] | list[Any]], modname: str, parent: type | None = None
+    ) -> str: ...
+    def docmodule(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Unused) -> str: ...
+    def docclass(
+        self,
+        object: object,
+        name: str | None = None,
+        mod: str | None = None,
+        funcs: Mapping[str, str] = {},
+        classes: Mapping[str, str] = {},
+        *ignored: Unused,
+    ) -> str: ...
+    def formatvalue(self, object: object) -> str: ...
+    def docother(self, object: object, name: str | None = None, mod: Any | None = None, *ignored: Unused) -> str: ...
+    if sys.version_info >= (3, 11):
+        def docroutine(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            funcs: Mapping[str, str] = {},
+            classes: Mapping[str, str] = {},
+            methods: Mapping[str, str] = {},
+            cl: type | None = None,
+            homecls: type | None = None,
+        ) -> str: ...
+        def docproperty(
+            self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+        def docdata(
+            self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+    else:
+        def docroutine(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            funcs: Mapping[str, str] = {},
+            classes: Mapping[str, str] = {},
+            methods: Mapping[str, str] = {},
+            cl: type | None = None,
+        ) -> str: ...
+        def docproperty(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docdata(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    if sys.version_info >= (3, 11):
+        def parentlink(self, object: type | ModuleType, modname: str) -> str: ...
+
+    def index(self, dir: str, shadowed: MutableMapping[str, bool] | None = None) -> str: ...
+    def filelink(self, url: str, path: str) -> str: ...
+
+class TextRepr(Repr):
+    def __init__(self) -> None: ...
+    def repr1(self, x: object, level: complex) -> str: ...
+    def repr_string(self, x: str, level: complex) -> str: ...
+    def repr_str(self, x: str, level: complex) -> str: ...
+    def repr_instance(self, x: object, level: complex) -> str: ...
+
+class TextDoc(Doc):
+    _repr_instance: TextRepr
+    repr = _repr_instance.repr
+    def bold(self, text: str) -> str: ...
+    def indent(self, text: str, prefix: str = "    ") -> str: ...
+    def section(self, title: str, contents: str) -> str: ...
+    def formattree(
+        self, tree: list[tuple[type, tuple[type, ...]] | list[Any]], modname: str, parent: type | None = None, prefix: str = ""
+    ) -> str: ...
+    def docclass(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Unused) -> str: ...
+    def formatvalue(self, object: object) -> str: ...
+    if sys.version_info >= (3, 11):
+        def docroutine(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            cl: Any | None = None,
+            homecls: Any | None = None,
+        ) -> str: ...
+        def docmodule(self, object: object, name: str | None = None, mod: Any | None = None, *ignored: Unused) -> str: ...
+        def docproperty(
+            self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+        def docdata(
+            self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+        def docother(
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            parent: str | None = None,
+            *ignored: Unused,
+            maxlen: int | None = None,
+            doc: Any | None = None,
+        ) -> str: ...
+    else:
+        def docroutine(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docmodule(self, object: object, name: str | None = None, mod: Any | None = None) -> str: ...  # type: ignore[override]
+        def docproperty(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docdata(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docother(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            parent: str | None = None,
+            maxlen: int | None = None,
+            doc: Any | None = None,
+        ) -> str: ...
+
+if sys.version_info >= (3, 13):
+    def pager(text: str, title: str = "") -> None: ...
+
+else:
+    def pager(text: str) -> None: ...
+
+def plain(text: str) -> str: ...
+def describe(thing: Any) -> str: ...
+def locate(path: str, forceload: bool = ...) -> object: ...
+
+if sys.version_info >= (3, 13):
+    def get_pager() -> _Pager: ...
+    def pipe_pager(text: str, cmd: str, title: str = "") -> None: ...
+    def tempfile_pager(text: str, cmd: str, title: str = "") -> None: ...
+    def tty_pager(text: str, title: str = "") -> None: ...
+    def plain_pager(text: str, title: str = "") -> None: ...
+
+    # For backwards compatibility.
+    getpager = get_pager
+    pipepager = pipe_pager
+    tempfilepager = tempfile_pager
+    ttypager = tty_pager
+    plainpager = plain_pager
+else:
+    def getpager() -> Callable[[str], None]: ...
+    def pipepager(text: str, cmd: str) -> None: ...
+    def tempfilepager(text: str, cmd: str) -> None: ...
+    def ttypager(text: str) -> None: ...
+    def plainpager(text: str) -> None: ...
+
+text: TextDoc
+html: HTMLDoc
+
+def resolve(thing: str | object, forceload: bool = ...) -> tuple[object, str] | None: ...
+def render_doc(
+    thing: str | object, title: str = "Python Library Documentation: %s", forceload: bool = ..., renderer: Doc | None = None
+) -> str: ...
+
+if sys.version_info >= (3, 11):
+    def doc(
+        thing: str | object,
+        title: str = "Python Library Documentation: %s",
+        forceload: bool = ...,
+        output: SupportsWrite[str] | None = None,
+        is_cli: bool = False,
+    ) -> None: ...
+
+else:
+    def doc(
+        thing: str | object,
+        title: str = "Python Library Documentation: %s",
+        forceload: bool = ...,
+        output: SupportsWrite[str] | None = None,
+    ) -> None: ...
+
+def writedoc(thing: str | object, forceload: bool = ...) -> None: ...
+def writedocs(dir: str, pkgpath: str = "", done: Any | None = None) -> None: ...
+
+class Helper:
+    keywords: dict[str, str | tuple[str, str]]
+    symbols: dict[str, str]
+    topics: dict[str, str | tuple[str, ...]]
+    def __init__(self, input: IO[str] | None = None, output: IO[str] | None = None) -> None: ...
+    @property
+    def input(self) -> IO[str]: ...
+    @property
+    def output(self) -> IO[str]: ...
+    def __call__(self, request: str | Helper | object = ...) -> None: ...
+    def interact(self) -> None: ...
+    def getline(self, prompt: str) -> str: ...
+    if sys.version_info >= (3, 11):
+        def help(self, request: Any, is_cli: bool = False) -> None: ...
+    else:
+        def help(self, request: Any) -> None: ...
+
+    def intro(self) -> None: ...
+    def list(self, items: _list[str], columns: int = 4, width: int = 80) -> None: ...
+    def listkeywords(self) -> None: ...
+    def listsymbols(self) -> None: ...
+    def listtopics(self) -> None: ...
+    def showtopic(self, topic: str, more_xrefs: str = "") -> None: ...
+    def showsymbol(self, symbol: str) -> None: ...
+    def listmodules(self, key: str = "") -> None: ...
+
+help: Helper
+
+class ModuleScanner:
+    quit: bool
+    def run(
+        self,
+        callback: Callable[[str | None, str, str], object],
+        key: str | None = None,
+        completer: Callable[[], object] | None = None,
+        onerror: Callable[[str], object] | None = None,
+    ) -> None: ...
+
+def apropos(key: str) -> None: ...
+def ispath(x: object) -> TypeGuard[str]: ...
+def cli() -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/pydoc_data/module_docs.pyi

@@ -0,0 +1,3 @@
+from typing import Final
+
+module_docs: Final[dict[str, str]]

package/analyzers/project-map-python/typeshed/stdlib/pydoc_data/topics.pyi

@@ -0,0 +1,3 @@
+from typing import Final
+
+topics: Final[dict[str, str]]

package/analyzers/project-map-python/typeshed/stdlib/pyexpat/__init__.pyi

@@ -0,0 +1,91 @@
+import sys
+from _typeshed import ReadableBuffer, SupportsRead
+from collections.abc import Callable
+from pyexpat import errors as errors, model as model
+from typing import Any, Final, TypeAlias, final
+from typing_extensions import CapsuleType
+from xml.parsers.expat import ExpatError as ExpatError
+
+EXPAT_VERSION: Final[str]  # undocumented
+version_info: tuple[int, int, int]  # undocumented
+native_encoding: str  # undocumented
+features: list[tuple[str, int]]  # undocumented
+
+error = ExpatError
+XML_PARAM_ENTITY_PARSING_NEVER: Final = 0
+XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: Final = 1
+XML_PARAM_ENTITY_PARSING_ALWAYS: Final = 2
+
+_Model: TypeAlias = tuple[int, int, str | None, tuple[Any, ...]]
+
+@final
+class XMLParserType:
+    def Parse(self, data: str | ReadableBuffer, isfinal: bool = False, /) -> int: ...
+    def ParseFile(self, file: SupportsRead[bytes], /) -> int: ...
+    def SetBase(self, base: str, /) -> None: ...
+    def GetBase(self) -> str | None: ...
+    def GetInputContext(self) -> bytes | None: ...
+    def ExternalEntityParserCreate(self, context: str | None, encoding: str = ..., /) -> XMLParserType: ...
+    def SetParamEntityParsing(self, flag: int, /) -> int: ...
+    def UseForeignDTD(self, flag: bool = True, /) -> None: ...
+    def GetReparseDeferralEnabled(self) -> bool: ...
+    def SetReparseDeferralEnabled(self, enabled: bool, /) -> None: ...
+    # Added in Python 3.10.20, 3.11.15, 3.12.3, 3.13.10, 3.14.1
+    def SetAllocTrackerActivationThreshold(self, threshold: int, /) -> None: ...
+    def SetAllocTrackerMaximumAmplification(self, max_factor: float, /) -> None: ...
+    if sys.version_info >= (3, 13):
+        # Added in Python 3.13.4, 3.14.6
+        def SetBillionLaughsAttackProtectionActivationThreshold(self, threshold: int, /) -> None: ...
+        def SetBillionLaughsAttackProtectionMaximumAmplification(self, max_factor: float, /) -> None: ...
+
+    @property
+    def intern(self) -> dict[str, str]: ...
+    buffer_size: int
+    buffer_text: bool
+    buffer_used: int
+    namespace_prefixes: bool  # undocumented
+    ordered_attributes: bool
+    specified_attributes: bool
+    ErrorByteIndex: int
+    ErrorCode: int
+    ErrorColumnNumber: int
+    ErrorLineNumber: int
+    CurrentByteIndex: int
+    CurrentColumnNumber: int
+    CurrentLineNumber: int
+    XmlDeclHandler: Callable[[str, str | None, int], Any] | None
+    StartDoctypeDeclHandler: Callable[[str, str | None, str | None, bool], Any] | None
+    EndDoctypeDeclHandler: Callable[[], Any] | None
+    ElementDeclHandler: Callable[[str, _Model], Any] | None
+    AttlistDeclHandler: Callable[[str, str, str, str | None, bool], Any] | None
+    StartElementHandler: (
+        Callable[[str, dict[str, str]], Any]
+        | Callable[[str, list[str]], Any]
+        | Callable[[str, dict[str, str], list[str]], Any]
+        | None
+    )
+    EndElementHandler: Callable[[str], Any] | None
+    ProcessingInstructionHandler: Callable[[str, str], Any] | None
+    CharacterDataHandler: Callable[[str], Any] | None
+    UnparsedEntityDeclHandler: Callable[[str, str | None, str, str | None, str], Any] | None
+    EntityDeclHandler: Callable[[str, bool, str | None, str | None, str, str | None, str | None], Any] | None
+    NotationDeclHandler: Callable[[str, str | None, str, str | None], Any] | None
+    StartNamespaceDeclHandler: Callable[[str, str], Any] | None
+    EndNamespaceDeclHandler: Callable[[str], Any] | None
+    CommentHandler: Callable[[str], Any] | None
+    StartCdataSectionHandler: Callable[[], Any] | None
+    EndCdataSectionHandler: Callable[[], Any] | None
+    DefaultHandler: Callable[[str], Any] | None
+    DefaultHandlerExpand: Callable[[str], Any] | None
+    NotStandaloneHandler: Callable[[], int] | None
+    ExternalEntityRefHandler: Callable[[str, str | None, str | None, str | None], int] | None
+    SkippedEntityHandler: Callable[[str, bool], Any] | None
+
+def ErrorString(code: int, /) -> str: ...
+
+# intern is undocumented
+def ParserCreate(
+    encoding: str | None = None, namespace_separator: str | None = None, intern: dict[str, Any] | None = None
+) -> XMLParserType: ...
+
+expat_CAPI: CapsuleType

package/analyzers/project-map-python/typeshed/stdlib/pyexpat/errors.pyi

@@ -0,0 +1,53 @@
+import sys
+from typing import Final
+from typing_extensions import LiteralString
+
+codes: dict[str, int]
+messages: dict[int, str]
+
+XML_ERROR_ABORTED: Final[LiteralString]
+XML_ERROR_ASYNC_ENTITY: Final[LiteralString]
+XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: Final[LiteralString]
+XML_ERROR_BAD_CHAR_REF: Final[LiteralString]
+XML_ERROR_BINARY_ENTITY_REF: Final[LiteralString]
+XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING: Final[LiteralString]
+XML_ERROR_DUPLICATE_ATTRIBUTE: Final[LiteralString]
+XML_ERROR_ENTITY_DECLARED_IN_PE: Final[LiteralString]
+XML_ERROR_EXTERNAL_ENTITY_HANDLING: Final[LiteralString]
+XML_ERROR_FEATURE_REQUIRES_XML_DTD: Final[LiteralString]
+XML_ERROR_FINISHED: Final[LiteralString]
+XML_ERROR_INCOMPLETE_PE: Final[LiteralString]
+XML_ERROR_INCORRECT_ENCODING: Final[LiteralString]
+XML_ERROR_INVALID_TOKEN: Final[LiteralString]
+XML_ERROR_JUNK_AFTER_DOC_ELEMENT: Final[LiteralString]
+XML_ERROR_MISPLACED_XML_PI: Final[LiteralString]
+XML_ERROR_NOT_STANDALONE: Final[LiteralString]
+XML_ERROR_NOT_SUSPENDED: Final[LiteralString]
+XML_ERROR_NO_ELEMENTS: Final[LiteralString]
+XML_ERROR_NO_MEMORY: Final[LiteralString]
+XML_ERROR_PARAM_ENTITY_REF: Final[LiteralString]
+XML_ERROR_PARTIAL_CHAR: Final[LiteralString]
+XML_ERROR_PUBLICID: Final[LiteralString]
+XML_ERROR_RECURSIVE_ENTITY_REF: Final[LiteralString]
+XML_ERROR_SUSPENDED: Final[LiteralString]
+XML_ERROR_SUSPEND_PE: Final[LiteralString]
+XML_ERROR_SYNTAX: Final[LiteralString]
+XML_ERROR_TAG_MISMATCH: Final[LiteralString]
+XML_ERROR_TEXT_DECL: Final[LiteralString]
+XML_ERROR_UNBOUND_PREFIX: Final[LiteralString]
+XML_ERROR_UNCLOSED_CDATA_SECTION: Final[LiteralString]
+XML_ERROR_UNCLOSED_TOKEN: Final[LiteralString]
+XML_ERROR_UNDECLARING_PREFIX: Final[LiteralString]
+XML_ERROR_UNDEFINED_ENTITY: Final[LiteralString]
+XML_ERROR_UNEXPECTED_STATE: Final[LiteralString]
+XML_ERROR_UNKNOWN_ENCODING: Final[LiteralString]
+XML_ERROR_XML_DECL: Final[LiteralString]
+if sys.version_info >= (3, 11):
+    XML_ERROR_RESERVED_PREFIX_XML: Final[LiteralString]
+    XML_ERROR_RESERVED_PREFIX_XMLNS: Final[LiteralString]
+    XML_ERROR_RESERVED_NAMESPACE_URI: Final[LiteralString]
+    XML_ERROR_INVALID_ARGUMENT: Final[LiteralString]
+    XML_ERROR_NO_BUFFER: Final[LiteralString]
+    XML_ERROR_AMPLIFICATION_LIMIT_BREACH: Final[LiteralString]
+if sys.version_info >= (3, 14):
+    XML_ERROR_NOT_STARTED: Final[LiteralString]

package/analyzers/project-map-python/typeshed/stdlib/pyexpat/model.pyi

@@ -0,0 +1,13 @@
+from typing import Final
+
+XML_CTYPE_ANY: Final = 2
+XML_CTYPE_EMPTY: Final = 1
+XML_CTYPE_MIXED: Final = 3
+XML_CTYPE_NAME: Final = 4
+XML_CTYPE_CHOICE: Final = 5
+XML_CTYPE_SEQ: Final = 6
+
+XML_CQUANT_NONE: Final = 0
+XML_CQUANT_OPT: Final = 1
+XML_CQUANT_REP: Final = 2
+XML_CQUANT_PLUS: Final = 3

package/analyzers/project-map-python/typeshed/stdlib/queue.pyi

@@ -0,0 +1,55 @@
+import sys
+from _queue import Empty as Empty, SimpleQueue as SimpleQueue
+from _typeshed import SupportsRichComparisonT
+from threading import Condition, Lock
+from types import GenericAlias
+from typing import Any, Generic, TypeVar
+
+__all__ = ["Empty", "Full", "Queue", "PriorityQueue", "LifoQueue", "SimpleQueue"]
+if sys.version_info >= (3, 13):
+    __all__ += ["ShutDown"]
+
+_T = TypeVar("_T")
+
+class Full(Exception): ...
+
+if sys.version_info >= (3, 13):
+    class ShutDown(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
+    if sys.version_info >= (3, 13):
+        is_shutdown: bool  # undocumented
+    # Despite the fact that `queue` has `deque` type,
+    # we treat it as `Any` to allow different implementations in subtypes.
+    queue: Any  # undocumented
+    def __init__(self, maxsize: int = 0) -> None: ...
+    def _init(self, maxsize: int) -> None: ...
+    def empty(self) -> bool: ...
+    def full(self) -> bool: ...
+    def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
+    def get_nowait(self) -> _T: ...
+    if sys.version_info >= (3, 13):
+        def shutdown(self, immediate: bool = False) -> None: ...
+
+    def _get(self) -> _T: ...
+    def put(self, item: _T, block: bool = True, timeout: float | None = None) -> 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: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+class PriorityQueue(Queue[SupportsRichComparisonT]):
+    queue: list[SupportsRichComparisonT]
+
+class LifoQueue(Queue[_T]):
+    queue: list[_T]

package/analyzers/project-map-python/typeshed/stdlib/quopri.pyi

@@ -0,0 +1,12 @@
+from _typeshed import ReadableBuffer, SupportsNoArgReadline, SupportsRead, SupportsWrite
+from typing import Protocol, type_check_only
+
+__all__ = ["encode", "decode", "encodestring", "decodestring"]
+
+@type_check_only
+class _Input(SupportsRead[bytes], SupportsNoArgReadline[bytes], Protocol): ...
+
+def encode(input: _Input, output: SupportsWrite[bytes], quotetabs: int, header: bool = False) -> None: ...
+def encodestring(s: ReadableBuffer, quotetabs: bool = False, header: bool = False) -> bytes: ...
+def decode(input: _Input, output: SupportsWrite[bytes], header: bool = False) -> None: ...
+def decodestring(s: str | ReadableBuffer, header: bool = False) -> bytes: ...