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

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

@@ -0,0 +1,103 @@
+import sys
+from typing import Literal
+
+SF_APPEND: Literal[0x00040000]
+SF_ARCHIVED: Literal[0x00010000]
+SF_IMMUTABLE: Literal[0x00020000]
+SF_NOUNLINK: Literal[0x00100000]
+SF_SNAPSHOT: Literal[0x00200000]
+
+ST_MODE: Literal[0]
+ST_INO: Literal[1]
+ST_DEV: Literal[2]
+ST_NLINK: Literal[3]
+ST_UID: Literal[4]
+ST_GID: Literal[5]
+ST_SIZE: Literal[6]
+ST_ATIME: Literal[7]
+ST_MTIME: Literal[8]
+ST_CTIME: Literal[9]
+
+S_IFIFO: Literal[0o010000]
+S_IFLNK: Literal[0o120000]
+S_IFREG: Literal[0o100000]
+S_IFSOCK: Literal[0o140000]
+S_IFBLK: Literal[0o060000]
+S_IFCHR: Literal[0o020000]
+S_IFDIR: Literal[0o040000]
+
+# These are 0 on systems that don't support the specific kind of file.
+# Example: Linux doesn't support door files, so S_IFDOOR is 0 on linux.
+S_IFDOOR: int
+S_IFPORT: int
+S_IFWHT: int
+
+S_ISUID: Literal[0o4000]
+S_ISGID: Literal[0o2000]
+S_ISVTX: Literal[0o1000]
+
+S_IRWXU: Literal[0o0700]
+S_IRUSR: Literal[0o0400]
+S_IWUSR: Literal[0o0200]
+S_IXUSR: Literal[0o0100]
+
+S_IRWXG: Literal[0o0070]
+S_IRGRP: Literal[0o0040]
+S_IWGRP: Literal[0o0020]
+S_IXGRP: Literal[0o0010]
+
+S_IRWXO: Literal[0o0007]
+S_IROTH: Literal[0o0004]
+S_IWOTH: Literal[0o0002]
+S_IXOTH: Literal[0o0001]
+
+S_ENFMT: Literal[0o2000]
+S_IREAD: Literal[0o0400]
+S_IWRITE: Literal[0o0200]
+S_IEXEC: Literal[0o0100]
+
+UF_APPEND: Literal[0x00000004]
+UF_COMPRESSED: Literal[0x00000020]  # OS X 10.6+ only
+UF_HIDDEN: Literal[0x00008000]  # OX X 10.5+ only
+UF_IMMUTABLE: Literal[0x00000002]
+UF_NODUMP: Literal[0x00000001]
+UF_NOUNLINK: Literal[0x00000010]
+UF_OPAQUE: Literal[0x00000008]
+
+def S_IMODE(mode: int) -> int: ...
+def S_IFMT(mode: int) -> int: ...
+def S_ISBLK(mode: int) -> bool: ...
+def S_ISCHR(mode: int) -> bool: ...
+def S_ISDIR(mode: int) -> bool: ...
+def S_ISDOOR(mode: int) -> bool: ...
+def S_ISFIFO(mode: int) -> bool: ...
+def S_ISLNK(mode: int) -> bool: ...
+def S_ISPORT(mode: int) -> bool: ...
+def S_ISREG(mode: int) -> bool: ...
+def S_ISSOCK(mode: int) -> bool: ...
+def S_ISWHT(mode: int) -> bool: ...
+def filemode(mode: int) -> str: ...
+
+if sys.platform == "win32":
+    IO_REPARSE_TAG_SYMLINK: int
+    IO_REPARSE_TAG_MOUNT_POINT: int
+    IO_REPARSE_TAG_APPEXECLINK: int
+
+if sys.platform == "win32":
+    FILE_ATTRIBUTE_ARCHIVE: Literal[32]
+    FILE_ATTRIBUTE_COMPRESSED: Literal[2048]
+    FILE_ATTRIBUTE_DEVICE: Literal[64]
+    FILE_ATTRIBUTE_DIRECTORY: Literal[16]
+    FILE_ATTRIBUTE_ENCRYPTED: Literal[16384]
+    FILE_ATTRIBUTE_HIDDEN: Literal[2]
+    FILE_ATTRIBUTE_INTEGRITY_STREAM: Literal[32768]
+    FILE_ATTRIBUTE_NORMAL: Literal[128]
+    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: Literal[8192]
+    FILE_ATTRIBUTE_NO_SCRUB_DATA: Literal[131072]
+    FILE_ATTRIBUTE_OFFLINE: Literal[4096]
+    FILE_ATTRIBUTE_READONLY: Literal[1]
+    FILE_ATTRIBUTE_REPARSE_POINT: Literal[1024]
+    FILE_ATTRIBUTE_SPARSE_FILE: Literal[512]
+    FILE_ATTRIBUTE_SYSTEM: Literal[4]
+    FILE_ATTRIBUTE_TEMPORARY: Literal[256]
+    FILE_ATTRIBUTE_VIRTUAL: Literal[65536]

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

