layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pygram.pyi

@@ -0,0 +1,114 @@
+from .pgen2.grammar import Grammar
+
+class Symbols:
+    def __init__(self, grammar: Grammar) -> None: ...
+
+class python_symbols(Symbols):
+    and_expr: int
+    and_test: int
+    annassign: int
+    arglist: int
+    argument: int
+    arith_expr: int
+    assert_stmt: int
+    async_funcdef: int
+    async_stmt: int
+    atom: int
+    augassign: int
+    break_stmt: int
+    classdef: int
+    comp_for: int
+    comp_if: int
+    comp_iter: int
+    comp_op: int
+    comparison: int
+    compound_stmt: int
+    continue_stmt: int
+    decorated: int
+    decorator: int
+    decorators: int
+    del_stmt: int
+    dictsetmaker: int
+    dotted_as_name: int
+    dotted_as_names: int
+    dotted_name: int
+    encoding_decl: int
+    eval_input: int
+    except_clause: int
+    exec_stmt: int
+    expr: int
+    expr_stmt: int
+    exprlist: int
+    factor: int
+    file_input: int
+    flow_stmt: int
+    for_stmt: int
+    funcdef: int
+    global_stmt: int
+    if_stmt: int
+    import_as_name: int
+    import_as_names: int
+    import_from: int
+    import_name: int
+    import_stmt: int
+    lambdef: int
+    listmaker: int
+    not_test: int
+    old_lambdef: int
+    old_test: int
+    or_test: int
+    parameters: int
+    pass_stmt: int
+    power: int
+    print_stmt: int
+    raise_stmt: int
+    return_stmt: int
+    shift_expr: int
+    simple_stmt: int
+    single_input: int
+    sliceop: int
+    small_stmt: int
+    star_expr: int
+    stmt: int
+    subscript: int
+    subscriptlist: int
+    suite: int
+    term: int
+    test: int
+    testlist: int
+    testlist1: int
+    testlist_gexp: int
+    testlist_safe: int
+    testlist_star_expr: int
+    tfpdef: int
+    tfplist: int
+    tname: int
+    trailer: int
+    try_stmt: int
+    typedargslist: int
+    varargslist: int
+    vfpdef: int
+    vfplist: int
+    vname: int
+    while_stmt: int
+    with_item: int
+    with_stmt: int
+    with_var: int
+    xor_expr: int
+    yield_arg: int
+    yield_expr: int
+    yield_stmt: int
+
+class pattern_symbols(Symbols):
+    Alternative: int
+    Alternatives: int
+    Details: int
+    Matcher: int
+    NegatedUnit: int
+    Repeater: int
+    Unit: int
+
+python_grammar: Grammar
+python_grammar_no_print_statement: Grammar
+python_grammar_no_print_and_exec_statement: Grammar
+pattern_grammar: Grammar

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/pytree.pyi

