layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/distutils/util.pyi

@@ -0,0 +1,53 @@
+from _typeshed import StrPath, Unused
+from collections.abc import Callable, Container, Iterable, Mapping
+from typing import Any, Literal
+from typing_extensions import TypeVarTuple, Unpack
+
+_Ts = TypeVarTuple("_Ts")
+
+def get_host_platform() -> str: ...
+def get_platform() -> str: ...
+def convert_path(pathname: str) -> str: ...
+def change_root(new_root: StrPath, pathname: StrPath) -> str: ...
+def check_environ() -> None: ...
+def subst_vars(s: str, local_vars: Mapping[str, str]) -> None: ...
+def split_quoted(s: str) -> list[str]: ...
+def execute(
+    func: Callable[[Unpack[_Ts]], Unused],
+    args: tuple[Unpack[_Ts]],
+    msg: str | None = None,
+    verbose: bool | Literal[0, 1] = 0,
+    dry_run: bool | Literal[0, 1] = 0,
+) -> None: ...
+def strtobool(val: str) -> Literal[0, 1]: ...
+def byte_compile(
+    py_files: list[str],
+    optimize: int = 0,
+    force: bool | Literal[0, 1] = 0,
+    prefix: str | None = None,
+    base_dir: str | None = None,
+    verbose: bool | Literal[0, 1] = 1,
+    dry_run: bool | Literal[0, 1] = 0,
+    direct: bool | None = None,
+) -> None: ...
+def rfc822_escape(header: str) -> str: ...
+def run_2to3(
+    files: Iterable[str],
+    fixer_names: Iterable[str] | None = None,
+    options: Mapping[str, Any] | None = None,
+    explicit: Unused = None,
+) -> None: ...
+def copydir_run_2to3(
+    src: StrPath,
+    dest: StrPath,
+    template: str | None = None,
+    fixer_names: Iterable[str] | None = None,
+    options: Mapping[str, Any] | None = None,
+    explicit: Container[str] | None = None,
+) -> list[str]: ...
+
+class Mixin2to3:
+    fixer_names: Iterable[str] | None
+    options: Mapping[str, Any] | None
+    explicit: Container[str] | None
+    def run_2to3(self, files: Iterable[str]) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/distutils/version.pyi

@@ -0,0 +1,36 @@
+from abc import abstractmethod
+from re import Pattern
+from typing_extensions import Self
+
+class Version:
+    def __eq__(self, other: object) -> bool: ...
+    def __lt__(self, other: Self | str) -> bool: ...
+    def __le__(self, other: Self | str) -> bool: ...
+    def __gt__(self, other: Self | str) -> bool: ...
+    def __ge__(self, other: Self | str) -> bool: ...
+    @abstractmethod
+    def __init__(self, vstring: str | None = None) -> None: ...
+    @abstractmethod
+    def parse(self, vstring: str) -> Self: ...
+    @abstractmethod
+    def __str__(self) -> str: ...
+    @abstractmethod
+    def _cmp(self, other: Self | str) -> bool: ...
+
+class StrictVersion(Version):
+    version_re: Pattern[str]
+    version: tuple[int, int, int]
+    prerelease: tuple[str, int] | None
+    def __init__(self, vstring: str | None = None) -> None: ...
+    def parse(self, vstring: str) -> Self: ...
+    def __str__(self) -> str: ...  # noqa: Y029
+    def _cmp(self, other: Self | str) -> bool: ...
+
+class LooseVersion(Version):
+    component_re: Pattern[str]
+    vstring: str
+    version: tuple[str | int, ...]
+    def __init__(self, vstring: str | None = None) -> None: ...
+    def parse(self, vstring: str) -> Self: ...
+    def __str__(self) -> str: ...  # noqa: Y029
+    def _cmp(self, other: Self | str) -> bool: ...

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