@@ -0,0 +1,63 @@
+import sys
+from _typeshed import structseq
+from collections.abc import Callable
+from threading import Thread
+from types import TracebackType
+from typing import Any, Final, NoReturn, final
+
+error = RuntimeError
+
+def _count() -> int: ...
+@final
+class LockType:
+    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
+    def release(self) -> None: ...
+    def locked(self) -> bool: ...
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self,
+        type: type[BaseException] | None,
+        value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None: ...
+
+def start_new_thread(
+    function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any] = ...
+) -> int: ...
+def interrupt_main() -> None: ...
+def exit() -> NoReturn: ...
+def allocate_lock() -> LockType: ...
+def get_ident() -> int: ...
+def stack_size(size: int = ...) -> int: ...
+
+TIMEOUT_MAX: float
+
+def get_native_id() -> int: ...  # only available on some platforms
+@final
+class _ExceptHookArgs(
+    structseq[Any],
+    tuple[
+        type[BaseException], BaseException | None, TracebackType | None, Thread | None
+    ],
+):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("exc_type", "exc_value", "exc_traceback", "thread")
+
+    @property
+    def exc_type(self) -> type[BaseException]: ...
+    @property
+    def exc_value(self) -> BaseException | None: ...
+    @property
+    def exc_traceback(self) -> TracebackType | None: ...
+    @property
+    def thread(self) -> Thread | None: ...
+
+_excepthook: Callable[[_ExceptHookArgs], Any]
+
+if sys.version_info >= (3, 12):
+    def daemon_threads_allowed() -> bool: ...
+
+class _local:
+    def __getattribute__(self, __name: str) -> Any: ...
+    def __setattr__(self, __name: str, __value: Any) -> None: ...
+    def __delattr__(self, __name: str) -> None: ...

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

@@ -0,0 +1,17 @@
+from typing import Any
+from typing_extensions import TypeAlias
+from weakref import ReferenceType
+
+__all__ = ["local"]
+_LocalDict: TypeAlias = dict[Any, Any]
+
+class _localimpl:
+    key: str
+    dicts: dict[int, tuple[ReferenceType[Any], _LocalDict]]
+    def get_dict(self) -> _LocalDict: ...
+    def create_dict(self) -> _LocalDict: ...
+
+class local:
+    def __getattribute__(self, name: str) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+    def __delattr__(self, name: str) -> None: ...

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

