jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

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

@@ -1,50 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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