@@ -0,0 +1,262 @@
+import sys
+import types
+import unittest
+from _typeshed import ExcInfo
+from collections.abc import Callable
+from typing import Any, Final, NamedTuple, TypeAlias, type_check_only
+from typing_extensions import Self
+
+__all__ = [
+    "register_optionflag",
+    "DONT_ACCEPT_TRUE_FOR_1",
+    "DONT_ACCEPT_BLANKLINE",
+    "NORMALIZE_WHITESPACE",
+    "ELLIPSIS",
+    "SKIP",
+    "IGNORE_EXCEPTION_DETAIL",
+    "COMPARISON_FLAGS",
+    "REPORT_UDIFF",
+    "REPORT_CDIFF",
+    "REPORT_NDIFF",
+    "REPORT_ONLY_FIRST_FAILURE",
+    "REPORTING_FLAGS",
+    "FAIL_FAST",
+    "Example",
+    "DocTest",
+    "DocTestParser",
+    "DocTestFinder",
+    "DocTestRunner",
+    "OutputChecker",
+    "DocTestFailure",
+    "UnexpectedException",
+    "DebugRunner",
+    "testmod",
+    "testfile",
+    "run_docstring_examples",
+    "DocTestSuite",
+    "DocFileSuite",
+    "set_unittest_reportflags",
+    "script_from_examples",
+    "testsource",
+    "debug_src",
+    "debug",
+]
+
+if sys.version_info >= (3, 13):
+    @type_check_only
+    class _TestResultsBase(NamedTuple):
+        failed: int
+        attempted: int
+
+    class TestResults(_TestResultsBase):
+        def __new__(cls, failed: int, attempted: int, *, skipped: int = 0) -> Self: ...
+        skipped: int
+
+else:
+    class TestResults(NamedTuple):
+        failed: int
+        attempted: int
+
+OPTIONFLAGS_BY_NAME: Final[dict[str, int]]
+
+def register_optionflag(name: str) -> int: ...
+
+DONT_ACCEPT_TRUE_FOR_1: Final = 1
+DONT_ACCEPT_BLANKLINE: Final = 2
+NORMALIZE_WHITESPACE: Final = 4
+ELLIPSIS: Final = 8
+SKIP: Final = 16
+IGNORE_EXCEPTION_DETAIL: Final = 32
+
+COMPARISON_FLAGS: Final = 63
+
+REPORT_UDIFF: Final = 64
+REPORT_CDIFF: Final = 128
+REPORT_NDIFF: Final = 256
+REPORT_ONLY_FIRST_FAILURE: Final = 512
+FAIL_FAST: Final = 1024
+
+REPORTING_FLAGS: Final = 1984
+
+BLANKLINE_MARKER: Final = "<BLANKLINE>"
+ELLIPSIS_MARKER: Final = "..."
+
+class Example:
+    source: str
+    want: str
+    exc_msg: str | None
+    lineno: int
+    indent: int
+    options: dict[int, bool]
+    def __init__(
+        self,
+        source: str,
+        want: str,
+        exc_msg: str | None = None,
+        lineno: int = 0,
+        indent: int = 0,
+        options: dict[int, bool] | None = None,
+    ) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+
+class DocTest:
+    examples: list[Example]
+    globs: dict[str, Any]
+    name: str
+    filename: str | None
+    lineno: int | None
+    docstring: str | None
+    def __init__(
+        self,
+        examples: list[Example],
+        globs: dict[str, Any],
+        name: str,
+        filename: str | None,
+        lineno: int | None,
+        docstring: str | None,
+    ) -> None: ...
+    def __hash__(self) -> int: ...
+    def __lt__(self, other: DocTest) -> bool: ...
+    def __eq__(self, other: object) -> bool: ...
+
+class DocTestParser:
+    def parse(self, string: str, name: str = "<string>") -> list[str | Example]: ...
+    def get_doctest(self, string: str, globs: dict[str, Any], name: str, filename: str | None, lineno: int | None) -> DocTest: ...
+    def get_examples(self, string: str, name: str = "<string>") -> list[Example]: ...
+
+class DocTestFinder:
+    def __init__(
+        self, verbose: bool = False, parser: DocTestParser = ..., recurse: bool = True, exclude_empty: bool = True
+    ) -> None: ...
+    def find(
+        self,
+        obj: object,
+        name: str | None = None,
+        module: None | bool | types.ModuleType = None,
+        globs: dict[str, Any] | None = None,
+        extraglobs: dict[str, Any] | None = None,
+    ) -> list[DocTest]: ...
+
+_Out: TypeAlias = Callable[[str], object]
+
+class DocTestRunner:
+    DIVIDER: str
+    optionflags: int
+    original_optionflags: int
+    tries: int
+    failures: int
+    if sys.version_info >= (3, 13):
+        skips: int
+    test: DocTest
+    def __init__(self, checker: OutputChecker | None = None, verbose: bool | None = None, optionflags: int = 0) -> None: ...
+    def report_start(self, out: _Out, test: DocTest, example: Example) -> None: ...
+    def report_success(self, out: _Out, test: DocTest, example: Example, got: str) -> None: ...
+    def report_failure(self, out: _Out, test: DocTest, example: Example, got: str) -> None: ...
+    def report_unexpected_exception(self, out: _Out, test: DocTest, example: Example, exc_info: ExcInfo) -> None: ...
+    def run(
+        self, test: DocTest, compileflags: int | None = None, out: _Out | None = None, clear_globs: bool = True
+    ) -> TestResults: ...
+    def summarize(self, verbose: bool | None = None) -> TestResults: ...
+    def merge(self, other: DocTestRunner) -> None: ...
+
+class OutputChecker:
+    def check_output(self, want: str, got: str, optionflags: int) -> bool: ...
+    def output_difference(self, example: Example, got: str, optionflags: int) -> str: ...
+
+class DocTestFailure(Exception):
+    test: DocTest
+    example: Example
+    got: str
+    def __init__(self, test: DocTest, example: Example, got: str) -> None: ...
+
+class UnexpectedException(Exception):
+    test: DocTest
+    example: Example
+    exc_info: ExcInfo
+    def __init__(self, test: DocTest, example: Example, exc_info: ExcInfo) -> None: ...
+
+class DebugRunner(DocTestRunner): ...
+
+master: DocTestRunner | None
+
+def testmod(
+    m: types.ModuleType | None = None,
+    name: str | None = None,
+    globs: dict[str, Any] | None = None,
+    verbose: bool | None = None,
+    report: bool = True,
+    optionflags: int = 0,
+    extraglobs: dict[str, Any] | None = None,
+    raise_on_error: bool = False,
+    exclude_empty: bool = False,
+) -> TestResults: ...
+def testfile(
+    filename: str,
+    module_relative: bool = True,
+    name: str | None = None,
+    package: None | str | types.ModuleType = None,
+    globs: dict[str, Any] | None = None,
+    verbose: bool | None = None,
+    report: bool = True,
+    optionflags: int = 0,
+    extraglobs: dict[str, Any] | None = None,
+    raise_on_error: bool = False,
+    parser: DocTestParser = ...,
+    encoding: str | None = None,
+) -> TestResults: ...
+def run_docstring_examples(
+    f: object,
+    globs: dict[str, Any],
+    verbose: bool = False,
+    name: str = "NoName",
+    compileflags: int | None = None,
+    optionflags: int = 0,
+) -> None: ...
+def set_unittest_reportflags(flags: int) -> int: ...
+
+class DocTestCase(unittest.TestCase):
+    def __init__(
+        self,
+        test: DocTest,
+        optionflags: int = 0,
+        setUp: Callable[[DocTest], object] | None = None,
+        tearDown: Callable[[DocTest], object] | None = None,
+        checker: OutputChecker | None = None,
+    ) -> None: ...
+    def runTest(self) -> None: ...
+    def format_failure(self, err: str) -> str: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+
+class SkipDocTestCase(DocTestCase):
+    def __init__(self, module: types.ModuleType) -> None: ...
+    def test_skip(self) -> None: ...
+
+class _DocTestSuite(unittest.TestSuite): ...
+
+def DocTestSuite(
+    module: None | str | types.ModuleType = None,
+    globs: dict[str, Any] | None = None,
+    extraglobs: dict[str, Any] | None = None,
+    test_finder: DocTestFinder | None = None,
+    **options: Any,
+) -> _DocTestSuite: ...
+
+class DocFileCase(DocTestCase): ...
+
+def DocFileTest(
+    path: str,
+    module_relative: bool = True,
+    package: None | str | types.ModuleType = None,
+    globs: dict[str, Any] | None = None,
+    parser: DocTestParser = ...,
+    encoding: str | None = None,
+    **options: Any,
+) -> DocFileCase: ...
+def DocFileSuite(*paths: str, **kw: Any) -> _DocTestSuite: ...
+def script_from_examples(s: str) -> str: ...
+def testsource(module: None | str | types.ModuleType, name: str) -> str: ...
+def debug_src(src: str, pm: bool = False, globs: dict[str, Any] | None = None) -> None: ...
+def debug_script(src: str, pm: bool = False, globs: dict[str, Any] | None = None) -> None: ...
+def debug(module: None | str | types.ModuleType, name: str, pm: bool = False) -> None: ...

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

