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

jaclang/vendor/mypy/typeshed/stdlib/logging/config.pyi

@@ -0,0 +1,161 @@
+import sys
+from _typeshed import StrOrBytesPath
+from collections.abc import Callable, Hashable, Iterable, Sequence
+from configparser import RawConfigParser
+from re import Pattern
+from threading import Thread
+from typing import IO, Any, Literal, SupportsIndex, TypedDict, overload
+from typing_extensions import Required, TypeAlias
+
+from . import (
+    Filter,
+    Filterer,
+    Formatter,
+    Handler,
+    Logger,
+    _FilterType,
+    _FormatStyle,
+    _Level,
+)
+
+DEFAULT_LOGGING_CONFIG_PORT: int
+RESET_ERROR: int  # undocumented
+IDENTIFIER: Pattern[str]  # undocumented
+
+if sys.version_info >= (3, 11):
+    class _RootLoggerConfiguration(TypedDict, total=False):
+        level: _Level
+        filters: Sequence[str | _FilterType]
+        handlers: Sequence[str]
+
+else:
+    class _RootLoggerConfiguration(TypedDict, total=False):
+        level: _Level
+        filters: Sequence[str]
+        handlers: Sequence[str]
+
+class _LoggerConfiguration(_RootLoggerConfiguration, TypedDict, total=False):
+    propagate: bool
+
+_FormatterConfigurationTypedDict = TypedDict(
+    "_FormatterConfigurationTypedDict",
+    {"class": str, "format": str, "datefmt": str, "style": _FormatStyle},
+    total=False,
+)
+
+class _FilterConfigurationTypedDict(TypedDict):
+    name: str
+
+# Formatter and filter configs can specify custom factories via the special `()` key.
+# If that is the case, the dictionary can contain any additional keys
+# https://docs.python.org/3/library/logging.config.html#user-defined-objects
+_FormatterConfiguration: TypeAlias = _FormatterConfigurationTypedDict | dict[str, Any]
+_FilterConfiguration: TypeAlias = _FilterConfigurationTypedDict | dict[str, Any]
+# Handler config can have additional keys even when not providing a custom factory so we just use `dict`.
+_HandlerConfiguration: TypeAlias = dict[str, Any]
+
+class _DictConfigArgs(TypedDict, total=False):
+    version: Required[Literal[1]]
+    formatters: dict[str, _FormatterConfiguration]
+    filters: dict[str, _FilterConfiguration]
+    handlers: dict[str, _HandlerConfiguration]
+    loggers: dict[str, _LoggerConfiguration]
+    root: _RootLoggerConfiguration
+    incremental: bool
+    disable_existing_loggers: bool
+
+# Accept dict[str, Any] to avoid false positives if called with a dict
+# type, since dict types are not compatible with TypedDicts.
+#
+# Also accept a TypedDict type, to allow callers to use TypedDict
+# types, and for somewhat stricter type checking of dict literals.
+def dictConfig(config: _DictConfigArgs | dict[str, Any]) -> None: ...
+
+if sys.version_info >= (3, 10):
+    def fileConfig(
+        fname: StrOrBytesPath | IO[str] | RawConfigParser,
+        defaults: dict[str, str] | None = None,
+        disable_existing_loggers: bool = True,
+        encoding: str | None = None,
+    ) -> None: ...
+
+else:
+    def fileConfig(
+        fname: StrOrBytesPath | IO[str] | RawConfigParser,
+        defaults: dict[str, str] | None = None,
+        disable_existing_loggers: bool = True,
+    ) -> None: ...
+
+def valid_ident(s: str) -> Literal[True]: ...  # undocumented
+def listen(
+    port: int = 9030, verify: Callable[[bytes], bytes | None] | None = None
+) -> Thread: ...
+def stopListening() -> None: ...
+
+class ConvertingMixin:  # undocumented
+    def convert_with_key(self, key: Any, value: Any, replace: bool = True) -> Any: ...
+    def convert(self, value: Any) -> Any: ...
+
+class ConvertingDict(dict[Hashable, Any], ConvertingMixin):  # undocumented
+    def __getitem__(self, key: Hashable) -> Any: ...
+    def get(self, key: Hashable, default: Any = None) -> Any: ...
+    def pop(self, key: Hashable, default: Any = None) -> Any: ...
+
+class ConvertingList(list[Any], ConvertingMixin):  # undocumented
+    @overload
+    def __getitem__(self, key: SupportsIndex) -> Any: ...
+    @overload
+    def __getitem__(self, key: slice) -> Any: ...
+    def pop(self, idx: SupportsIndex = -1) -> Any: ...
+
+class ConvertingTuple(tuple[Any, ...], ConvertingMixin):  # undocumented
+    @overload
+    def __getitem__(self, key: SupportsIndex) -> Any: ...
+    @overload
+    def __getitem__(self, key: slice) -> Any: ...
+
+class BaseConfigurator:  # undocumented
+    CONVERT_PATTERN: Pattern[str]
+    WORD_PATTERN: Pattern[str]
+    DOT_PATTERN: Pattern[str]
+    INDEX_PATTERN: Pattern[str]
+    DIGIT_PATTERN: Pattern[str]
+    value_converters: dict[str, str]
+    importer: Callable[..., Any]
+
+    def __init__(self, config: _DictConfigArgs | dict[str, Any]) -> None: ...
+    def resolve(self, s: str) -> Any: ...
+    def ext_convert(self, value: str) -> Any: ...
+    def cfg_convert(self, value: str) -> Any: ...
+    def convert(self, value: Any) -> Any: ...
+    def configure_custom(self, config: dict[str, Any]) -> Any: ...
+    def as_tuple(self, value: list[Any] | tuple[Any]) -> tuple[Any]: ...
+
+class DictConfigurator(BaseConfigurator):
+    def configure(self) -> None: ...  # undocumented
+    def configure_formatter(
+        self, config: _FormatterConfiguration
+    ) -> Formatter | Any: ...  # undocumented
+    def configure_filter(
+        self, config: _FilterConfiguration
+    ) -> Filter | Any: ...  # undocumented
+    def add_filters(
+        self, filterer: Filterer, filters: Iterable[_FilterType]
+    ) -> None: ...  # undocumented
+    def configure_handler(
+        self, config: _HandlerConfiguration
+    ) -> Handler | Any: ...  # undocumented
+    def add_handlers(
+        self, logger: Logger, handlers: Iterable[str]
+    ) -> None: ...  # undocumented
+    def common_logger_config(
+        self, logger: Logger, config: _LoggerConfiguration, incremental: bool = False
+    ) -> None: ...  # undocumented
+    def configure_logger(
+        self, name: str, config: _LoggerConfiguration, incremental: bool = False
+    ) -> None: ...  # undocumented
+    def configure_root(
+        self, config: _LoggerConfiguration, incremental: bool = False
+    ) -> None: ...  # undocumented
+
+dictConfigClass = DictConfigurator

