basedpyright 1.31.5 → 1.31.6

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/debug.pyi

@@ -0,0 +1,18 @@
+__all__ = ["spew", "unspew"]
+
+from collections.abc import Container
+from types import FrameType
+from typing import Any
+from typing_extensions import Self
+
+class Spew:
+    trace_names: Container[str] | None = None
+    show_values: bool
+
+    def __init__(self, trace_names: Container[str] | None = None, show_values: bool = True) -> None: ...
+    def __call__(
+        self, frame: FrameType, event: str, arg: Any  # `arg` is not used inside the function, stub is set Any
+    ) -> Self: ...
+
+def spew(trace_names: Container[str] | None = None, show_values: bool = False) -> None: ...
+def unspew() -> None: ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/errors.pyi

@@ -0,0 +1,8 @@
+class HaltServer(BaseException):
+    reason: str
+    exit_status: int
+
+    def __init__(self, reason: str, exit_status: int = 1) -> None: ...
+
+class ConfigError(Exception): ...
+class AppImportError(Exception): ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/glogging.pyi

@@ -0,0 +1,158 @@
+import logging
+import threading
+from collections.abc import Mapping
+from datetime import timedelta
+from logging.config import _DictConfigArgs
+from socket import SocketKind
+from typing import Annotated, Any, ClassVar, Literal, TypedDict, type_check_only
+from typing_extensions import TypeAlias, override
+
+from gunicorn.http import Request
+from gunicorn.http.wsgi import Response
+
+from ._types import _EnvironType
+from .config import Config
+
+SYSLOG_FACILITIES: dict[str, int]
+
+@type_check_only
+class _AtomsDict(TypedDict, total=False):
+    h: str
+    l: str
+    u: str
+    t: str
+    r: str
+    s: str
+    m: str | None
+    U: str | None
+    q: str | None
+    H: str | None
+    b: str
+    B: int | None
+    f: str
+    a: str
+    T: int
+    D: int
+    M: int
+    L: str
+    p: str
+
+_CriticalIntType: TypeAlias = Annotated[int, "50"]
+_ErrorIntType: TypeAlias = Annotated[int, "40"]
+_WarningIntType: TypeAlias = Annotated[int, "30"]
+_InfoIntType: TypeAlias = Annotated[int, "20"]
+_DebugIntType: TypeAlias = Annotated[int, "10"]
+_LogLevelIntType: TypeAlias = _CriticalIntType | _ErrorIntType | _WarningIntType | _InfoIntType | _DebugIntType
+_LogLevelStrType: TypeAlias = Literal["critical", "error", "warning", "info", "debug"]
+_LogLevelType: TypeAlias = _LogLevelIntType | _LogLevelStrType
+
+CONFIG_DEFAULTS: _DictConfigArgs
+
+def loggers() -> list[logging.Logger]: ...
+
+class SafeAtoms(dict[str, Any]):
+    def __init__(self, atoms: dict[str, Any]) -> None: ...
+    @override
+    def __getitem__(self, k: str) -> str: ...
+
+_SyslogAddressType: TypeAlias = (
+    tuple[Literal[SocketKind.SOCK_DGRAM] | None, str]  # Unix Socket
+    | tuple[Literal[SocketKind.SOCK_DGRAM, SocketKind.SOCK_STREAM], tuple[str, int]]  # TCP/UDP Socket
+)
+
+def parse_syslog_address(addr: str) -> _SyslogAddressType: ...
+@type_check_only
+class _LogLevels(TypedDict):
+    critical: _CriticalIntType
+    error: _ErrorIntType
+    warning: _WarningIntType
+    info: _InfoIntType
+    debug: _DebugIntType
+
+class Logger:
+    LOG_LEVELS: ClassVar[_LogLevels]
+    loglevel: ClassVar[_LogLevelIntType]
+    error_fmt: ClassVar[str]
+    datefmt: ClassVar[str]
+    access_fmt: ClassVar[str]
+    syslog_fmt: ClassVar[str]
+    atoms_wrapper_class: ClassVar[type[SafeAtoms]]
+    error_log: logging.Logger
+    access_log: logging.Logger
+    error_handlers: list[logging.Handler]
+    access_handlers: list[logging.Handler]
+    logfile: Any | None
+    lock: threading.Lock
+    cfg: Config
+
+    def __init__(self, cfg: Config) -> None: ...
+    def setup(self, cfg: Config) -> None: ...
+    def critical(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def error(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def warning(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def info(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def debug(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def exception(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = True,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def log(
+        self,
+        lvl: _LogLevelType,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def atoms(self, resp: Response, req: Request, environ: _EnvironType, request_time: timedelta) -> _AtomsDict: ...
+    def access(self, resp: Response, req: Request, environ: _EnvironType, request_time: timedelta) -> None: ...
+    def now(self) -> str: ...
+    def reopen_files(self) -> None: ...
+    def close_on_exec(self) -> None: ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/http/__init__.pyi

@@ -0,0 +1,4 @@
+from gunicorn.http.message import Message as Message, Request as Request
+from gunicorn.http.parser import RequestParser as RequestParser
+
+__all__ = ["Message", "Request", "RequestParser"]

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/http/body.pyi

@@ -0,0 +1,48 @@
+import io
+from collections.abc import Callable, Generator, Iterator
+from typing_extensions import TypeAlias
+
+from gunicorn.http.message import Request
+from gunicorn.http.unreader import Unreader
+
+class ChunkedReader:
+    req: Request
+    parser: Generator[bytes, None, None] | None
+    buf: io.BytesIO
+
+    def __init__(self, req: Request, unreader: Unreader) -> None: ...
+    def read(self, size: int) -> bytes: ...
+    def parse_trailers(self, unreader: Unreader, data: bytes) -> None: ...
+    def parse_chunked(self, unreader: Unreader) -> Generator[bytes]: ...
+    def parse_chunk_size(self, unreader: Unreader, data: bytes | None = None) -> tuple[int, bytes | None]: ...
+    def get_data(self, unreader: Unreader, buf: io.BytesIO) -> None: ...
+
+class LengthReader:
+    unreader: Unreader
+    length: int
+
+    def __init__(self, unreader: Unreader, length: int) -> None: ...
+    def read(self, size: int) -> bytes: ...
+
+class EOFReader:
+    unreader: Unreader
+    buf: io.BytesIO
+    finished: bool
+
+    def __init__(self, unreader: Unreader) -> None: ...
+    def read(self, size: int) -> bytes: ...
+
+_ReaderType: TypeAlias = ChunkedReader | LengthReader | EOFReader
+
+class Body:
+    reader: _ReaderType
+    buf: io.BytesIO
+
+    def __init__(self, reader: _ReaderType) -> None: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+    def __next__(self) -> bytes: ...
+    next: Callable[[Body], bytes]
+    def getsize(self, size: int | None) -> int: ...
+    def read(self, size: int | None = None) -> bytes: ...
+    def readline(self, size: int | None = None) -> bytes: ...
+    def readlines(self, size: int | None = None) -> list[bytes]: ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/http/errors.pyi

@@ -0,0 +1,89 @@
+from typing_extensions import Buffer
+
+from gunicorn.http import Message
+
+class ParseException(Exception): ...
+
+class NoMoreData(IOError):
+    buf: Buffer
+
+    def __init__(self, buf: Buffer | None = None) -> None: ...
+
+class ConfigurationProblem(ParseException):
+    info: str
+    code: int
+
+    def __init__(self, info: str) -> None: ...
+
+class InvalidRequestLine(ParseException):
+    req: str
+    code: int
+
+    def __init__(self, req: str) -> None: ...
+
+class InvalidRequestMethod(ParseException):
+    method: str
+
+    def __init__(self, method: str) -> None: ...
+
+class InvalidHTTPVersion(ParseException):
+    version: str | tuple[int, int]
+
+    def __init__(self, version: str | tuple[int, int]) -> None: ...
+
+class InvalidHeader(ParseException):
+    hdr: str
+    req: Message | None
+
+    def __init__(self, hdr: str, req: Message | None = None) -> None: ...
+
+class ObsoleteFolding(ParseException):
+    hdr: str
+
+    def __init__(self, hdr: str) -> None: ...
+
+class InvalidHeaderName(ParseException):
+    hdr: str
+
+    def __init__(self, hdr: str) -> None: ...
+
+class UnsupportedTransferCoding(ParseException):
+    hdr: str
+    code: int
+
+    def __init__(self, hdr: str) -> None: ...
+
+class InvalidChunkSize(IOError):
+    data: bytes
+
+    def __init__(self, data: bytes) -> None: ...
+
+class ChunkMissingTerminator(IOError):
+    term: bytes
+
+    def __init__(self, term: bytes) -> None: ...
+
+class LimitRequestLine(ParseException):
+    size: int
+    max_size: int
+
+    def __init__(self, size: int, max_size: int) -> None: ...
+
+class LimitRequestHeaders(ParseException):
+    msg: str
+
+    def __init__(self, msg: str) -> None: ...
+
+class InvalidProxyLine(ParseException):
+    line: str
+    code: int
+
+    def __init__(self, line: str) -> None: ...
+
+class ForbiddenProxyRequest(ParseException):
+    host: str
+    code: int
+
+    def __init__(self, host: str) -> None: ...
+
+class InvalidSchemeHeaders(ParseException): ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/http/message.pyi

@@ -0,0 +1,62 @@
+import io
+import re
+from typing_extensions import override
+
+from gunicorn.config import Config
+from gunicorn.http.body import Body
+from gunicorn.http.unreader import Unreader
+
+from .._types import _AddressType
+
+MAX_REQUEST_LINE: int
+MAX_HEADERS: int
+DEFAULT_MAX_HEADERFIELD_SIZE: int
+RFC9110_5_6_2_TOKEN_SPECIALS: str
+TOKEN_RE: re.Pattern[str]
+METHOD_BADCHAR_RE: re.Pattern[str]
+VERSION_RE: re.Pattern[str]
+RFC9110_5_5_INVALID_AND_DANGEROUS: re.Pattern[str]
+
+class Message:
+    cfg: Config
+    unreader: Unreader
+    peer_addr: _AddressType
+    remote_addr: _AddressType
+    version: tuple[int, int] | None
+    headers: list[tuple[str, str]]
+    trailers: list[tuple[str, str]]
+    body: Body | None
+    scheme: str
+    must_close: bool
+    limit_request_fields: int
+    limit_request_field_size: int
+    max_buffer_headers: int
+
+    def __init__(self, cfg: Config, unreader: Unreader, peer_addr: _AddressType) -> None: ...
+    def force_close(self) -> None: ...
+    def parse(self, unreader: Unreader) -> bytes: ...
+    def parse_headers(self, data: bytes, from_trailer: bool = False) -> list[tuple[str, str]]: ...
+    def set_body_reader(self) -> None: ...
+    def should_close(self) -> bool: ...
+
+class Request(Message):
+    method: str | None
+    uri: str | None
+    path: str | None
+    query: str | None
+    fragment: str | None
+    limit_request_line: int
+    req_number: int
+    proxy_protocol_info: dict[str, str | int] | None
+
+    def __init__(self, cfg: Config, unreader: Unreader, peer_addr: _AddressType, req_number: int = 1) -> None: ...
+    def get_data(self, unreader: Unreader, buf: io.BytesIO, stop: bool = False) -> None: ...
+    @override
+    def parse(self, unreader: Unreader) -> bytes: ...
+    def read_line(self, unreader: Unreader, buf: io.BytesIO, limit: int = 0) -> tuple[bytes, bytes]: ...
+    def proxy_protocol(self, line: str) -> bool: ...
+    def proxy_protocol_access_check(self) -> None: ...
+    def parse_proxy_protocol(self, line: str) -> None: ...
+    def parse_request_line(self, line_bytes: bytes) -> None: ...
+    @override
+    def set_body_reader(self) -> None: ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/http/parser.pyi

@@ -0,0 +1,26 @@
+import socket
+from collections.abc import Callable, Iterable, Iterator
+from typing import ClassVar
+
+from gunicorn.config import Config
+from gunicorn.http.message import Request
+from gunicorn.http.unreader import Unreader
+
+from .._types import _AddressType
+
+class Parser:
+    mesg_class: ClassVar[type[Request] | None]
+    cfg: Config
+    unreader: Unreader
+    mesg: Request | None
+    source_addr: _AddressType
+    req_count: int
+
+    def __init__(self, cfg: Config, source: socket.socket | Iterable[bytes], source_addr: _AddressType) -> None: ...
+    def __iter__(self) -> Iterator[Request]: ...
+    def __next__(self) -> Request: ...
+
+    next: Callable[[Parser], Request]
+
+class RequestParser(Parser):
+    mesg_class: ClassVar[type[Request]]

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/http/unreader.pyi

@@ -0,0 +1,28 @@
+import io
+import socket
+from _typeshed import ReadableBuffer
+from collections.abc import Iterable, Iterator
+from typing_extensions import override
+
+class Unreader:
+    buf: io.BytesIO
+
+    def __init__(self) -> None: ...
+    def chunk(self) -> bytes: ...
+    def read(self, size: int | None = None) -> bytes: ...
+    def unread(self, data: ReadableBuffer) -> None: ...
+
+class SocketUnreader(Unreader):
+    sock: socket.socket
+    mxchunk: int
+
+    def __init__(self, sock: socket.socket, max_chunk: int = 8192) -> None: ...
+    @override
+    def chunk(self) -> bytes: ...
+
+class IterUnreader(Unreader):
+    iter: Iterator[bytes] | None
+
+    def __init__(self, iterable: Iterable[bytes]) -> None: ...
+    @override
+    def chunk(self) -> bytes: ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/http/wsgi.pyi

@@ -0,0 +1,70 @@
+import io
+import logging
+import re
+import socket
+from _typeshed import ReadableBuffer
+from collections.abc import Callable
+from typing import Any
+from typing_extensions import override
+
+from gunicorn.config import Config
+from gunicorn.http import Request
+
+from .._types import _AddressType, _EnvironType, _HeadersType, _StatusType
+
+BLKSIZE: int
+HEADER_VALUE_RE: re.Pattern[str]
+log: logging.Logger
+
+class FileWrapper:
+    filelike: io.IOBase
+    blksize: int
+    close: Callable[[], None] | None
+
+    def __init__(self, filelike: io.IOBase, blksize: int = 8192) -> None: ...
+    def __getitem__(self, key: Any) -> bytes: ...
+
+class WSGIErrorsWrapper(io.RawIOBase):
+    streams: list[io.TextIOBase]
+
+    def __init__(self, cfg: Config) -> None: ...
+    @override
+    def write(self, data: ReadableBuffer) -> None: ...
+
+def base_environ(cfg: Config) -> _EnvironType: ...
+def default_environ(req: Request, sock: socket.socket, cfg: Config) -> _EnvironType: ...
+def proxy_environ(req: Request) -> _EnvironType: ...
+def create(
+    req: Request, sock: socket.socket, client: _AddressType, server: _AddressType, cfg: Config
+) -> tuple[Response, _EnvironType]: ...
+
+class Response:
+    req: Request
+    sock: socket.socket
+    version: str
+    status: str | None
+    chunked: bool
+    must_close: bool
+    headers: _HeadersType
+    headers_sent: bool
+    response_length: int | None
+    sent: int
+    upgrade: bool
+    cfg: Config
+    status_code: int | None
+
+    def __init__(self, req: Request, sock: socket.socket, cfg: Config) -> None: ...
+    def force_close(self) -> None: ...
+    def should_close(self) -> bool: ...
+    def start_response(
+        self, status: _StatusType, headers: _HeadersType, exc_info: tuple[type, BaseException, Any] | None = None
+    ) -> Callable[[bytes], None]: ...
+    def process_headers(self, headers: _HeadersType) -> None: ...
+    def is_chunked(self) -> bool: ...
+    def default_headers(self) -> list[str]: ...
+    def send_headers(self) -> None: ...
+    def write(self, arg: bytes) -> None: ...
+    def can_sendfile(self) -> bool: ...
+    def sendfile(self, respiter: FileWrapper) -> bool: ...
+    def write_file(self, respiter: FileWrapper) -> None: ...
+    def close(self) -> None: ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/instrument/statsd.pyi

@@ -0,0 +1,105 @@
+import logging
+import socket
+from collections.abc import Mapping
+from datetime import timedelta
+from typing_extensions import override
+
+from gunicorn.config import Config
+from gunicorn.glogging import Logger
+from gunicorn.http import Request
+from gunicorn.http.wsgi import Response
+
+from .._types import _EnvironType
+from ..glogging import _LogLevelType
+
+METRIC_VAR: str
+VALUE_VAR: str
+MTYPE_VAR: str
+GAUGE_TYPE: str
+COUNTER_TYPE: str
+HISTOGRAM_TYPE: str
+
+class Statsd(Logger):
+    prefix: str
+    sock: socket.socket | None
+    dogstatsd_tags: str | None
+    cfg: Config
+
+    def __init__(self, cfg: Config) -> None: ...
+    @override
+    def critical(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    @override
+    def error(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    @override
+    def warning(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    @override
+    def info(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    @override
+    def debug(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    @override
+    def exception(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = True,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    @override
+    def log(
+        self,
+        lvl: _LogLevelType,
+        msg: object,
+        *args: object,
+        exc_info: logging._ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    @override
+    def access(self, resp: Response, req: Request, environ: _EnvironType, request_time: timedelta) -> None: ...
+    def gauge(self, name: str, value: float) -> None: ...
+    def increment(self, name: str, value: int, sampling_rate: float = 1.0) -> None: ...
+    def decrement(self, name: str, value: int, sampling_rate: float = 1.0) -> None: ...
+    def histogram(self, name: str, value: float) -> None: ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/pidfile.pyi

@@ -0,0 +1,8 @@
+from _typeshed import StrOrBytesPath
+
+class Pidfile:
+    def __init__(self, fname: StrOrBytesPath) -> None: ...
+    def create(self, pid: int) -> None: ...
+    def rename(self, path: StrOrBytesPath) -> None: ...
+    def unlink(self) -> None: ...
+    def validate(self) -> None: ...

package/dist/typeshed-fallback/stubs/gunicorn/gunicorn/reloader.pyi

@@ -0,0 +1,50 @@
+import sys
+import threading
+from collections.abc import Callable, Iterable
+from re import Pattern
+from typing import NoReturn, TypedDict, type_check_only
+from typing_extensions import TypeAlias, override
+
+COMPILED_EXT_RE: Pattern[str]
+
+class Reloader(threading.Thread):
+    daemon: bool
+
+    def __init__(
+        self, extra_files: Iterable[str] | None = None, interval: int = 1, callback: Callable[[str], None] | None = None
+    ) -> None: ...
+    def add_extra_file(self, filename: str) -> None: ...
+    def get_files(self) -> list[str]: ...
+    @override
+    def run(self) -> None: ...
+
+has_inotify: bool
+
+if sys.platform == "linux":
+    class InotifyReloader(threading.Thread):
+        event_mask: int
+        daemon: bool
+
+        def __init__(self, extra_files: Iterable[str] | None = None, callback: Callable[[str], None] | None = None) -> None: ...
+        def add_extra_file(self, filename: str) -> None: ...
+        def get_dirs(self) -> set[str]: ...
+        @override
+        def run(self) -> None: ...
+
+else:
+    class InotifyReloader:
+        def __init__(
+            self, extra_files: Iterable[str] | None = None, callback: Callable[[str], None] | None = None
+        ) -> NoReturn: ...
+
+_PreferredReloaderType: TypeAlias = type[InotifyReloader | Reloader]
+_ReloaderType: TypeAlias = InotifyReloader | Reloader  # noqa: Y047
+
+@type_check_only
+class _ReloadedEngines(TypedDict):
+    auto: _PreferredReloaderType
+    pool: type[Reloader]
+    inotify: type[InotifyReloader]
+
+preferred_reloader: _PreferredReloaderType
+reloader_engines: _ReloadedEngines