@@ -0,0 +1,120 @@
+import sys
+from typing import Any, ClassVar, Literal, final
+
+# _tkinter is meant to be only used internally by tkinter, but some tkinter
+# functions e.g. return _tkinter.Tcl_Obj objects. Tcl_Obj represents a Tcl
+# object that hasn't been converted to a string.
+#
+# There are not many ways to get Tcl_Objs from tkinter, and I'm not sure if the
+# only existing ways are supposed to return Tcl_Objs as opposed to returning
+# strings. Here's one of these things that return Tcl_Objs:
+#
+#    >>> import tkinter
+#    >>> text = tkinter.Text()
+#    >>> text.tag_add('foo', '1.0', 'end')
+#    >>> text.tag_ranges('foo')
+#    (<textindex object: '1.0'>, <textindex object: '2.0'>)
+@final
+class Tcl_Obj:
+    @property
+    def string(self) -> str: ...
+    @property
+    def typename(self) -> str: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    def __eq__(self, __value): ...
+    def __ge__(self, __value): ...
+    def __gt__(self, __value): ...
+    def __le__(self, __value): ...
+    def __lt__(self, __value): ...
+    def __ne__(self, __value): ...
+
+class TclError(Exception): ...
+
+# This class allows running Tcl code. Tkinter uses it internally a lot, and
+# it's often handy to drop a piece of Tcl code into a tkinter program. Example:
+#
+#    >>> import tkinter, _tkinter
+#    >>> tkapp = tkinter.Tk().tk
+#    >>> isinstance(tkapp, _tkinter.TkappType)
+#    True
+#    >>> tkapp.call('set', 'foo', (1,2,3))
+#    (1, 2, 3)
+#    >>> tkapp.eval('return $foo')
+#    '1 2 3'
+#    >>>
+#
+# call args can be pretty much anything. Also, call(some_tuple) is same as call(*some_tuple).
+#
+# eval always returns str because _tkinter_tkapp_eval_impl in _tkinter.c calls
+# Tkapp_UnicodeResult, and it returns a string when it succeeds.
+@final
+class TkappType:
+    # Please keep in sync with tkinter.Tk
+    def adderrorinfo(self, __msg): ...
+    def call(self, __command: Any, *args: Any) -> Any: ...
+    def createcommand(self, __name, __func): ...
+    if sys.platform != "win32":
+        def createfilehandler(self, __file, __mask, __func): ...
+        def deletefilehandler(self, __file): ...
+
+    def createtimerhandler(self, __milliseconds, __func): ...
+    def deletecommand(self, __name): ...
+    def dooneevent(self, __flags: int = 0): ...
+    def eval(self, __script: str) -> str: ...
+    def evalfile(self, __fileName): ...
+    def exprboolean(self, __s): ...
+    def exprdouble(self, __s): ...
+    def exprlong(self, __s): ...
+    def exprstring(self, __s): ...
+    def getboolean(self, __arg): ...
+    def getdouble(self, __arg): ...
+    def getint(self, __arg): ...
+    def getvar(self, *args, **kwargs): ...
+    def globalgetvar(self, *args, **kwargs): ...
+    def globalsetvar(self, *args, **kwargs): ...
+    def globalunsetvar(self, *args, **kwargs): ...
+    def interpaddr(self): ...
+    def loadtk(self) -> None: ...
+    def mainloop(self, __threshold: int = 0): ...
+    def quit(self): ...
+    def record(self, __script): ...
+    def setvar(self, *ags, **kwargs): ...
+    if sys.version_info < (3, 11):
+        def split(self, __arg): ...
+
+    def splitlist(self, __arg): ...
+    def unsetvar(self, *args, **kwargs): ...
+    def wantobjects(self, *args, **kwargs): ...
+    def willdispatch(self): ...
+
+# These should be kept in sync with tkinter.tix constants, except ALL_EVENTS which doesn't match TCL_ALL_EVENTS
+ALL_EVENTS: Literal[-3]
+FILE_EVENTS: Literal[8]
+IDLE_EVENTS: Literal[32]
+TIMER_EVENTS: Literal[16]
+WINDOW_EVENTS: Literal[4]
+
+DONT_WAIT: Literal[2]
+EXCEPTION: Literal[8]
+READABLE: Literal[2]
+WRITABLE: Literal[4]
+
+TCL_VERSION: str
+TK_VERSION: str
+
+@final
+class TkttType:
+    def deletetimerhandler(self): ...
+
+def create(
+    __screenName: str | None = None,
+    __baseName: str = "",
+    __className: str = "Tk",
+    __interactive: bool = False,
+    __wantobjects: bool = False,
+    __wantTk: bool = True,
+    __sync: bool = False,
+    __use: str | None = None,
+): ...
+def getbusywaitinterval(): ...
+def setbusywaitinterval(__new_val): ...

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

@@ -0,0 +1,17 @@
+import sys
+from collections.abc import Sequence
+from tracemalloc import _FrameTuple, _TraceTuple
+
+def _get_object_traceback(__obj: object) -> Sequence[_FrameTuple] | None: ...
+def _get_traces() -> Sequence[_TraceTuple]: ...
+def clear_traces() -> None: ...
+def get_traceback_limit() -> int: ...
+def get_traced_memory() -> tuple[int, int]: ...
+def get_tracemalloc_memory() -> int: ...
+def is_tracing() -> bool: ...
+
+if sys.version_info >= (3, 9):
+    def reset_peak() -> None: ...
+
+def start(__nframe: int = 1) -> None: ...
+def stop() -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/_typeshed/README.md

@@ -0,0 +1,34 @@
+# Utility types for typeshed
+
+This package and its submodules contains various common types used by
+typeshed. It can also be used by packages outside typeshed, but beware
+the API stability guarantees below.
+
+## Usage
+
+The `_typeshed` package and its types do not exist at runtime, but can be
+used freely in stubs (`.pyi`) files. To import the types from this package in
+implementation (`.py`) files, use the following construct:
+
+```python
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from _typeshed import ...
+```
+
+Types can then be used in annotations by either quoting them or
+using:
+
+```python
+from __future__ import annotations
+```
+
+## API Stability
+
+You can use this package and its submodules outside of typeshed, but we
+guarantee only limited API stability. Items marked as "stable" will not be
+removed or changed in an incompatible way for at least one year.
+Before making such a change, the "stable" moniker will be removed
+and we will mark the type in question as deprecated. No guarantees
+are made about unmarked types.