@@ -0,0 +1,62 @@
+from collections.abc import Callable
+from email._policybase import _MessageT
+from email.message import Message
+from email.policy import Policy
+from typing import IO, TypeAlias, overload
+
+# At runtime, listing submodules in __all__ without them being imported is
+# valid, and causes them to be included in a star import. See #6523
+
+__all__ = [  # noqa: F822  # Undefined names in __all__
+    "base64mime",  # pyright: ignore[reportUnsupportedDunderAll]
+    "charset",  # pyright: ignore[reportUnsupportedDunderAll]
+    "encoders",  # pyright: ignore[reportUnsupportedDunderAll]
+    "errors",  # pyright: ignore[reportUnsupportedDunderAll]
+    "feedparser",  # pyright: ignore[reportUnsupportedDunderAll]
+    "generator",  # pyright: ignore[reportUnsupportedDunderAll]
+    "header",  # pyright: ignore[reportUnsupportedDunderAll]
+    "iterators",  # pyright: ignore[reportUnsupportedDunderAll]
+    "message",  # pyright: ignore[reportUnsupportedDunderAll]
+    "message_from_file",
+    "message_from_binary_file",
+    "message_from_string",
+    "message_from_bytes",
+    "mime",  # pyright: ignore[reportUnsupportedDunderAll]
+    "parser",  # pyright: ignore[reportUnsupportedDunderAll]
+    "quoprimime",  # pyright: ignore[reportUnsupportedDunderAll]
+    "utils",  # pyright: ignore[reportUnsupportedDunderAll]
+]
+
+# Definitions imported by multiple submodules in typeshed
+_ParamType: TypeAlias = str | tuple[str | None, str | None, str]  # noqa: Y047
+_ParamsType: TypeAlias = str | None | tuple[str, str | None, str]  # noqa: Y047
+
+@overload
+def message_from_string(s: str) -> Message: ...
+@overload
+def message_from_string(s: str, _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def message_from_string(s: str, _class: Callable[[], _MessageT] = ..., *, policy: Policy[_MessageT]) -> _MessageT: ...
+
+@overload
+def message_from_bytes(s: bytes | bytearray) -> Message: ...
+@overload
+def message_from_bytes(s: bytes | bytearray, _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def message_from_bytes(
+    s: bytes | bytearray, _class: Callable[[], _MessageT] = ..., *, policy: Policy[_MessageT]
+) -> _MessageT: ...
+
+@overload
+def message_from_file(fp: IO[str]) -> Message: ...
+@overload
+def message_from_file(fp: IO[str], _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def message_from_file(fp: IO[str], _class: Callable[[], _MessageT] = ..., *, policy: Policy[_MessageT]) -> _MessageT: ...
+
+@overload
+def message_from_binary_file(fp: IO[bytes]) -> Message: ...
+@overload
+def message_from_binary_file(fp: IO[bytes], _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def message_from_binary_file(fp: IO[bytes], _class: Callable[[], _MessageT] = ..., *, policy: Policy[_MessageT]) -> _MessageT: ...