jaclang 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/pgen2/pgen.pyi

@@ -0,0 +1,50 @@
+from _typeshed import Incomplete, StrPath
+from collections.abc import Iterable, Iterator
+from typing import IO, NoReturn, overload
+
+from . import grammar
+from .tokenize import _TokenInfo
+
+class PgenGrammar(grammar.Grammar): ...
+
+class ParserGenerator:
+    filename: StrPath
+    stream: IO[str]
+    generator: Iterator[_TokenInfo]
+    first: dict[str, dict[str, int]]
+    def __init__(self, filename: StrPath, stream: IO[str] | None = None) -> None: ...
+    def make_grammar(self) -> PgenGrammar: ...
+    def make_first(self, c: PgenGrammar, name: str) -> dict[int, int]: ...
+    def make_label(self, c: PgenGrammar, label: str) -> int: ...
+    def addfirstsets(self) -> None: ...
+    def calcfirst(self, name: str) -> None: ...
+    def parse(self) -> tuple[dict[str, list[DFAState]], str]: ...
+    def make_dfa(self, start: NFAState, finish: NFAState) -> list[DFAState]: ...
+    def dump_nfa(self, name: str, start: NFAState, finish: NFAState) -> list[DFAState]: ...
+    def dump_dfa(self, name: str, dfa: Iterable[DFAState]) -> None: ...
+    def simplify_dfa(self, dfa: list[DFAState]) -> None: ...
+    def parse_rhs(self) -> tuple[NFAState, NFAState]: ...
+    def parse_alt(self) -> tuple[NFAState, NFAState]: ...
+    def parse_item(self) -> tuple[NFAState, NFAState]: ...
+    def parse_atom(self) -> tuple[NFAState, NFAState]: ...
+    def expect(self, type: int, value: str | None = None) -> str: ...
+    def gettoken(self) -> None: ...
+    @overload
+    def raise_error(self, msg: object) -> NoReturn: ...
+    @overload
+    def raise_error(self, msg: str, *args: object) -> NoReturn: ...
+
+class NFAState:
+    arcs: list[tuple[str | None, NFAState]]
+    def addarc(self, next: NFAState, label: str | None = None) -> None: ...
+
+class DFAState:
+    nfaset: dict[NFAState, Incomplete]
+    isfinal: bool
+    arcs: dict[str, DFAState]
+    def __init__(self, nfaset: dict[NFAState, Incomplete], final: NFAState) -> None: ...
+    def addarc(self, next: DFAState, label: str) -> None: ...
+    def unifystate(self, old: DFAState, new: DFAState) -> None: ...
+    def __eq__(self, other: DFAState) -> bool: ...  # type: ignore[override]
+
+def generate_grammar(filename: StrPath = "Grammar.txt") -> PgenGrammar: ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/pgen2/token.pyi

@@ -0,0 +1,67 @@
+ENDMARKER: int
+NAME: int
+NUMBER: int
+STRING: int
+NEWLINE: int
+INDENT: int
+DEDENT: int
+LPAR: int
+RPAR: int
+LSQB: int
+RSQB: int
+COLON: int
+COMMA: int
+SEMI: int
+PLUS: int
+MINUS: int
+STAR: int
+SLASH: int
+VBAR: int
+AMPER: int
+LESS: int
+GREATER: int
+EQUAL: int
+DOT: int
+PERCENT: int
+BACKQUOTE: int
+LBRACE: int
+RBRACE: int
+EQEQUAL: int
+NOTEQUAL: int
+LESSEQUAL: int
+GREATEREQUAL: int
+TILDE: int
+CIRCUMFLEX: int
+LEFTSHIFT: int
+RIGHTSHIFT: int
+DOUBLESTAR: int
+PLUSEQUAL: int
+MINEQUAL: int
+STAREQUAL: int
+SLASHEQUAL: int
+PERCENTEQUAL: int
+AMPEREQUAL: int
+VBAREQUAL: int
+CIRCUMFLEXEQUAL: int
+LEFTSHIFTEQUAL: int
+RIGHTSHIFTEQUAL: int
+DOUBLESTAREQUAL: int
+DOUBLESLASH: int
+DOUBLESLASHEQUAL: int
+OP: int
+COMMENT: int
+NL: int
+RARROW: int
+AT: int
+ATEQUAL: int
+AWAIT: int
+ASYNC: int
+ERRORTOKEN: int
+COLONEQUAL: int
+N_TOKENS: int
+NT_OFFSET: int
+tok_name: dict[int, str]
+
+def ISTERMINAL(x: int) -> bool: ...
+def ISNONTERMINAL(x: int) -> bool: ...
+def ISEOF(x: int) -> bool: ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/pgen2/tokenize.pyi