@@ -0,0 +1,118 @@
+from _typeshed import Incomplete, SupportsGetItem, SupportsLenAndGetItem, Unused
+from abc import abstractmethod
+from collections.abc import Iterable, Iterator, MutableSequence
+from typing import ClassVar, Final, TypeAlias
+from typing_extensions import Self
+
+from .fixer_base import BaseFix
+from .pgen2.grammar import Grammar
+
+_NL: TypeAlias = Node | Leaf
+_Context: TypeAlias = tuple[str, int, int]
+_Results: TypeAlias = dict[str, _NL]
+_RawNode: TypeAlias = tuple[int, str, _Context, list[_NL] | None]
+
+HUGE: Final = 0x7FFFFFFF
+
+def type_repr(type_num: int) -> str | int: ...
+
+class Base:
+    type: int
+    parent: Node | None
+    prefix: str
+    children: list[_NL]
+    was_changed: bool
+    was_checked: bool
+    def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    @abstractmethod
+    def _eq(self, other: Base) -> bool: ...
+    @abstractmethod
+    def clone(self) -> Self: ...
+    @abstractmethod
+    def post_order(self) -> Iterator[Self]: ...
+    @abstractmethod
+    def pre_order(self) -> Iterator[Self]: ...
+    def replace(self, new: _NL | list[_NL]) -> None: ...
+    def get_lineno(self) -> int: ...
+    def changed(self) -> None: ...
+    def remove(self) -> int | None: ...
+    @property
+    def next_sibling(self) -> _NL | None: ...
+    @property
+    def prev_sibling(self) -> _NL | None: ...
+    def leaves(self) -> Iterator[Leaf]: ...
+    def depth(self) -> int: ...
+    def get_suffix(self) -> str: ...
+
+class Node(Base):
+    fixers_applied: MutableSequence[BaseFix] | None
+    # Is Unbound until set in refactor.RefactoringTool
+    future_features: frozenset[Incomplete]
+    # Is Unbound until set in pgen2.parse.Parser.pop
+    used_names: set[str]
+    def __init__(
+        self,
+        type: int,
+        children: Iterable[_NL],
+        context: Unused = None,
+        prefix: str | None = None,
+        fixers_applied: MutableSequence[BaseFix] | None = None,
+    ) -> None: ...
+    def _eq(self, other: Base) -> bool: ...
+    def clone(self) -> Node: ...
+    def post_order(self) -> Iterator[Self]: ...
+    def pre_order(self) -> Iterator[Self]: ...
+    def set_child(self, i: int, child: _NL) -> None: ...
+    def insert_child(self, i: int, child: _NL) -> None: ...
+    def append_child(self, child: _NL) -> None: ...
+    def __unicode__(self) -> str: ...
+
+class Leaf(Base):
+    lineno: int
+    column: int
+    value: str
+    fixers_applied: MutableSequence[BaseFix]
+    def __init__(
+        self,
+        type: int,
+        value: str,
+        context: _Context | None = None,
+        prefix: str | None = None,
+        fixers_applied: MutableSequence[BaseFix] = [],
+    ) -> None: ...
+    def _eq(self, other: Base) -> bool: ...
+    def clone(self) -> Leaf: ...
+    def post_order(self) -> Iterator[Self]: ...
+    def pre_order(self) -> Iterator[Self]: ...
+    def __unicode__(self) -> str: ...
+
+def convert(gr: Grammar, raw_node: _RawNode) -> _NL: ...
+
+class BasePattern:
+    type: int
+    content: str | None
+    name: str | None
+    def optimize(self) -> BasePattern: ...  # sic, subclasses are free to optimize themselves into different patterns
+    def match(self, node: _NL, results: _Results | None = None) -> bool: ...
+    def match_seq(self, nodes: SupportsLenAndGetItem[_NL], results: _Results | None = None) -> bool: ...
+    def generate_matches(self, nodes: SupportsGetItem[int, _NL]) -> Iterator[tuple[int, _Results]]: ...
+
+class LeafPattern(BasePattern):
+    def __init__(self, type: int | None = None, content: str | None = None, name: str | None = None) -> None: ...
+
+class NodePattern(BasePattern):
+    wildcards: bool
+    def __init__(self, type: int | None = None, content: str | None = None, name: str | None = None) -> None: ...
+
+class WildcardPattern(BasePattern):
+    min: int
+    max: int
+    def __init__(self, content: str | None = None, min: int = 0, max: int = 0x7FFFFFFF, name: str | None = None) -> None: ...
+
+class NegatedPattern(BasePattern):
+    def __init__(self, content: str | None = None) -> None: ...
+
+def generate_matches(
+    patterns: SupportsGetItem[int | slice, BasePattern] | None, nodes: SupportsGetItem[int | slice, _NL]
+) -> Iterator[tuple[int, _Results]]: ...

package/analyzers/project-map-python/typeshed/stdlib/lib2to3/refactor.pyi

