jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

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

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

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

@@ -1,197 +0,0 @@
-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: ...