layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/logging/config.pyi

@@ -0,0 +1,141 @@
+import sys
+from _typeshed import StrOrBytesPath
+from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence
+from configparser import RawConfigParser
+from re import Pattern
+from threading import Thread
+from typing import IO, Any, Final, Literal, SupportsIndex, TypeAlias, TypedDict, overload, type_check_only
+from typing_extensions import Required, disjoint_base
+
+from . import Filter, Filterer, Formatter, Handler, Logger, _FilterType, _FormatStyle, _Level
+
+DEFAULT_LOGGING_CONFIG_PORT: Final = 9030
+RESET_ERROR: Final[int]  # undocumented
+IDENTIFIER: Final[Pattern[str]]  # undocumented
+
+if sys.version_info >= (3, 11):
+    @type_check_only
+    class _RootLoggerConfiguration(TypedDict, total=False):
+        level: _Level
+        filters: Sequence[str | _FilterType]
+        handlers: Sequence[str]
+
+else:
+    @type_check_only
+    class _RootLoggerConfiguration(TypedDict, total=False):
+        level: _Level
+        filters: Sequence[str]
+        handlers: Sequence[str]
+
+@type_check_only
+class _LoggerConfiguration(_RootLoggerConfiguration, TypedDict, total=False):
+    propagate: bool
+
+_FormatterConfigurationTypedDict = TypedDict(
+    "_FormatterConfigurationTypedDict", {"class": str, "format": str, "datefmt": str, "style": _FormatStyle}, total=False
+)
+
+@type_check_only
+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]
+
+@type_check_only
+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: ...
+def fileConfig(
+    fname: StrOrBytesPath | IO[str] | RawConfigParser,
+    defaults: Mapping[str, str] | None = None,
+    disable_existing_loggers: bool = True,
+    encoding: str | None = None,
+) -> 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[SupportsIndex | None]) -> Any: ...
+
+    def pop(self, idx: SupportsIndex = -1) -> Any: ...
+
+if sys.version_info >= (3, 12):
+    class ConvertingTuple(tuple[Any, ...], ConvertingMixin):  # undocumented
+        @overload
+        def __getitem__(self, key: SupportsIndex) -> Any: ...
+        @overload
+        def __getitem__(self, key: slice[SupportsIndex | None]) -> Any: ...
+
+else:
+    @disjoint_base
+    class ConvertingTuple(tuple[Any, ...], ConvertingMixin):  # undocumented
+        @overload
+        def __getitem__(self, key: SupportsIndex) -> Any: ...
+        @overload
+        def __getitem__(self, key: slice[SupportsIndex | None]) -> Any: ...
+
+class BaseConfigurator:
+    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]
+
+    config: dict[str, Any]  # undocumented
+
+    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

package/analyzers/project-map-python/typeshed/stdlib/logging/handlers.pyi

@@ -0,0 +1,258 @@
+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 types import TracebackType
+from typing import Any, ClassVar, Final, Protocol, TypeVar, type_check_only
+from typing_extensions import Self
+
+_T = TypeVar("_T")
+
+DEFAULT_TCP_LOGGING_PORT: Final = 9020
+DEFAULT_UDP_LOGGING_PORT: Final = 9021
+DEFAULT_HTTP_LOGGING_PORT: Final = 9022
+DEFAULT_SOAP_LOGGING_PORT: Final = 9023
+SYSLOG_UDP_PORT: Final = 514
+SYSLOG_TCP_PORT: Final = 514
+
+class WatchedFileHandler(FileHandler):
+    dev: int  # undocumented
+    ino: int  # undocumented
+    def __init__(
+        self, filename: StrPath, mode: str = "a", encoding: str | None = None, delay: bool = False, errors: str | None = None
+    ) -> None: ...
+    def _statstream(self) -> None: ...  # undocumented
+    def reopenIfNeeded(self) -> None: ...
+
+class BaseRotatingHandler(FileHandler):
+    namer: Callable[[str], str] | None
+    rotator: Callable[[str, str], None] | None
+    def __init__(
+        self, filename: StrPath, mode: str, encoding: str | None = None, delay: bool = False, errors: str | None = None
+    ) -> None: ...
+    def rotation_filename(self, default_name: str) -> str: ...
+    def rotate(self, source: str, dest: str) -> None: ...
+
+class RotatingFileHandler(BaseRotatingHandler):
+    maxBytes: int  # undocumented
+    backupCount: int  # undocumented
+    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: ...
+    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
+    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: ...
+    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
+    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
+    if sys.version_info >= (3, 14):
+        timeout: float | None
+        def __init__(
+            self,
+            address: tuple[str, int] | str = ("localhost", 514),
+            facility: str | int = 1,
+            socktype: SocketKind | None = None,
+            timeout: float | None = None,
+        ) -> None: ...
+    else:
+        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]: ...
+    def getConnection(self, host: str, secure: bool) -> http.client.HTTPConnection: ...  # undocumented
+
+@type_check_only
+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: ...
+    if sys.version_info >= (3, 12):
+        listener: QueueListener | 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: ...
+
+    if sys.version_info >= (3, 14):
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
+        ) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/lzma.pyi

@@ -0,0 +1,181 @@
+import sys
+from _lzma import (
+    CHECK_CRC32 as CHECK_CRC32,
+    CHECK_CRC64 as CHECK_CRC64,
+    CHECK_ID_MAX as CHECK_ID_MAX,
+    CHECK_NONE as CHECK_NONE,
+    CHECK_SHA256 as CHECK_SHA256,
+    CHECK_UNKNOWN as CHECK_UNKNOWN,
+    FILTER_ARM as FILTER_ARM,
+    FILTER_ARMTHUMB as FILTER_ARMTHUMB,
+    FILTER_DELTA as FILTER_DELTA,
+    FILTER_IA64 as FILTER_IA64,
+    FILTER_LZMA1 as FILTER_LZMA1,
+    FILTER_LZMA2 as FILTER_LZMA2,
+    FILTER_POWERPC as FILTER_POWERPC,
+    FILTER_SPARC as FILTER_SPARC,
+    FILTER_X86 as FILTER_X86,
+    FORMAT_ALONE as FORMAT_ALONE,
+    FORMAT_AUTO as FORMAT_AUTO,
+    FORMAT_RAW as FORMAT_RAW,
+    FORMAT_XZ as FORMAT_XZ,
+    MF_BT2 as MF_BT2,
+    MF_BT3 as MF_BT3,
+    MF_BT4 as MF_BT4,
+    MF_HC3 as MF_HC3,
+    MF_HC4 as MF_HC4,
+    MODE_FAST as MODE_FAST,
+    MODE_NORMAL as MODE_NORMAL,
+    PRESET_DEFAULT as PRESET_DEFAULT,
+    PRESET_EXTREME as PRESET_EXTREME,
+    LZMACompressor as LZMACompressor,
+    LZMADecompressor as LZMADecompressor,
+    LZMAError as LZMAError,
+    _FilterChain,
+    is_check_supported as is_check_supported,
+)
+from _typeshed import ReadableBuffer, StrOrBytesPath
+from io import TextIOWrapper
+from typing import IO, Literal, TypeAlias, overload
+from typing_extensions import Self
+
+if sys.version_info >= (3, 14):
+    from compression._common._streams import BaseStream
+else:
+    from _compression import BaseStream
+
+__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]
+
+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,
+) -> TextIOWrapper: ...
+@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,
+) -> TextIOWrapper: ...
+@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 | TextIOWrapper: ...
+
+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: ...