jaclang 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

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

@@ -0,0 +1,171 @@
+import sys
+from _typeshed import (
+    AnyOrLiteralStr,
+    BytesPath,
+    FileDescriptorOrPath,
+    StrOrBytesPath,
+    StrPath,
+)
+from collections.abc import Iterable
+from genericpath import (
+    commonprefix as commonprefix,
+    exists as exists,
+    getatime as getatime,
+    getctime as getctime,
+    getmtime as getmtime,
+    getsize as getsize,
+    isdir as isdir,
+    isfile as isfile,
+    samefile as samefile,
+    sameopenfile as sameopenfile,
+    samestat as samestat,
+)
+from os import PathLike
+from typing import AnyStr, overload
+from typing_extensions import LiteralString
+
+__all__ = [
+    "normcase",
+    "isabs",
+    "join",
+    "splitdrive",
+    "split",
+    "splitext",
+    "basename",
+    "dirname",
+    "commonprefix",
+    "getsize",
+    "getmtime",
+    "getatime",
+    "getctime",
+    "islink",
+    "exists",
+    "lexists",
+    "isdir",
+    "isfile",
+    "ismount",
+    "expanduser",
+    "expandvars",
+    "normpath",
+    "abspath",
+    "samefile",
+    "sameopenfile",
+    "samestat",
+    "curdir",
+    "pardir",
+    "sep",
+    "pathsep",
+    "defpath",
+    "altsep",
+    "extsep",
+    "devnull",
+    "realpath",
+    "supports_unicode_filenames",
+    "relpath",
+    "commonpath",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["isjunction", "splitroot"]
+
+supports_unicode_filenames: bool
+# aliases (also in os)
+curdir: LiteralString
+pardir: LiteralString
+sep: LiteralString
+altsep: LiteralString | None
+extsep: LiteralString
+pathsep: LiteralString
+defpath: LiteralString
+devnull: LiteralString
+
+# Overloads are necessary to work around python/mypy#3644.
+@overload
+def abspath(path: PathLike[AnyStr]) -> AnyStr: ...
+@overload
+def abspath(path: AnyStr) -> AnyStr: ...
+@overload
+def basename(p: PathLike[AnyStr]) -> AnyStr: ...
+@overload
+def basename(p: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
+@overload
+def dirname(p: PathLike[AnyStr]) -> AnyStr: ...
+@overload
+def dirname(p: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
+@overload
+def expanduser(path: PathLike[AnyStr]) -> AnyStr: ...
+@overload
+def expanduser(path: AnyStr) -> AnyStr: ...
+@overload
+def expandvars(path: PathLike[AnyStr]) -> AnyStr: ...
+@overload
+def expandvars(path: AnyStr) -> AnyStr: ...
+@overload
+def normcase(s: PathLike[AnyStr]) -> AnyStr: ...
+@overload
+def normcase(s: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
+@overload
+def normpath(path: PathLike[AnyStr]) -> AnyStr: ...
+@overload
+def normpath(path: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
+@overload
+def commonpath(paths: Iterable[LiteralString]) -> LiteralString: ...
+@overload
+def commonpath(paths: Iterable[StrPath]) -> str: ...
+@overload
+def commonpath(paths: Iterable[BytesPath]) -> bytes: ...
+
+# First parameter is not actually pos-only,
+# but must be defined as pos-only in the stub or cross-platform code doesn't type-check,
+# as the parameter name is different in ntpath.join()
+@overload
+def join(__a: LiteralString, *paths: LiteralString) -> LiteralString: ...
+@overload
+def join(__a: StrPath, *paths: StrPath) -> str: ...
+@overload
+def join(__a: BytesPath, *paths: BytesPath) -> bytes: ...
+
+if sys.version_info >= (3, 10):
+    @overload
+    def realpath(filename: PathLike[AnyStr], *, strict: bool = False) -> AnyStr: ...
+    @overload
+    def realpath(filename: AnyStr, *, strict: bool = False) -> AnyStr: ...
+
+else:
+    @overload
+    def realpath(filename: PathLike[AnyStr]) -> AnyStr: ...
+    @overload
+    def realpath(filename: AnyStr) -> AnyStr: ...
+
+@overload
+def relpath(
+    path: LiteralString, start: LiteralString | None = None
+) -> LiteralString: ...
+@overload
+def relpath(path: BytesPath, start: BytesPath | None = None) -> bytes: ...
+@overload
+def relpath(path: StrPath, start: StrPath | None = None) -> str: ...
+@overload
+def split(p: PathLike[AnyStr]) -> tuple[AnyStr, AnyStr]: ...
+@overload
+def split(p: AnyOrLiteralStr) -> tuple[AnyOrLiteralStr, AnyOrLiteralStr]: ...
+@overload
+def splitdrive(p: PathLike[AnyStr]) -> tuple[AnyStr, AnyStr]: ...
+@overload
+def splitdrive(p: AnyOrLiteralStr) -> tuple[AnyOrLiteralStr, AnyOrLiteralStr]: ...
+@overload
+def splitext(p: PathLike[AnyStr]) -> tuple[AnyStr, AnyStr]: ...
+@overload
+def splitext(p: AnyOrLiteralStr) -> tuple[AnyOrLiteralStr, AnyOrLiteralStr]: ...
+def isabs(s: StrOrBytesPath) -> bool: ...
+def islink(path: FileDescriptorOrPath) -> bool: ...
+def ismount(path: FileDescriptorOrPath) -> bool: ...
+def lexists(path: FileDescriptorOrPath) -> bool: ...
+
+if sys.version_info >= (3, 12):
+    def isjunction(path: StrOrBytesPath) -> bool: ...
+    @overload
+    def splitroot(
+        p: AnyOrLiteralStr,
+    ) -> tuple[AnyOrLiteralStr, AnyOrLiteralStr, AnyOrLiteralStr]: ...
+    @overload
+    def splitroot(p: PathLike[AnyStr]) -> tuple[AnyStr, AnyStr, AnyStr]: ...

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

@@ -0,0 +1,122 @@
+import sys
+from typing import IO
+
+__all__ = [
+    "pprint",
+    "pformat",
+    "isreadable",
+    "isrecursive",
+    "saferepr",
+    "PrettyPrinter",
+    "pp",
+]
+
+if sys.version_info >= (3, 10):
+    def pformat(
+        object: object,
+        indent: int = 1,
+        width: int = 80,
+        depth: int | None = None,
+        *,
+        compact: bool = False,
+        sort_dicts: bool = True,
+        underscore_numbers: bool = False,
+    ) -> str: ...
+
+else:
+    def pformat(
+        object: object,
+        indent: int = 1,
+        width: int = 80,
+        depth: int | None = None,
+        *,
+        compact: bool = False,
+        sort_dicts: bool = True,
+    ) -> str: ...
+
+if sys.version_info >= (3, 10):
+    def pp(
+        object: object,
+        stream: IO[str] | None = ...,
+        indent: int = ...,
+        width: int = ...,
+        depth: int | None = ...,
+        *,
+        compact: bool = ...,
+        sort_dicts: bool = False,
+        underscore_numbers: bool = ...,
+    ) -> None: ...
+
+else:
+    def pp(
+        object: object,
+        stream: IO[str] | None = ...,
+        indent: int = ...,
+        width: int = ...,
+        depth: int | None = ...,
+        *,
+        compact: bool = ...,
+        sort_dicts: bool = False,
+    ) -> None: ...
+
+if sys.version_info >= (3, 10):
+    def pprint(
+        object: object,
+        stream: IO[str] | None = None,
+        indent: int = 1,
+        width: int = 80,
+        depth: int | None = None,
+        *,
+        compact: bool = False,
+        sort_dicts: bool = True,
+        underscore_numbers: bool = False,
+    ) -> None: ...
+
+else:
+    def pprint(
+        object: object,
+        stream: IO[str] | None = None,
+        indent: int = 1,
+        width: int = 80,
+        depth: int | None = None,
+        *,
+        compact: bool = False,
+        sort_dicts: bool = True,
+    ) -> None: ...
+
+def isreadable(object: object) -> bool: ...
+def isrecursive(object: object) -> bool: ...
+def saferepr(object: object) -> str: ...
+
+class PrettyPrinter:
+    if sys.version_info >= (3, 10):
+        def __init__(
+            self,
+            indent: int = 1,
+            width: int = 80,
+            depth: int | None = None,
+            stream: IO[str] | None = None,
+            *,
+            compact: bool = False,
+            sort_dicts: bool = True,
+            underscore_numbers: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            indent: int = 1,
+            width: int = 80,
+            depth: int | None = None,
+            stream: IO[str] | None = None,
+            *,
+            compact: bool = False,
+            sort_dicts: bool = True,
+        ) -> None: ...
+
+    def pformat(self, object: object) -> str: ...
+    def pprint(self, object: object) -> None: ...
+    def isreadable(self, object: object) -> bool: ...
+    def isrecursive(self, object: object) -> bool: ...
+    def format(
+        self, object: object, context: dict[int, int], maxlevels: int, level: int
+    ) -> tuple[str, bool, bool]: ...

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

@@ -0,0 +1,43 @@
+from _typeshed import StrOrBytesPath
+from collections.abc import Callable
+from typing import Any, TypeVar
+from typing_extensions import ParamSpec, Self, TypeAlias
+
+__all__ = ["run", "runctx", "Profile"]
+
+def run(statement: str, filename: str | None = None, sort: str | int = -1) -> None: ...
+def runctx(
+    statement: str,
+    globals: dict[str, Any],
+    locals: dict[str, Any],
+    filename: str | None = None,
+    sort: str | int = -1,
+) -> None: ...
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+_Label: TypeAlias = tuple[str, int, str]
+
+class Profile:
+    bias: int
+    stats: dict[
+        _Label, tuple[int, int, int, int, dict[_Label, tuple[int, int, int, int]]]
+    ]  # undocumented
+    def __init__(
+        self, timer: Callable[[], float] | None = None, bias: int | None = None
+    ) -> None: ...
+    def set_cmd(self, cmd: str) -> None: ...
+    def simulate_call(self, name: str) -> None: ...
+    def simulate_cmd_complete(self) -> None: ...
+    def print_stats(self, sort: str | int = -1) -> None: ...
+    def dump_stats(self, file: StrOrBytesPath) -> None: ...
+    def create_stats(self) -> None: ...
+    def snapshot_stats(self) -> None: ...
+    def run(self, cmd: str) -> Self: ...
+    def runctx(
+        self, cmd: str, globals: dict[str, Any], locals: dict[str, Any]
+    ) -> Self: ...
+    def runcall(
+        self, __func: Callable[_P, _T], *args: _P.args, **kw: _P.kwargs
+    ) -> _T: ...
+    def calibrate(self, m: int, verbose: int = 0) -> float: ...

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

@@ -0,0 +1,85 @@
+import sys
+from _typeshed import StrEnum, StrOrBytesPath
+from collections.abc import Iterable
+from cProfile import Profile as _cProfile
+from profile import Profile
+from typing import IO, Any, Literal, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 9):
+    __all__ = ["Stats", "SortKey", "FunctionProfile", "StatsProfile"]
+else:
+    __all__ = ["Stats", "SortKey"]
+
+_Selector: TypeAlias = str | float | int
+
+class SortKey(StrEnum):
+    CALLS: str
+    CUMULATIVE: str
+    FILENAME: str
+    LINE: str
+    NAME: str
+    NFL: str
+    PCALLS: str
+    STDNAME: str
+    TIME: str
+
+if sys.version_info >= (3, 9):
+    from dataclasses import dataclass
+
+    @dataclass(unsafe_hash=True)
+    class FunctionProfile:
+        ncalls: str
+        tottime: float
+        percall_tottime: float
+        cumtime: float
+        percall_cumtime: float
+        file_name: str
+        line_number: int
+
+    @dataclass(unsafe_hash=True)
+    class StatsProfile:
+        total_tt: float
+        func_profiles: dict[str, FunctionProfile]
+
+_SortArgDict: TypeAlias = dict[str, tuple[tuple[tuple[int, int], ...], str]]
+
+class Stats:
+    sort_arg_dict_default: _SortArgDict
+    def __init__(
+        self,
+        __arg: None | str | Profile | _cProfile = ...,
+        *args: None | str | Profile | _cProfile | Self,
+        stream: IO[Any] | None = None,
+    ) -> None: ...
+    def init(self, arg: None | str | Profile | _cProfile) -> None: ...
+    def load_stats(self, arg: None | str | Profile | _cProfile) -> None: ...
+    def get_top_level_stats(self) -> None: ...
+    def add(self, *arg_list: None | str | Profile | _cProfile | Self) -> Self: ...
+    def dump_stats(self, filename: StrOrBytesPath) -> None: ...
+    def get_sort_arg_defs(self) -> _SortArgDict: ...
+    @overload
+    def sort_stats(self, field: Literal[-1, 0, 1, 2]) -> Self: ...
+    @overload
+    def sort_stats(self, *field: str) -> Self: ...
+    def reverse_order(self) -> Self: ...
+    def strip_dirs(self) -> Self: ...
+    def calc_callees(self) -> None: ...
+    def eval_print_amount(
+        self, sel: _Selector, list: list[str], msg: str
+    ) -> tuple[list[str], str]: ...
+    if sys.version_info >= (3, 9):
+        def get_stats_profile(self) -> StatsProfile: ...
+
+    def get_print_list(
+        self, sel_list: Iterable[_Selector]
+    ) -> tuple[int, list[str]]: ...
+    def print_stats(self, *amount: _Selector) -> Self: ...
+    def print_callees(self, *amount: _Selector) -> Self: ...
+    def print_callers(self, *amount: _Selector) -> Self: ...
+    def print_call_heading(self, name_size: int, column_title: str) -> None: ...
+    def print_call_line(
+        self, name_size: int, source: str, call_dict: dict[str, Any], arrow: str = "->"
+    ) -> None: ...
+    def print_title(self) -> None: ...
+    def print_line(self, func: str) -> None: ...

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

@@ -0,0 +1,21 @@
+import sys
+from collections.abc import Callable, Iterable
+from typing import Literal
+from typing_extensions import TypeAlias
+
+if sys.platform != "win32":
+    __all__ = ["openpty", "fork", "spawn"]
+    _Reader: TypeAlias = Callable[[int], bytes]
+
+    STDIN_FILENO: Literal[0]
+    STDOUT_FILENO: Literal[1]
+    STDERR_FILENO: Literal[2]
+
+    CHILD: Literal[0]
+    def openpty() -> tuple[int, int]: ...
+    def master_open() -> tuple[int, str]: ...  # deprecated, use openpty()
+    def slave_open(tty_name: str) -> int: ...  # deprecated, use openpty()
+    def fork() -> tuple[int, int]: ...
+    def spawn(
+        argv: str | Iterable[str], master_read: _Reader = ..., stdin_read: _Reader = ...
+    ) -> int: ...

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

@@ -0,0 +1,36 @@
+import sys
+from _typeshed import structseq
+from typing import Any, Final, final
+
+if sys.platform != "win32":
+    @final
+    class struct_passwd(structseq[Any], tuple[str, str, int, int, str, str, str]):
+        if sys.version_info >= (3, 10):
+            __match_args__: Final = (
+                "pw_name",
+                "pw_passwd",
+                "pw_uid",
+                "pw_gid",
+                "pw_gecos",
+                "pw_dir",
+                "pw_shell",
+            )
+
+        @property
+        def pw_name(self) -> str: ...
+        @property
+        def pw_passwd(self) -> str: ...
+        @property
+        def pw_uid(self) -> int: ...
+        @property
+        def pw_gid(self) -> int: ...
+        @property
+        def pw_gecos(self) -> str: ...
+        @property
+        def pw_dir(self) -> str: ...
+        @property
+        def pw_shell(self) -> str: ...
+
+    def getpwall() -> list[struct_passwd]: ...
+    def getpwuid(__uid: int) -> struct_passwd: ...
+    def getpwnam(__name: str) -> struct_passwd: ...

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

@@ -0,0 +1,40 @@
+import enum
+import sys
+from typing import AnyStr
+
+__all__ = ["compile", "main", "PyCompileError", "PycInvalidationMode"]
+
+class PyCompileError(Exception):
+    exc_type_name: str
+    exc_value: BaseException
+    file: str
+    msg: str
+    def __init__(
+        self,
+        exc_type: type[BaseException],
+        exc_value: BaseException,
+        file: str,
+        msg: str = "",
+    ) -> None: ...
+
+class PycInvalidationMode(enum.Enum):
+    TIMESTAMP: int
+    CHECKED_HASH: int
+    UNCHECKED_HASH: int
+
+def _get_default_invalidation_mode() -> PycInvalidationMode: ...
+def compile(
+    file: AnyStr,
+    cfile: AnyStr | None = None,
+    dfile: AnyStr | None = None,
+    doraise: bool = False,
+    optimize: int = -1,
+    invalidation_mode: PycInvalidationMode | None = None,
+    quiet: int = 0,
+) -> AnyStr | None: ...
+
+if sys.version_info >= (3, 10):
+    def main() -> None: ...
+
+else:
+    def main(args: list[str] | None = None) -> int: ...

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

@@ -0,0 +1,97 @@
+import sys
+from collections.abc import Mapping, Sequence
+
+__all__ = ["readmodule", "readmodule_ex", "Class", "Function"]
+
+class _Object:
+    module: str
+    name: str
+    file: int
+    lineno: int
+
+    if sys.version_info >= (3, 10):
+        end_lineno: int | None
+
+    parent: _Object | None
+
+    # This is a dict at runtime, but we're typing it as Mapping to
+    # avoid variance issues in the subclasses
+    children: Mapping[str, _Object]
+
+    if sys.version_info >= (3, 10):
+        def __init__(
+            self,
+            module: str,
+            name: str,
+            file: str,
+            lineno: int,
+            end_lineno: int | None,
+            parent: _Object | None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, module: str, name: str, file: str, lineno: int, parent: _Object | None
+        ) -> None: ...
+
+class Function(_Object):
+    if sys.version_info >= (3, 10):
+        is_async: bool
+
+    parent: Function | Class | None
+    children: dict[str, Class | Function]
+
+    if sys.version_info >= (3, 10):
+        def __init__(
+            self,
+            module: str,
+            name: str,
+            file: str,
+            lineno: int,
+            parent: Function | Class | None = None,
+            is_async: bool = False,
+            *,
+            end_lineno: int | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            module: str,
+            name: str,
+            file: str,
+            lineno: int,
+            parent: Function | Class | None = None,
+        ) -> None: ...
+
+class Class(_Object):
+    super: list[Class | str] | None
+    methods: dict[str, int]
+    parent: Class | None
+    children: dict[str, Class | Function]
+
+    if sys.version_info >= (3, 10):
+        def __init__(
+            self,
+            module: str,
+            name: str,
+            super_: list[Class | str] | None,
+            file: str,
+            lineno: int,
+            parent: Class | None = None,
+            *,
+            end_lineno: int | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            module: str,
+            name: str,
+            super: list[Class | str] | None,
+            file: str,
+            lineno: int,
+            parent: Class | None = None,
+        ) -> None: ...
+
+def readmodule(module: str, path: Sequence[str] | None = None) -> dict[str, Class]: ...
+def readmodule_ex(
+    module: str, path: Sequence[str] | None = None
+) -> dict[str, Class | Function | list[str]]: ...