jaclang/vendor/mypy/typeshed/stdlib/logging/handlers.pyi

@@ -0,0 +1,315 @@
+import datetime
+import http.client
+import ssl
+import sys
+from _typeshed import ReadableBuffer, StrPath
+from collections.abc import Callable
+from logging import FileHandler, Handler, LogRecord
+from re import Pattern
+from socket import SocketKind, socket
+from threading import Thread
+from typing import Any, ClassVar, Protocol, TypeVar
+
+_T = TypeVar("_T")
+
+DEFAULT_TCP_LOGGING_PORT: int
+DEFAULT_UDP_LOGGING_PORT: int
+DEFAULT_HTTP_LOGGING_PORT: int
+DEFAULT_SOAP_LOGGING_PORT: int
+SYSLOG_UDP_PORT: int
+SYSLOG_TCP_PORT: int
+
+class WatchedFileHandler(FileHandler):
+    dev: int  # undocumented
+    ino: int  # undocumented
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            filename: StrPath,
+            mode: str = "a",
+            encoding: str | None = None,
+            delay: bool = False,
+            errors: str | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            filename: StrPath,
+            mode: str = "a",
+            encoding: str | None = None,
+            delay: bool = False,
+        ) -> None: ...
+
+    def _statstream(self) -> None: ...  # undocumented
+    def reopenIfNeeded(self) -> None: ...
+
+class BaseRotatingHandler(FileHandler):
+    namer: Callable[[str], str] | None
+    rotator: Callable[[str, str], None] | None
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            filename: StrPath,
+            mode: str,
+            encoding: str | None = None,
+            delay: bool = False,
+            errors: str | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            filename: StrPath,
+            mode: str,
+            encoding: str | None = None,
+            delay: bool = False,
+        ) -> None: ...
+
+    def rotation_filename(self, default_name: str) -> str: ...
+    def rotate(self, source: str, dest: str) -> None: ...
+
+class RotatingFileHandler(BaseRotatingHandler):
+    maxBytes: str  # undocumented
+    backupCount: int  # undocumented
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            filename: StrPath,
+            mode: str = "a",
+            maxBytes: int = 0,
+            backupCount: int = 0,
+            encoding: str | None = None,
+            delay: bool = False,
+            errors: str | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            filename: StrPath,
+            mode: str = "a",
+            maxBytes: int = 0,
+            backupCount: int = 0,
+            encoding: str | None = None,
+            delay: bool = False,
+        ) -> None: ...
+
+    def doRollover(self) -> None: ...
+    def shouldRollover(self, record: LogRecord) -> int: ...  # undocumented
+
+class TimedRotatingFileHandler(BaseRotatingHandler):
+    when: str  # undocumented
+    backupCount: int  # undocumented
+    utc: bool  # undocumented
+    atTime: datetime.time | None  # undocumented
+    interval: int  # undocumented
+    suffix: str  # undocumented
+    dayOfWeek: int  # undocumented
+    rolloverAt: int  # undocumented
+    extMatch: Pattern[str]  # undocumented
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            filename: StrPath,
+            when: str = "h",
+            interval: int = 1,
+            backupCount: int = 0,
+            encoding: str | None = None,
+            delay: bool = False,
+            utc: bool = False,
+            atTime: datetime.time | None = None,
+            errors: str | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            filename: StrPath,
+            when: str = "h",
+            interval: int = 1,
+            backupCount: int = 0,
+            encoding: str | None = None,
+            delay: bool = False,
+            utc: bool = False,
+            atTime: datetime.time | None = None,
+        ) -> None: ...
+
+    def doRollover(self) -> None: ...
+    def shouldRollover(self, record: LogRecord) -> int: ...  # undocumented
+    def computeRollover(self, currentTime: int) -> int: ...  # undocumented
+    def getFilesToDelete(self) -> list[str]: ...  # undocumented
+
+class SocketHandler(Handler):
+    host: str  # undocumented
+    port: int | None  # undocumented
+    address: tuple[str, int] | str  # undocumented
+    sock: socket | None  # undocumented
+    closeOnError: bool  # undocumented
+    retryTime: float | None  # undocumented
+    retryStart: float  # undocumented
+    retryFactor: float  # undocumented
+    retryMax: float  # undocumented
+    def __init__(self, host: str, port: int | None) -> None: ...
+    def makeSocket(self, timeout: float = 1) -> socket: ...  # timeout is undocumented
+    def makePickle(self, record: LogRecord) -> bytes: ...
+    def send(self, s: ReadableBuffer) -> None: ...
+    def createSocket(self) -> None: ...
+
+class DatagramHandler(SocketHandler):
+    def makeSocket(self) -> socket: ...  # type: ignore[override]
+
+class SysLogHandler(Handler):
+    LOG_EMERG: int
+    LOG_ALERT: int
+    LOG_CRIT: int
+    LOG_ERR: int
+    LOG_WARNING: int
+    LOG_NOTICE: int
+    LOG_INFO: int
+    LOG_DEBUG: int
+
+    LOG_KERN: int
+    LOG_USER: int
+    LOG_MAIL: int
+    LOG_DAEMON: int
+    LOG_AUTH: int
+    LOG_SYSLOG: int
+    LOG_LPR: int
+    LOG_NEWS: int
+    LOG_UUCP: int
+    LOG_CRON: int
+    LOG_AUTHPRIV: int
+    LOG_FTP: int
+
+    if sys.version_info >= (3, 9):
+        LOG_NTP: int
+        LOG_SECURITY: int
+        LOG_CONSOLE: int
+        LOG_SOLCRON: int
+
+    LOG_LOCAL0: int
+    LOG_LOCAL1: int
+    LOG_LOCAL2: int
+    LOG_LOCAL3: int
+    LOG_LOCAL4: int
+    LOG_LOCAL5: int
+    LOG_LOCAL6: int
+    LOG_LOCAL7: int
+    address: tuple[str, int] | str  # undocumented
+    unixsocket: bool  # undocumented
+    socktype: SocketKind  # undocumented
+    ident: str  # undocumented
+    append_nul: bool  # undocumented
+    facility: int  # undocumented
+    priority_names: ClassVar[dict[str, int]]  # undocumented
+    facility_names: ClassVar[dict[str, int]]  # undocumented
+    priority_map: ClassVar[dict[str, str]]  # undocumented
+    def __init__(
+        self,
+        address: tuple[str, int] | str = ("localhost", 514),
+        facility: str | int = 1,
+        socktype: SocketKind | None = None,
+    ) -> None: ...
+    if sys.version_info >= (3, 11):
+        def createSocket(self) -> None: ...
+
+    def encodePriority(self, facility: int | str, priority: int | str) -> int: ...
+    def mapPriority(self, levelName: str) -> str: ...
+
+class NTEventLogHandler(Handler):
+    def __init__(
+        self, appname: str, dllname: str | None = None, logtype: str = "Application"
+    ) -> None: ...
+    def getEventCategory(self, record: LogRecord) -> int: ...
+    # TODO correct return value?
+    def getEventType(self, record: LogRecord) -> int: ...
+    def getMessageID(self, record: LogRecord) -> int: ...
+
+class SMTPHandler(Handler):
+    mailhost: str  # undocumented
+    mailport: int | None  # undocumented
+    username: str | None  # undocumented
+    # password only exists as an attribute if passed credentials is a tuple or list
+    password: str  # undocumented
+    fromaddr: str  # undocumented
+    toaddrs: list[str]  # undocumented
+    subject: str  # undocumented
+    secure: tuple[()] | tuple[str] | tuple[str, str] | None  # undocumented
+    timeout: float  # undocumented
+    def __init__(
+        self,
+        mailhost: str | tuple[str, int],
+        fromaddr: str,
+        toaddrs: str | list[str],
+        subject: str,
+        credentials: tuple[str, str] | None = None,
+        secure: tuple[()] | tuple[str] | tuple[str, str] | None = None,
+        timeout: float = 5.0,
+    ) -> None: ...
+    def getSubject(self, record: LogRecord) -> str: ...
+
+class BufferingHandler(Handler):
+    capacity: int  # undocumented
+    buffer: list[LogRecord]  # undocumented
+    def __init__(self, capacity: int) -> None: ...
+    def shouldFlush(self, record: LogRecord) -> bool: ...
+
+class MemoryHandler(BufferingHandler):
+    flushLevel: int  # undocumented
+    target: Handler | None  # undocumented
+    flushOnClose: bool  # undocumented
+    def __init__(
+        self,
+        capacity: int,
+        flushLevel: int = 40,
+        target: Handler | None = None,
+        flushOnClose: bool = True,
+    ) -> None: ...
+    def setTarget(self, target: Handler | None) -> None: ...
+
+class HTTPHandler(Handler):
+    host: str  # undocumented
+    url: str  # undocumented
+    method: str  # undocumented
+    secure: bool  # undocumented
+    credentials: tuple[str, str] | None  # undocumented
+    context: ssl.SSLContext | None  # undocumented
+    def __init__(
+        self,
+        host: str,
+        url: str,
+        method: str = "GET",
+        secure: bool = False,
+        credentials: tuple[str, str] | None = None,
+        context: ssl.SSLContext | None = None,
+    ) -> None: ...
+    def mapLogRecord(self, record: LogRecord) -> dict[str, Any]: ...
+    if sys.version_info >= (3, 9):
+        def getConnection(
+            self, host: str, secure: bool
+        ) -> http.client.HTTPConnection: ...  # undocumented
+
+class _QueueLike(Protocol[_T]):
+    def get(self) -> _T: ...
+    def put_nowait(self, __item: _T) -> None: ...
+
+class QueueHandler(Handler):
+    queue: _QueueLike[Any]
+    def __init__(self, queue: _QueueLike[Any]) -> None: ...
+    def prepare(self, record: LogRecord) -> Any: ...
+    def enqueue(self, record: LogRecord) -> None: ...
+
+class QueueListener:
+    handlers: tuple[Handler, ...]  # undocumented
+    respect_handler_level: bool  # undocumented
+    queue: _QueueLike[Any]  # undocumented
+    _thread: Thread | None  # undocumented
+    def __init__(
+        self,
+        queue: _QueueLike[Any],
+        *handlers: Handler,
+        respect_handler_level: bool = False
+    ) -> None: ...
+    def dequeue(self, block: bool) -> LogRecord: ...
+    def prepare(self, record: LogRecord) -> Any: ...
+    def start(self) -> None: ...
+    def stop(self) -> None: ...
+    def enqueue_sentinel(self) -> None: ...
+    def handle(self, record: LogRecord) -> None: ...

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