@@ -0,0 +1,85 @@
+from _typeshed import FileDescriptorOrPath, StrPath, SupportsGetItem
+from collections.abc import Container, Generator, Iterable, Mapping
+from logging import Logger, _ExcInfoType
+from multiprocessing import JoinableQueue
+from multiprocessing.synchronize import Lock
+from typing import Any, ClassVar, Final, NoReturn, overload
+
+from .btm_matcher import BottomMatcher
+from .fixer_base import BaseFix
+from .pgen2.driver import Driver
+from .pgen2.grammar import Grammar
+from .pytree import Node
+
+def get_all_fix_names(fixer_pkg: str, remove_prefix: bool = True) -> list[str]: ...
+def get_fixers_from_package(pkg_name: str) -> list[str]: ...
+
+class FixerError(Exception): ...
+
+class RefactoringTool:
+    CLASS_PREFIX: ClassVar[str]
+    FILE_PREFIX: ClassVar[str]
+    fixers: Iterable[str]
+    explicit: Container[str]
+    options: dict[str, Any]
+    grammar: Grammar
+    write_unchanged_files: bool
+    errors: list[tuple[str, Iterable[str], dict[str, _ExcInfoType]]]
+    logger: Logger
+    fixer_log: list[str]
+    wrote: bool
+    driver: Driver
+    pre_order: list[BaseFix]
+    post_order: list[BaseFix]
+    files: list[StrPath]
+    BM: BottomMatcher
+    bmi_pre_order: list[BaseFix]
+    bmi_post_order: list[BaseFix]
+    def __init__(
+        self, fixer_names: Iterable[str], options: Mapping[str, object] | None = None, explicit: Container[str] | None = None
+    ) -> None: ...
+    def get_fixers(self) -> tuple[list[BaseFix], list[BaseFix]]: ...
+    def log_error(self, msg: str, *args: Iterable[str], **kwargs: _ExcInfoType) -> NoReturn: ...
+
+    @overload
+    def log_message(self, msg: object) -> None: ...
+    @overload
+    def log_message(self, msg: str, *args: object) -> None: ...
+
+    @overload
+    def log_debug(self, msg: object) -> None: ...
+    @overload
+    def log_debug(self, msg: str, *args: object) -> None: ...
+
+    def print_output(self, old_text: str, new_text: str, filename: StrPath, equal: bool) -> None: ...
+    def refactor(self, items: Iterable[str], write: bool = False, doctests_only: bool = False) -> None: ...
+    def refactor_dir(self, dir_name: str, write: bool = False, doctests_only: bool = False) -> None: ...
+    def _read_python_source(self, filename: FileDescriptorOrPath) -> tuple[str, str]: ...
+    def refactor_file(self, filename: StrPath, write: bool = False, doctests_only: bool = False) -> None: ...
+    def refactor_string(self, data: str, name: str) -> Node | None: ...
+    def refactor_stdin(self, doctests_only: bool = False) -> None: ...
+    def refactor_tree(self, tree: Node, name: str) -> bool: ...
+    def traverse_by(self, fixers: SupportsGetItem[int, Iterable[BaseFix]] | None, traversal: Iterable[Node]) -> None: ...
+    def processed_file(
+        self, new_text: str, filename: StrPath, old_text: str | None = None, write: bool = False, encoding: str | None = None
+    ) -> None: ...
+    def write_file(self, new_text: str, filename: FileDescriptorOrPath, old_text: str, encoding: str | None = None) -> None: ...
+    PS1: Final = ">>> "
+    PS2: Final = "... "
+    def refactor_docstring(self, input: str, filename: StrPath) -> str: ...
+    def refactor_doctest(self, block: list[str], lineno: int, indent: int, filename: StrPath) -> list[str]: ...
+    def summarize(self) -> None: ...
+    def parse_block(self, block: Iterable[str], lineno: int, indent: int) -> Node: ...
+    def wrap_toks(
+        self, block: Iterable[str], lineno: int, indent: int
+    ) -> Generator[tuple[int, str, tuple[int, int], tuple[int, int], str]]: ...
+    def gen_lines(self, block: Iterable[str], indent: int) -> Generator[str]: ...
+
+class MultiprocessingUnsupported(Exception): ...
+
+class MultiprocessRefactoringTool(RefactoringTool):
+    queue: JoinableQueue[None | tuple[Iterable[str], bool | int]] | None
+    output_lock: Lock | None
+    def refactor(
+        self, items: Iterable[str], write: bool = False, doctests_only: bool = False, num_processes: int = 1
+    ) -> None: ...

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