@@ -0,0 +1,96 @@
+from collections.abc import Callable, Iterable, Iterator
+from typing_extensions import TypeAlias
+
+from .token import *
+
+__all__ = [
+    "AMPER",
+    "AMPEREQUAL",
+    "ASYNC",
+    "AT",
+    "ATEQUAL",
+    "AWAIT",
+    "BACKQUOTE",
+    "CIRCUMFLEX",
+    "CIRCUMFLEXEQUAL",
+    "COLON",
+    "COMMA",
+    "COMMENT",
+    "DEDENT",
+    "DOT",
+    "DOUBLESLASH",
+    "DOUBLESLASHEQUAL",
+    "DOUBLESTAR",
+    "DOUBLESTAREQUAL",
+    "ENDMARKER",
+    "EQEQUAL",
+    "EQUAL",
+    "ERRORTOKEN",
+    "GREATER",
+    "GREATEREQUAL",
+    "INDENT",
+    "ISEOF",
+    "ISNONTERMINAL",
+    "ISTERMINAL",
+    "LBRACE",
+    "LEFTSHIFT",
+    "LEFTSHIFTEQUAL",
+    "LESS",
+    "LESSEQUAL",
+    "LPAR",
+    "LSQB",
+    "MINEQUAL",
+    "MINUS",
+    "NAME",
+    "NEWLINE",
+    "NL",
+    "NOTEQUAL",
+    "NT_OFFSET",
+    "NUMBER",
+    "N_TOKENS",
+    "OP",
+    "PERCENT",
+    "PERCENTEQUAL",
+    "PLUS",
+    "PLUSEQUAL",
+    "RARROW",
+    "RBRACE",
+    "RIGHTSHIFT",
+    "RIGHTSHIFTEQUAL",
+    "RPAR",
+    "RSQB",
+    "SEMI",
+    "SLASH",
+    "SLASHEQUAL",
+    "STAR",
+    "STAREQUAL",
+    "STRING",
+    "TILDE",
+    "VBAR",
+    "VBAREQUAL",
+    "tok_name",
+    "tokenize",
+    "generate_tokens",
+    "untokenize",
+    "COLONEQUAL",
+]
+
+_Coord: TypeAlias = tuple[int, int]
+_TokenEater: TypeAlias = Callable[[int, str, _Coord, _Coord, str], object]
+_TokenInfo: TypeAlias = tuple[int, str, _Coord, _Coord, str]
+
+class TokenError(Exception): ...
+class StopTokenizing(Exception): ...
+
+def tokenize(readline: Callable[[], str], tokeneater: _TokenEater = ...) -> None: ...
+
+class Untokenizer:
+    tokens: list[str]
+    prev_row: int
+    prev_col: int
+    def add_whitespace(self, start: _Coord) -> None: ...
+    def untokenize(self, iterable: Iterable[_TokenInfo]) -> str: ...
+    def compat(self, token: tuple[int, str], iterable: Iterable[_TokenInfo]) -> None: ...
+
+def untokenize(iterable: Iterable[_TokenInfo]) -> str: ...
+def generate_tokens(readline: Callable[[], str]) -> Iterator[_TokenInfo]: ...

jaclang/vendor/mypy/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

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/pytree.pyi

@@ -0,0 +1,117 @@
+from _typeshed import Incomplete, SupportsGetItem, SupportsLenAndGetItem, Unused
+from abc import abstractmethod
+from collections.abc import Iterable, Iterator, MutableSequence
+from typing import Final
+from typing_extensions import Self, TypeAlias
+
+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: ...
+    @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]]: ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/refactor.pyi

@@ -0,0 +1,82 @@
+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], None, None]: ...
+    def gen_lines(self, block: Iterable[str], indent: int) -> Generator[str, None, None]: ...
+
+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: ...

jaclang/vendor/mypy/typeshed/stdlib/linecache.pyi

@@ -0,0 +1,23 @@
+import sys
+from collections.abc import Callable
+from typing import Any
+from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 9):
+    __all__ = ["getline", "clearcache", "checkcache", "lazycache"]
+else:
+    __all__ = ["getline", "clearcache", "checkcache"]
+
+_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: ...

jaclang/vendor/mypy/typeshed/stdlib/locale.pyi

@@ -0,0 +1,152 @@
+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
+
+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",
+    "resetlocale",
+    "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.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: ...
+def resetlocale(category: int = ...) -> None: ...
+
+if sys.version_info < (3, 12):
+    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 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