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

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

@@ -1,273 +0,0 @@
-import sys
-from collections.abc import Callable, Iterable, Iterator
-from typing import Any, Generic, Literal, SupportsComplex, SupportsFloat, SupportsIndex, SupportsInt, TypeVar, overload
-from typing_extensions import Self, TypeAlias
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-_T = TypeVar("_T")
-_S = TypeVar("_S")
-_N = TypeVar("_N", int, float, SupportsFloat, SupportsInt, SupportsIndex, SupportsComplex)
-_T_co = TypeVar("_T_co", covariant=True)
-_S_co = TypeVar("_S_co", covariant=True)
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
-_T3 = TypeVar("_T3")
-_T4 = TypeVar("_T4")
-_T5 = TypeVar("_T5")
-_T6 = TypeVar("_T6")
-
-_Step: TypeAlias = SupportsFloat | SupportsInt | SupportsIndex | SupportsComplex
-
-_Predicate: TypeAlias = Callable[[_T], object]
-
-# Technically count can take anything that implements a number protocol and has an add method
-# but we can't enforce the add method
-class count(Iterator[_N]):
-    @overload
-    def __new__(cls) -> count[int]: ...
-    @overload
-    def __new__(cls, start: _N, step: _Step = ...) -> count[_N]: ...
-    @overload
-    def __new__(cls, *, step: _N) -> count[_N]: ...
-    def __next__(self) -> _N: ...
-    def __iter__(self) -> Self: ...
-
-class cycle(Iterator[_T]):
-    def __init__(self, iterable: Iterable[_T], /) -> None: ...
-    def __next__(self) -> _T: ...
-    def __iter__(self) -> Self: ...
-
-class repeat(Iterator[_T]):
-    @overload
-    def __init__(self, object: _T) -> None: ...
-    @overload
-    def __init__(self, object: _T, times: int) -> None: ...
-    def __next__(self) -> _T: ...
-    def __iter__(self) -> Self: ...
-    def __length_hint__(self) -> int: ...
-
-class accumulate(Iterator[_T]):
-    @overload
-    def __init__(self, iterable: Iterable[_T], func: None = None, *, initial: _T | None = ...) -> None: ...
-    @overload
-    def __init__(self, iterable: Iterable[_S], func: Callable[[_T, _S], _T], *, initial: _T | None = ...) -> None: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T: ...
-
-class chain(Iterator[_T]):
-    def __init__(self, *iterables: Iterable[_T]) -> None: ...
-    def __next__(self) -> _T: ...
-    def __iter__(self) -> Self: ...
-    @classmethod
-    # We use type[Any] and not type[_S] to not lose the type inference from __iterable
-    def from_iterable(cls: type[Any], iterable: Iterable[Iterable[_S]], /) -> chain[_S]: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
-
-class compress(Iterator[_T]):
-    def __init__(self, data: Iterable[_T], selectors: Iterable[Any]) -> None: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T: ...
-
-class dropwhile(Iterator[_T]):
-    def __init__(self, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> None: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T: ...
-
-class filterfalse(Iterator[_T]):
-    def __init__(self, predicate: _Predicate[_T] | None, iterable: Iterable[_T], /) -> None: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T: ...
-
-class groupby(Iterator[tuple[_T_co, Iterator[_S_co]]], Generic[_T_co, _S_co]):
-    @overload
-    def __new__(cls, iterable: Iterable[_T1], key: None = None) -> groupby[_T1, _T1]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T1], key: Callable[[_T1], _T2]) -> groupby[_T2, _T1]: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> tuple[_T_co, Iterator[_S_co]]: ...
-
-class islice(Iterator[_T]):
-    @overload
-    def __init__(self, iterable: Iterable[_T], stop: int | None, /) -> None: ...
-    @overload
-    def __init__(self, iterable: Iterable[_T], start: int | None, stop: int | None, step: int | None = ..., /) -> None: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T: ...
-
-class starmap(Iterator[_T_co]):
-    def __new__(cls, function: Callable[..., _T], iterable: Iterable[Iterable[Any]], /) -> starmap[_T]: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T_co: ...
-
-class takewhile(Iterator[_T]):
-    def __init__(self, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> None: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T: ...
-
-def tee(iterable: Iterable[_T], n: int = 2, /) -> tuple[Iterator[_T], ...]: ...
-
-class zip_longest(Iterator[_T_co]):
-    # one iterable (fillvalue doesn't matter)
-    @overload
-    def __new__(cls, iter1: Iterable[_T1], /, *, fillvalue: object = ...) -> zip_longest[tuple[_T1]]: ...
-    # two iterables
-    @overload
-    # In the overloads without fillvalue, all of the tuple members could theoretically be None,
-    # but we return Any instead to avoid false positives for code where we know one of the iterables
-    # is longer.
-    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /) -> zip_longest[tuple[_T1 | Any, _T2 | Any]]: ...
-    @overload
-    def __new__(
-        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /, *, fillvalue: _T
-    ) -> zip_longest[tuple[_T1 | _T, _T2 | _T]]: ...
-    # three iterables
-    @overload
-    def __new__(
-        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /
-    ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any]]: ...
-    @overload
-    def __new__(
-        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /, *, fillvalue: _T
-    ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T]]: ...
-    # four iterables
-    @overload
-    def __new__(
-        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /
-    ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any, _T4 | Any]]: ...
-    @overload
-    def __new__(
-        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /, *, fillvalue: _T
-    ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T, _T4 | _T]]: ...
-    # five iterables
-    @overload
-    def __new__(
-        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /
-    ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any, _T4 | Any, _T5 | Any]]: ...
-    @overload
-    def __new__(
-        cls,
-        iter1: Iterable[_T1],
-        iter2: Iterable[_T2],
-        iter3: Iterable[_T3],
-        iter4: Iterable[_T4],
-        iter5: Iterable[_T5],
-        /,
-        *,
-        fillvalue: _T,
-    ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T, _T4 | _T, _T5 | _T]]: ...
-    # six or more iterables
-    @overload
-    def __new__(
-        cls,
-        iter1: Iterable[_T],
-        iter2: Iterable[_T],
-        iter3: Iterable[_T],
-        iter4: Iterable[_T],
-        iter5: Iterable[_T],
-        iter6: Iterable[_T],
-        /,
-        *iterables: Iterable[_T],
-    ) -> zip_longest[tuple[_T | Any, ...]]: ...
-    @overload
-    def __new__(
-        cls,
-        iter1: Iterable[_T],
-        iter2: Iterable[_T],
-        iter3: Iterable[_T],
-        iter4: Iterable[_T],
-        iter5: Iterable[_T],
-        iter6: Iterable[_T],
-        /,
-        *iterables: Iterable[_T],
-        fillvalue: _T,
-    ) -> zip_longest[tuple[_T, ...]]: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T_co: ...
-
-class product(Iterator[_T_co]):
-    @overload
-    def __new__(cls, iter1: Iterable[_T1], /) -> product[tuple[_T1]]: ...
-    @overload
-    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /) -> product[tuple[_T1, _T2]]: ...
-    @overload
-    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /) -> product[tuple[_T1, _T2, _T3]]: ...
-    @overload
-    def __new__(
-        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /
-    ) -> product[tuple[_T1, _T2, _T3, _T4]]: ...
-    @overload
-    def __new__(
-        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /
-    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
-    @overload
-    def __new__(
-        cls,
-        iter1: Iterable[_T1],
-        iter2: Iterable[_T2],
-        iter3: Iterable[_T3],
-        iter4: Iterable[_T4],
-        iter5: Iterable[_T5],
-        iter6: Iterable[_T6],
-        /,
-    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
-    @overload
-    def __new__(cls, *iterables: Iterable[_T1], repeat: int = 1) -> product[tuple[_T1, ...]]: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T_co: ...
-
-class permutations(Iterator[_T_co]):
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> permutations[tuple[_T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> permutations[tuple[_T, _T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> permutations[tuple[_T, _T, _T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> permutations[tuple[_T, _T, _T, _T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: int | None = ...) -> permutations[tuple[_T, ...]]: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T_co: ...
-
-class combinations(Iterator[_T_co]):
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations[tuple[_T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> combinations[tuple[_T, _T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> combinations[tuple[_T, _T, _T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> combinations[tuple[_T, _T, _T, _T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: int) -> combinations[tuple[_T, ...]]: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T_co: ...
-
-class combinations_with_replacement(Iterator[_T_co]):
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations_with_replacement[tuple[_T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> combinations_with_replacement[tuple[_T, _T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> combinations_with_replacement[tuple[_T, _T, _T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> combinations_with_replacement[tuple[_T, _T, _T, _T, _T]]: ...
-    @overload
-    def __new__(cls, iterable: Iterable[_T], r: int) -> combinations_with_replacement[tuple[_T, ...]]: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> _T_co: ...
-
-if sys.version_info >= (3, 10):
-    class pairwise(Iterator[_T_co]):
-        def __new__(cls, iterable: Iterable[_T], /) -> pairwise[tuple[_T, _T]]: ...
-        def __iter__(self) -> Self: ...
-        def __next__(self) -> _T_co: ...
-
-if sys.version_info >= (3, 12):
-    class batched(Iterator[tuple[_T_co, ...]], Generic[_T_co]):
-        def __new__(cls, iterable: Iterable[_T_co], n: int) -> Self: ...
-        def __iter__(self) -> Self: ...
-        def __next__(self) -> tuple[_T_co, ...]: ...

jaclang/vendor/mypy/typeshed/stdlib/json/__init__.pyi

@@ -1,61 +0,0 @@
-from _typeshed import SupportsRead, SupportsWrite
-from collections.abc import Callable
-from typing import Any
-
-from .decoder import JSONDecodeError as JSONDecodeError, JSONDecoder as JSONDecoder
-from .encoder import JSONEncoder as JSONEncoder
-
-__all__ = ["dump", "dumps", "load", "loads", "JSONDecoder", "JSONDecodeError", "JSONEncoder"]
-
-def dumps(
-    obj: Any,
-    *,
-    skipkeys: bool = False,
-    ensure_ascii: bool = True,
-    check_circular: bool = True,
-    allow_nan: bool = True,
-    cls: type[JSONEncoder] | None = None,
-    indent: None | int | str = None,
-    separators: tuple[str, str] | None = None,
-    default: Callable[[Any], Any] | None = None,
-    sort_keys: bool = False,
-    **kwds: Any,
-) -> str: ...
-def dump(
-    obj: Any,
-    fp: SupportsWrite[str],
-    *,
-    skipkeys: bool = False,
-    ensure_ascii: bool = True,
-    check_circular: bool = True,
-    allow_nan: bool = True,
-    cls: type[JSONEncoder] | None = None,
-    indent: None | int | str = None,
-    separators: tuple[str, str] | None = None,
-    default: Callable[[Any], Any] | None = None,
-    sort_keys: bool = False,
-    **kwds: Any,
-) -> None: ...
-def loads(
-    s: str | bytes | bytearray,
-    *,
-    cls: type[JSONDecoder] | None = None,
-    object_hook: Callable[[dict[Any, Any]], Any] | None = None,
-    parse_float: Callable[[str], Any] | None = None,
-    parse_int: Callable[[str], Any] | None = None,
-    parse_constant: Callable[[str], Any] | None = None,
-    object_pairs_hook: Callable[[list[tuple[Any, Any]]], Any] | None = None,
-    **kwds: Any,
-) -> Any: ...
-def load(
-    fp: SupportsRead[str | bytes],
-    *,
-    cls: type[JSONDecoder] | None = None,
-    object_hook: Callable[[dict[Any, Any]], Any] | None = None,
-    parse_float: Callable[[str], Any] | None = None,
-    parse_int: Callable[[str], Any] | None = None,
-    parse_constant: Callable[[str], Any] | None = None,
-    object_pairs_hook: Callable[[list[tuple[Any, Any]]], Any] | None = None,
-    **kwds: Any,
-) -> Any: ...
-def detect_encoding(b: bytes | bytearray) -> str: ...  # undocumented

jaclang/vendor/mypy/typeshed/stdlib/json/decoder.pyi

@@ -1,32 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-
-__all__ = ["JSONDecoder", "JSONDecodeError"]
-
-class JSONDecodeError(ValueError):
-    msg: str
-    doc: str
-    pos: int
-    lineno: int
-    colno: int
-    def __init__(self, msg: str, doc: str, pos: int) -> None: ...
-
-class JSONDecoder:
-    object_hook: Callable[[dict[str, Any]], Any]
-    parse_float: Callable[[str], Any]
-    parse_int: Callable[[str], Any]
-    parse_constant: Callable[[str], Any]
-    strict: bool
-    object_pairs_hook: Callable[[list[tuple[str, Any]]], Any]
-    def __init__(
-        self,
-        *,
-        object_hook: Callable[[dict[str, Any]], Any] | None = None,
-        parse_float: Callable[[str], Any] | None = None,
-        parse_int: Callable[[str], Any] | None = None,
-        parse_constant: Callable[[str], Any] | None = None,
-        strict: bool = True,
-        object_pairs_hook: Callable[[list[tuple[str, Any]]], Any] | None = None,
-    ) -> None: ...
-    def decode(self, s: str, _w: Callable[..., Any] = ...) -> Any: ...  # _w is undocumented
-    def raw_decode(self, s: str, idx: int = 0) -> tuple[Any, int]: ...

jaclang/vendor/mypy/typeshed/stdlib/json/encoder.pyi

@@ -1,40 +0,0 @@
-from collections.abc import Callable, Iterator
-from re import Pattern
-from typing import Any
-
-ESCAPE: Pattern[str]
-ESCAPE_ASCII: Pattern[str]
-HAS_UTF8: Pattern[bytes]
-ESCAPE_DCT: dict[str, str]
-INFINITY: float
-
-def py_encode_basestring(s: str) -> str: ...  # undocumented
-def py_encode_basestring_ascii(s: str) -> str: ...  # undocumented
-def encode_basestring(s: str) -> str: ...  # undocumented
-def encode_basestring_ascii(s: str) -> str: ...  # undocumented
-
-class JSONEncoder:
-    item_separator: str
-    key_separator: str
-
-    skipkeys: bool
-    ensure_ascii: bool
-    check_circular: bool
-    allow_nan: bool
-    sort_keys: bool
-    indent: int | str
-    def __init__(
-        self,
-        *,
-        skipkeys: bool = False,
-        ensure_ascii: bool = True,
-        check_circular: bool = True,
-        allow_nan: bool = True,
-        sort_keys: bool = False,
-        indent: int | str | None = None,
-        separators: tuple[str, str] | None = None,
-        default: Callable[..., Any] | None = None,
-    ) -> None: ...
-    def default(self, o: Any) -> Any: ...
-    def encode(self, o: Any) -> str: ...
-    def iterencode(self, o: Any, _one_shot: bool = False) -> Iterator[str]: ...

jaclang/vendor/mypy/typeshed/stdlib/json/tool.pyi

@@ -1 +0,0 @@
-def main() -> None: ...

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

@@ -1,21 +0,0 @@
-import sys
-from collections.abc import Sequence
-from typing import Final
-
-if sys.version_info >= (3, 9):
-    __all__ = ["iskeyword", "issoftkeyword", "kwlist", "softkwlist"]
-else:
-    __all__ = ["iskeyword", "kwlist"]
-
-def iskeyword(s: str) -> bool: ...
-
-# a list at runtime, but you're not meant to mutate it;
-# type it as a sequence
-kwlist: Final[Sequence[str]]
-
-if sys.version_info >= (3, 9):
-    def issoftkeyword(s: str) -> bool: ...
-
-    # a list at runtime, but you're not meant to mutate it;
-    # type it as a sequence
-    softkwlist: Final[Sequence[str]]

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

@@ -1,28 +0,0 @@
-from _typeshed import Incomplete, SupportsGetItem
-from collections import defaultdict
-from collections.abc import Iterable
-
-from .fixer_base import BaseFix
-from .pytree import Leaf, Node
-
-class BMNode:
-    count: Incomplete
-    transition_table: Incomplete
-    fixers: Incomplete
-    id: Incomplete
-    content: str
-    def __init__(self) -> None: ...
-
-class BottomMatcher:
-    match: Incomplete
-    root: Incomplete
-    nodes: Incomplete
-    fixers: Incomplete
-    logger: Incomplete
-    def __init__(self) -> None: ...
-    def add_fixer(self, fixer: BaseFix) -> None: ...
-    def add(self, pattern: SupportsGetItem[int | slice, Incomplete] | None, start: BMNode) -> list[BMNode]: ...
-    def run(self, leaves: Iterable[Leaf]) -> defaultdict[BaseFix, list[Node | Leaf]]: ...
-    def print_ac(self) -> None: ...
-
-def type_repr(type_num: int) -> str | int: ...

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

@@ -1,42 +0,0 @@
-from _typeshed import Incomplete, StrPath
-from abc import ABCMeta, abstractmethod
-from collections.abc import MutableMapping
-from typing import ClassVar, Literal, TypeVar
-
-from .pytree import Base, Leaf, Node
-
-_N = TypeVar("_N", bound=Base)
-
-class BaseFix:
-    PATTERN: ClassVar[str | None]
-    pattern: Incomplete | None
-    pattern_tree: Incomplete | None
-    options: Incomplete | None
-    filename: Incomplete | None
-    numbers: Incomplete
-    used_names: Incomplete
-    order: ClassVar[Literal["post", "pre"]]
-    explicit: ClassVar[bool]
-    run_order: ClassVar[int]
-    keep_line_order: ClassVar[bool]
-    BM_compatible: ClassVar[bool]
-    syms: Incomplete
-    log: Incomplete
-    def __init__(self, options: MutableMapping[str, Incomplete], log: list[str]) -> None: ...
-    def compile_pattern(self) -> None: ...
-    def set_filename(self, filename: StrPath) -> None: ...
-    def match(self, node: _N) -> Literal[False] | dict[str, _N]: ...
-    @abstractmethod
-    def transform(self, node: Base, results: dict[str, Base]) -> Node | Leaf | None: ...
-    def new_name(self, template: str = "xxx_todo_changeme") -> str: ...
-    first_log: bool
-    def log_message(self, message: str) -> None: ...
-    def cannot_convert(self, node: Base, reason: str | None = None) -> None: ...
-    def warning(self, node: Base, reason: str) -> None: ...
-    def start_tree(self, tree: Node, filename: StrPath) -> None: ...
-    def finish_tree(self, tree: Node, filename: StrPath) -> None: ...
-
-class ConditionalFix(BaseFix, metaclass=ABCMeta):
-    skip_on: ClassVar[str | None]
-    def start_tree(self, tree: Node, filename: StrPath, /) -> None: ...
-    def should_skip(self, node: Base) -> bool: ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_apply.pyi

@@ -1,8 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixApply(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results): ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_asserts.pyi

@@ -1,10 +0,0 @@
-from typing import ClassVar, Literal
-
-from ..fixer_base import BaseFix
-
-NAMES: dict[str, str]
-
-class FixAsserts(BaseFix):
-    BM_compatible: ClassVar[Literal[False]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_basestring.pyi

@@ -1,8 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixBasestring(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[Literal["'basestring'"]]
-    def transform(self, node, results): ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_buffer.pyi

@@ -1,8 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixBuffer(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_dict.pyi

@@ -1,16 +0,0 @@
-from _typeshed import Incomplete
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-iter_exempt: set[str]
-
-class FixDict(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results): ...
-    P1: ClassVar[str]
-    p1: ClassVar[Incomplete]
-    P2: ClassVar[str]
-    p2: ClassVar[Incomplete]
-    def in_special_context(self, node, isiter): ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_except.pyi

@@ -1,14 +0,0 @@
-from collections.abc import Generator, Iterable
-from typing import ClassVar, Literal, TypeVar
-
-from .. import fixer_base
-from ..pytree import Base
-
-_N = TypeVar("_N", bound=Base)
-
-def find_excepts(nodes: Iterable[_N]) -> Generator[tuple[_N, _N], None, None]: ...
-
-class FixExcept(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results): ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_exec.pyi

@@ -1,8 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixExec(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results): ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_execfile.pyi

@@ -1,8 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixExecfile(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results): ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_exitfunc.pyi

@@ -1,13 +0,0 @@
-from _typeshed import Incomplete, StrPath
-from lib2to3 import fixer_base
-from typing import ClassVar, Literal
-
-from ..pytree import Node
-
-class FixExitfunc(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def __init__(self, *args) -> None: ...
-    sys_import: Incomplete | None
-    def start_tree(self, tree: Node, filename: StrPath) -> None: ...
-    def transform(self, node, results) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_filter.pyi

@@ -1,9 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixFilter(fixer_base.ConditionalFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    skip_on: ClassVar[Literal["future_builtins.filter"]]
-    def transform(self, node, results): ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_funcattrs.pyi

@@ -1,8 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixFuncattrs(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_future.pyi

@@ -1,8 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixFuture(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results): ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_getcwdu.pyi

@@ -1,8 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixGetcwdu(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/lib2to3/fixes/fix_has_key.pyi

@@ -1,8 +0,0 @@
-from typing import ClassVar, Literal
-
-from .. import fixer_base
-
-class FixHasKey(fixer_base.BaseFix):
-    BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[str]
-    def transform(self, node, results): ...