@@ -0,0 +1,213 @@
+from _compression import BaseStream
+from _typeshed import ReadableBuffer, StrOrBytesPath
+from collections.abc import Mapping, Sequence
+from typing import IO, Any, Literal, TextIO, final, overload
+from typing_extensions import Self, TypeAlias
+
+__all__ = [
+    "CHECK_NONE",
+    "CHECK_CRC32",
+    "CHECK_CRC64",
+    "CHECK_SHA256",
+    "CHECK_ID_MAX",
+    "CHECK_UNKNOWN",
+    "FILTER_LZMA1",
+    "FILTER_LZMA2",
+    "FILTER_DELTA",
+    "FILTER_X86",
+    "FILTER_IA64",
+    "FILTER_ARM",
+    "FILTER_ARMTHUMB",
+    "FILTER_POWERPC",
+    "FILTER_SPARC",
+    "FORMAT_AUTO",
+    "FORMAT_XZ",
+    "FORMAT_ALONE",
+    "FORMAT_RAW",
+    "MF_HC3",
+    "MF_HC4",
+    "MF_BT2",
+    "MF_BT3",
+    "MF_BT4",
+    "MODE_FAST",
+    "MODE_NORMAL",
+    "PRESET_DEFAULT",
+    "PRESET_EXTREME",
+    "LZMACompressor",
+    "LZMADecompressor",
+    "LZMAFile",
+    "LZMAError",
+    "open",
+    "compress",
+    "decompress",
+    "is_check_supported",
+]
+
+_OpenBinaryWritingMode: TypeAlias = Literal["w", "wb", "x", "xb", "a", "ab"]
+_OpenTextWritingMode: TypeAlias = Literal["wt", "xt", "at"]
+
+_PathOrFile: TypeAlias = StrOrBytesPath | IO[bytes]
+
+_FilterChain: TypeAlias = Sequence[Mapping[str, Any]]
+
+FORMAT_AUTO: Literal[0]
+FORMAT_XZ: Literal[1]
+FORMAT_ALONE: Literal[2]
+FORMAT_RAW: Literal[3]
+CHECK_NONE: Literal[0]
+CHECK_CRC32: Literal[1]
+CHECK_CRC64: Literal[4]
+CHECK_SHA256: Literal[10]
+CHECK_ID_MAX: Literal[15]
+CHECK_UNKNOWN: Literal[16]
+FILTER_LZMA1: int  # v big number
+FILTER_LZMA2: Literal[33]
+FILTER_DELTA: Literal[3]
+FILTER_X86: Literal[4]
+FILTER_IA64: Literal[6]
+FILTER_ARM: Literal[7]
+FILTER_ARMTHUMB: Literal[8]
+FILTER_SPARC: Literal[9]
+FILTER_POWERPC: Literal[5]
+MF_HC3: Literal[3]
+MF_HC4: Literal[4]
+MF_BT2: Literal[18]
+MF_BT3: Literal[19]
+MF_BT4: Literal[20]
+MODE_FAST: Literal[1]
+MODE_NORMAL: Literal[2]
+PRESET_DEFAULT: Literal[6]
+PRESET_EXTREME: int  # v big number
+
+# from _lzma.c
+@final
+class LZMADecompressor:
+    def __init__(
+        self,
+        format: int | None = ...,
+        memlimit: int | None = ...,
+        filters: _FilterChain | None = ...,
+    ) -> None: ...
+    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
+    @property
+    def check(self) -> int: ...
+    @property
+    def eof(self) -> bool: ...
+    @property
+    def unused_data(self) -> bytes: ...
+    @property
+    def needs_input(self) -> bool: ...
+
+# from _lzma.c
+@final
+class LZMACompressor:
+    def __init__(
+        self,
+        format: int | None = ...,
+        check: int = ...,
+        preset: int | None = ...,
+        filters: _FilterChain | None = ...,
+    ) -> None: ...
+    def compress(self, __data: ReadableBuffer) -> bytes: ...
+    def flush(self) -> bytes: ...
+
+class LZMAError(Exception): ...
+
+class LZMAFile(BaseStream, IO[bytes]):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
+    def __init__(
+        self,
+        filename: _PathOrFile | None = None,
+        mode: str = "r",
+        *,
+        format: int | None = None,
+        check: int = -1,
+        preset: int | None = None,
+        filters: _FilterChain | None = None,
+    ) -> None: ...
+    def __enter__(self) -> Self: ...
+    def peek(self, size: int = -1) -> bytes: ...
+    def read(self, size: int | None = -1) -> bytes: ...
+    def read1(self, size: int = -1) -> bytes: ...
+    def readline(self, size: int | None = -1) -> bytes: ...
+    def write(self, data: ReadableBuffer) -> int: ...
+    def seek(self, offset: int, whence: int = 0) -> int: ...
+
+@overload
+def open(
+    filename: _PathOrFile,
+    mode: Literal["r", "rb"] = "rb",
+    *,
+    format: int | None = None,
+    check: Literal[-1] = -1,
+    preset: None = None,
+    filters: _FilterChain | None = None,
+    encoding: None = None,
+    errors: None = None,
+    newline: None = None,
+) -> LZMAFile: ...
+@overload
+def open(
+    filename: _PathOrFile,
+    mode: _OpenBinaryWritingMode,
+    *,
+    format: int | None = None,
+    check: int = -1,
+    preset: int | None = None,
+    filters: _FilterChain | None = None,
+    encoding: None = None,
+    errors: None = None,
+    newline: None = None,
+) -> LZMAFile: ...
+@overload
+def open(
+    filename: StrOrBytesPath,
+    mode: Literal["rt"],
+    *,
+    format: int | None = None,
+    check: Literal[-1] = -1,
+    preset: None = None,
+    filters: _FilterChain | None = None,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+) -> TextIO: ...
+@overload
+def open(
+    filename: StrOrBytesPath,
+    mode: _OpenTextWritingMode,
+    *,
+    format: int | None = None,
+    check: int = -1,
+    preset: int | None = None,
+    filters: _FilterChain | None = None,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+) -> TextIO: ...
+@overload
+def open(
+    filename: _PathOrFile,
+    mode: str,
+    *,
+    format: int | None = None,
+    check: int = -1,
+    preset: int | None = None,
+    filters: _FilterChain | None = None,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+) -> LZMAFile | TextIO: ...
+def compress(
+    data: ReadableBuffer,
+    format: int = 1,
+    check: int = -1,
+    preset: int | None = None,
+    filters: _FilterChain | None = None,
+) -> bytes: ...
+def decompress(
+    data: ReadableBuffer,
+    format: int = 0,
+    memlimit: int | None = None,
+    filters: _FilterChain | None = None,
+) -> bytes: ...
+def is_check_supported(__check_id: int) -> bool: ...