@@ -0,0 +1,18 @@
+from collections.abc import Callable
+from typing import Any, TypeAlias
+
+__all__ = ["getline", "clearcache", "checkcache", "lazycache"]
+
+_ModuleGlobals: TypeAlias = dict[str, Any]
+_ModuleMetadata: TypeAlias = tuple[int, float | None, list[str], str]
+
+_SourceLoader: TypeAlias = tuple[Callable[[], str | None]]
+
+cache: dict[str, _SourceLoader | _ModuleMetadata]  # undocumented
+
+def getline(filename: str, lineno: int, module_globals: _ModuleGlobals | None = None) -> str: ...
+def clearcache() -> None: ...
+def getlines(filename: str, module_globals: _ModuleGlobals | None = None) -> list[str]: ...
+def checkcache(filename: str | None = None) -> None: ...
+def updatecache(filename: str, module_globals: _ModuleGlobals | None = None) -> list[str]: ...
+def lazycache(filename: str, module_globals: _ModuleGlobals) -> bool: ...

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

@@ -0,0 +1,160 @@
+import sys
+from _locale import (
+    CHAR_MAX as CHAR_MAX,
+    LC_ALL as LC_ALL,
+    LC_COLLATE as LC_COLLATE,
+    LC_CTYPE as LC_CTYPE,
+    LC_MONETARY as LC_MONETARY,
+    LC_NUMERIC as LC_NUMERIC,
+    LC_TIME as LC_TIME,
+    localeconv as localeconv,
+    strcoll as strcoll,
+    strxfrm as strxfrm,
+)
+
+# This module defines a function "str()", which is why "str" can't be used
+# as a type annotation or type alias.
+from builtins import str as _str
+from collections.abc import Callable, Iterable
+from decimal import Decimal
+from typing import Any
+from typing_extensions import deprecated
+
+if sys.version_info >= (3, 11):
+    from _locale import getencoding as getencoding
+
+# Some parts of the `_locale` module are platform-specific:
+if sys.platform != "win32":
+    from _locale import (
+        ABDAY_1 as ABDAY_1,
+        ABDAY_2 as ABDAY_2,
+        ABDAY_3 as ABDAY_3,
+        ABDAY_4 as ABDAY_4,
+        ABDAY_5 as ABDAY_5,
+        ABDAY_6 as ABDAY_6,
+        ABDAY_7 as ABDAY_7,
+        ABMON_1 as ABMON_1,
+        ABMON_2 as ABMON_2,
+        ABMON_3 as ABMON_3,
+        ABMON_4 as ABMON_4,
+        ABMON_5 as ABMON_5,
+        ABMON_6 as ABMON_6,
+        ABMON_7 as ABMON_7,
+        ABMON_8 as ABMON_8,
+        ABMON_9 as ABMON_9,
+        ABMON_10 as ABMON_10,
+        ABMON_11 as ABMON_11,
+        ABMON_12 as ABMON_12,
+        ALT_DIGITS as ALT_DIGITS,
+        AM_STR as AM_STR,
+        CODESET as CODESET,
+        CRNCYSTR as CRNCYSTR,
+        D_FMT as D_FMT,
+        D_T_FMT as D_T_FMT,
+        DAY_1 as DAY_1,
+        DAY_2 as DAY_2,
+        DAY_3 as DAY_3,
+        DAY_4 as DAY_4,
+        DAY_5 as DAY_5,
+        DAY_6 as DAY_6,
+        DAY_7 as DAY_7,
+        ERA as ERA,
+        ERA_D_FMT as ERA_D_FMT,
+        ERA_D_T_FMT as ERA_D_T_FMT,
+        ERA_T_FMT as ERA_T_FMT,
+        LC_MESSAGES as LC_MESSAGES,
+        MON_1 as MON_1,
+        MON_2 as MON_2,
+        MON_3 as MON_3,
+        MON_4 as MON_4,
+        MON_5 as MON_5,
+        MON_6 as MON_6,
+        MON_7 as MON_7,
+        MON_8 as MON_8,
+        MON_9 as MON_9,
+        MON_10 as MON_10,
+        MON_11 as MON_11,
+        MON_12 as MON_12,
+        NOEXPR as NOEXPR,
+        PM_STR as PM_STR,
+        RADIXCHAR as RADIXCHAR,
+        T_FMT as T_FMT,
+        T_FMT_AMPM as T_FMT_AMPM,
+        THOUSEP as THOUSEP,
+        YESEXPR as YESEXPR,
+        bind_textdomain_codeset as bind_textdomain_codeset,
+        bindtextdomain as bindtextdomain,
+        dcgettext as dcgettext,
+        dgettext as dgettext,
+        gettext as gettext,
+        nl_langinfo as nl_langinfo,
+        textdomain as textdomain,
+    )
+
+__all__ = [
+    "getlocale",
+    "getdefaultlocale",
+    "getpreferredencoding",
+    "Error",
+    "setlocale",
+    "localeconv",
+    "strcoll",
+    "strxfrm",
+    "str",
+    "atof",
+    "atoi",
+    "format_string",
+    "currency",
+    "normalize",
+    "LC_CTYPE",
+    "LC_COLLATE",
+    "LC_TIME",
+    "LC_MONETARY",
+    "LC_NUMERIC",
+    "LC_ALL",
+    "CHAR_MAX",
+]
+
+if sys.version_info >= (3, 11):
+    __all__ += ["getencoding"]
+
+if sys.version_info < (3, 12):
+    __all__ += ["format"]
+
+if sys.version_info < (3, 13):
+    __all__ += ["resetlocale"]
+
+if sys.platform != "win32":
+    __all__ += ["LC_MESSAGES"]
+
+class Error(Exception): ...
+
+def getdefaultlocale(
+    envvars: tuple[_str, ...] = ("LC_ALL", "LC_CTYPE", "LANG", "LANGUAGE")
+) -> tuple[_str | None, _str | None]: ...
+def getlocale(category: int = ...) -> tuple[_str | None, _str | None]: ...
+def setlocale(category: int, locale: _str | Iterable[_str | None] | None = None) -> _str: ...
+def getpreferredencoding(do_setlocale: bool = True) -> _str: ...
+def normalize(localename: _str) -> _str: ...
+
+if sys.version_info < (3, 13):
+    @deprecated("Deprecated since Python 3.11; removed in Python 3.13. Use `locale.setlocale(locale.LC_ALL, '')` instead.")
+    def resetlocale(category: int = ...) -> None: ...
+
+if sys.version_info < (3, 12):
+    @deprecated("Deprecated since Python 3.7; removed in Python 3.12. Use `locale.format_string()` instead.")
+    def format(
+        percent: _str, value: float | Decimal, grouping: bool = False, monetary: bool = False, *additional: Any
+    ) -> _str: ...
+
+def format_string(f: _str, val: Any, grouping: bool = False, monetary: bool = False) -> _str: ...
+def currency(val: float | Decimal, symbol: bool = True, grouping: bool = False, international: bool = False) -> _str: ...
+def delocalize(string: _str) -> _str: ...
+def localize(string: _str, grouping: bool = False, monetary: bool = False) -> _str: ...
+def atof(string: _str, func: Callable[[_str], float] = ...) -> float: ...
+def atoi(string: _str) -> int: ...
+def str(val: float) -> _str: ...
+
+locale_alias: dict[_str, _str]  # undocumented
+locale_encoding_alias: dict[_str, _str]  # undocumented
+windows_locale: dict[int, _str]  # undocumented