From 7f06f44fa2d588645b5354959a8fca0f2132fdf9 Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Wed, 24 Feb 2021 22:24:50 +0100 Subject: [PATCH 1/7] Split logging into Python 2 and 3 versions --- stdlib/@python2/logging/__init__.pyi | 918 +++++++++++++++++++++++++++ stdlib/@python2/logging/config.pyi | 32 + stdlib/@python2/logging/handlers.pyi | 258 ++++++++ stdlib/VERSIONS | 2 +- 4 files changed, 1209 insertions(+), 1 deletion(-) create mode 100644 stdlib/@python2/logging/__init__.pyi create mode 100644 stdlib/@python2/logging/config.pyi create mode 100644 stdlib/@python2/logging/handlers.pyi diff --git a/stdlib/@python2/logging/__init__.pyi b/stdlib/@python2/logging/__init__.pyi new file mode 100644 index 000000000000..865c527ac844 --- /dev/null +++ b/stdlib/@python2/logging/__init__.pyi @@ -0,0 +1,918 @@ +import sys +import threading +from _typeshed import StrPath +from string import Template +from time import struct_time +from types import FrameType, TracebackType +from typing import ( + IO, + Any, + Callable, + Dict, + Iterable, + List, + Mapping, + MutableMapping, + Optional, + Sequence, + Text, + Tuple, + Union, + overload, +) + +_SysExcInfoType = Union[Tuple[type, BaseException, Optional[TracebackType]], Tuple[None, None, None]] +if sys.version_info >= (3, 5): + _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException] +else: + _ExcInfoType = Union[None, bool, _SysExcInfoType] +_ArgsType = Union[Tuple[Any, ...], Mapping[str, Any]] +_FilterType = Union[Filter, Callable[[LogRecord], int]] +_Level = Union[int, Text] + +raiseExceptions: bool +logThreads: bool +logMultiprocessing: bool +logProcesses: bool +_srcfile: Optional[str] + +def currentframe() -> FrameType: ... + +if sys.version_info >= (3,): + _levelToName: Dict[int, str] + _nameToLevel: Dict[str, int] +else: + _levelNames: Dict[Union[int, str], Union[str, int]] # Union[int:str, str:int] + +class Filterer(object): + filters: List[Filter] + def __init__(self) -> None: ... + def addFilter(self, filter: _FilterType) -> None: ... + def removeFilter(self, filter: _FilterType) -> None: ... + def filter(self, record: LogRecord) -> bool: ... + +class Logger(Filterer): + name: str + level: int + parent: Union[Logger, PlaceHolder] + propagate: bool + handlers: List[Handler] + disabled: int + def __init__(self, name: str, level: _Level = ...) -> None: ... + def setLevel(self, level: _Level) -> None: ... + def isEnabledFor(self, level: int) -> bool: ... + def getEffectiveLevel(self) -> int: ... + def getChild(self, suffix: str) -> Logger: ... + if sys.version_info >= (3, 8): + def debug( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def info( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warning( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warn( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def error( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def exception( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def critical( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def log( + self, + level: int, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def _log( + self, + level: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_ExcInfoType] = ..., + extra: Optional[Dict[str, Any]] = ..., + stack_info: bool = ..., + stacklevel: int = ..., + ) -> None: ... # undocumented + elif sys.version_info >= (3,): + def debug( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def info( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warning( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warn( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def error( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def critical( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + fatal = critical + def log( + self, + level: int, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def exception( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def _log( + self, + level: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_ExcInfoType] = ..., + extra: Optional[Dict[str, Any]] = ..., + stack_info: bool = ..., + ) -> None: ... # undocumented + else: + def debug( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def info( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def warning( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + warn = warning + def error( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def critical( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + fatal = critical + def log( + self, + level: int, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def exception( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def _log( + self, + level: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_ExcInfoType] = ..., + extra: Optional[Dict[str, Any]] = ..., + ) -> None: ... # undocumented + def filter(self, record: LogRecord) -> bool: ... + def addHandler(self, hdlr: Handler) -> None: ... + def removeHandler(self, hdlr: Handler) -> None: ... + if sys.version_info >= (3, 8): + def findCaller(self, stack_info: bool = ..., stacklevel: int = ...) -> Tuple[str, int, str, Optional[str]]: ... + elif sys.version_info >= (3,): + def findCaller(self, stack_info: bool = ...) -> Tuple[str, int, str, Optional[str]]: ... + else: + def findCaller(self) -> Tuple[str, int, str]: ... + def handle(self, record: LogRecord) -> None: ... + if sys.version_info >= (3,): + def makeRecord( + self, + name: str, + level: int, + fn: str, + lno: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_SysExcInfoType], + func: Optional[str] = ..., + extra: Optional[Mapping[str, Any]] = ..., + sinfo: Optional[str] = ..., + ) -> LogRecord: ... + else: + def makeRecord( + self, + name: str, + level: int, + fn: str, + lno: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_SysExcInfoType], + func: Optional[str] = ..., + extra: Optional[Mapping[str, Any]] = ..., + ) -> LogRecord: ... + if sys.version_info >= (3,): + def hasHandlers(self) -> bool: ... + +CRITICAL: int +FATAL: int +ERROR: int +WARNING: int +WARN: int +INFO: int +DEBUG: int +NOTSET: int + +class Handler(Filterer): + level: int # undocumented + formatter: Optional[Formatter] # undocumented + lock: Optional[threading.Lock] # undocumented + name: Optional[str] # undocumented + def __init__(self, level: _Level = ...) -> None: ... + def createLock(self) -> None: ... + def acquire(self) -> None: ... + def release(self) -> None: ... + def setLevel(self, level: _Level) -> None: ... + def setFormatter(self, fmt: Formatter) -> None: ... + def filter(self, record: LogRecord) -> bool: ... + def flush(self) -> None: ... + def close(self) -> None: ... + def handle(self, record: LogRecord) -> None: ... + def handleError(self, record: LogRecord) -> None: ... + def format(self, record: LogRecord) -> str: ... + def emit(self, record: LogRecord) -> None: ... + +class Formatter: + converter: Callable[[Optional[float]], struct_time] + _fmt: Optional[str] + datefmt: Optional[str] + if sys.version_info >= (3,): + _style: PercentStyle + default_time_format: str + default_msec_format: str + + if sys.version_info >= (3, 8): + def __init__( + self, fmt: Optional[str] = ..., datefmt: Optional[str] = ..., style: str = ..., validate: bool = ... + ) -> None: ... + elif sys.version_info >= (3,): + def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ..., style: str = ...) -> None: ... + else: + def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ...) -> None: ... + def format(self, record: LogRecord) -> str: ... + def formatTime(self, record: LogRecord, datefmt: Optional[str] = ...) -> str: ... + def formatException(self, ei: _SysExcInfoType) -> str: ... + if sys.version_info >= (3,): + def formatMessage(self, record: LogRecord) -> str: ... # undocumented + def formatStack(self, stack_info: str) -> str: ... + +class Filter: + def __init__(self, name: str = ...) -> None: ... + def filter(self, record: LogRecord) -> bool: ... + +class LogRecord: + args: _ArgsType + asctime: str + created: int + exc_info: Optional[_SysExcInfoType] + exc_text: Optional[str] + filename: str + funcName: str + levelname: str + levelno: int + lineno: int + module: str + msecs: int + message: str + msg: str + name: str + pathname: str + process: int + processName: str + relativeCreated: int + if sys.version_info >= (3,): + stack_info: Optional[str] + thread: int + threadName: str + if sys.version_info >= (3,): + def __init__( + self, + name: str, + level: int, + pathname: str, + lineno: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_SysExcInfoType], + func: Optional[str] = ..., + sinfo: Optional[str] = ..., + ) -> None: ... + else: + def __init__( + self, + name: str, + level: int, + pathname: str, + lineno: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_SysExcInfoType], + func: Optional[str] = ..., + ) -> None: ... + def getMessage(self) -> str: ... + +class LoggerAdapter: + logger: Logger + extra: Mapping[str, Any] + def __init__(self, logger: Logger, extra: Mapping[str, Any]) -> None: ... + def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> Tuple[Any, MutableMapping[str, Any]]: ... + if sys.version_info >= (3, 8): + def debug( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def info( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warning( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warn( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def error( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def exception( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def critical( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def log( + self, + level: int, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + elif sys.version_info >= (3,): + def debug( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def info( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warning( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warn( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def error( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def exception( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def critical( + self, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def log( + self, + level: int, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + else: + def debug( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def info( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def warning( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def error( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def exception( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def critical( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def log( + self, + level: int, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def isEnabledFor(self, level: int) -> bool: ... + if sys.version_info >= (3,): + def getEffectiveLevel(self) -> int: ... + def setLevel(self, level: Union[int, str]) -> None: ... + def hasHandlers(self) -> bool: ... + if sys.version_info >= (3, 6): + def _log( + self, + level: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_ExcInfoType] = ..., + extra: Optional[Dict[str, Any]] = ..., + stack_info: bool = ..., + ) -> None: ... # undocumented + +if sys.version_info >= (3,): + def getLogger(name: Optional[str] = ...) -> Logger: ... + +else: + @overload + def getLogger() -> Logger: ... + @overload + def getLogger(name: Union[Text, str]) -> Logger: ... + +def getLoggerClass() -> type: ... + +if sys.version_info >= (3,): + def getLogRecordFactory() -> Callable[..., LogRecord]: ... + +if sys.version_info >= (3, 8): + def debug( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def info( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warning( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warn( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def error( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def critical( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def exception( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def log( + level: int, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + stacklevel: int = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + +elif sys.version_info >= (3,): + def debug( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def info( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warning( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def warn( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def error( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def critical( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def exception( + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def log( + level: int, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + stack_info: bool = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + +else: + def debug( + msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def info( + msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def warning( + msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + warn = warning + def error( + msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def critical( + msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def exception( + msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def log( + level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + +fatal = critical + +if sys.version_info >= (3, 7): + def disable(level: int = ...) -> None: ... + +else: + def disable(level: int) -> None: ... + +def addLevelName(level: int, levelName: str) -> None: ... +def getLevelName(level: Union[int, str]) -> Any: ... +def makeLogRecord(dict: Mapping[str, Any]) -> LogRecord: ... + +if sys.version_info >= (3, 8): + def basicConfig( + *, + filename: Optional[StrPath] = ..., + filemode: str = ..., + format: str = ..., + datefmt: Optional[str] = ..., + style: str = ..., + level: Optional[_Level] = ..., + stream: Optional[IO[str]] = ..., + handlers: Optional[Iterable[Handler]] = ..., + force: bool = ..., + ) -> None: ... + +elif sys.version_info >= (3,): + def basicConfig( + *, + filename: Optional[StrPath] = ..., + filemode: str = ..., + format: str = ..., + datefmt: Optional[str] = ..., + style: str = ..., + level: Optional[_Level] = ..., + stream: Optional[IO[str]] = ..., + handlers: Optional[Iterable[Handler]] = ..., + ) -> None: ... + +else: + @overload + def basicConfig() -> None: ... + @overload + def basicConfig( + *, + filename: Optional[str] = ..., + filemode: str = ..., + format: str = ..., + datefmt: Optional[str] = ..., + level: Optional[_Level] = ..., + stream: IO[str] = ..., + ) -> None: ... + +def shutdown(handlerList: Sequence[Any] = ...) -> None: ... # handlerList is undocumented +def setLoggerClass(klass: type) -> None: ... +def captureWarnings(capture: bool) -> None: ... + +if sys.version_info >= (3,): + def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ... + +if sys.version_info >= (3,): + lastResort: Optional[StreamHandler] + +class StreamHandler(Handler): + stream: IO[str] # undocumented + if sys.version_info >= (3, 2): + terminator: str + def __init__(self, stream: Optional[IO[str]] = ...) -> None: ... + if sys.version_info >= (3, 7): + def setStream(self, stream: IO[str]) -> Optional[IO[str]]: ... + +class FileHandler(StreamHandler): + baseFilename: str # undocumented + mode: str # undocumented + encoding: Optional[str] # undocumented + delay: bool # undocumented + def __init__(self, filename: StrPath, mode: str = ..., encoding: Optional[str] = ..., delay: bool = ...) -> None: ... + def _open(self) -> IO[Any]: ... + +class NullHandler(Handler): ... + +class PlaceHolder: + def __init__(self, alogger: Logger) -> None: ... + def append(self, alogger: Logger) -> None: ... + +# Below aren't in module docs but still visible + +class RootLogger(Logger): + def __init__(self, level: int) -> None: ... + +root: RootLogger + +if sys.version_info >= (3,): + class PercentStyle(object): + default_format: str + asctime_format: str + asctime_search: str + _fmt: str + def __init__(self, fmt: str) -> None: ... + def usesTime(self) -> bool: ... + def format(self, record: Any) -> str: ... + class StrFormatStyle(PercentStyle): ... + class StringTemplateStyle(PercentStyle): + _tpl: Template + _STYLES: Dict[str, Tuple[PercentStyle, str]] + +BASIC_FORMAT: str diff --git a/stdlib/@python2/logging/config.pyi b/stdlib/@python2/logging/config.pyi new file mode 100644 index 000000000000..535d583d759a --- /dev/null +++ b/stdlib/@python2/logging/config.pyi @@ -0,0 +1,32 @@ +import sys +from _typeshed import AnyPath, StrPath +from threading import Thread +from typing import IO, Any, Callable, Dict, Optional, Union + +if sys.version_info >= (3,): + from configparser import RawConfigParser +else: + from ConfigParser import RawConfigParser + +if sys.version_info >= (3, 7): + _Path = AnyPath +else: + _Path = StrPath + +def dictConfig(config: Dict[str, Any]) -> None: ... + +if sys.version_info >= (3, 4): + def fileConfig( + fname: Union[_Path, IO[str], RawConfigParser], + defaults: Optional[Dict[str, str]] = ..., + disable_existing_loggers: bool = ..., + ) -> None: ... + def listen(port: int = ..., verify: Optional[Callable[[bytes], Optional[bytes]]] = ...) -> Thread: ... + +else: + def fileConfig( + fname: Union[str, IO[str]], defaults: Optional[Dict[str, str]] = ..., disable_existing_loggers: bool = ... + ) -> None: ... + def listen(port: int = ...) -> Thread: ... + +def stopListening() -> None: ... diff --git a/stdlib/@python2/logging/handlers.pyi b/stdlib/@python2/logging/handlers.pyi new file mode 100644 index 000000000000..3c726fc2a3c0 --- /dev/null +++ b/stdlib/@python2/logging/handlers.pyi @@ -0,0 +1,258 @@ +import datetime +import ssl +import sys +from _typeshed import StrPath +from logging import FileHandler, Handler, LogRecord +from socket import SocketKind, SocketType +from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple, Union + +if sys.version_info >= (3, 7): + from queue import Queue, SimpleQueue +elif sys.version_info >= (3,): + from queue import Queue +else: + from Queue import Queue + +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 + ino: int + def __init__(self, filename: StrPath, mode: str = ..., encoding: Optional[str] = ..., delay: bool = ...) -> None: ... + def _statstream(self) -> None: ... + +if sys.version_info >= (3,): + class BaseRotatingHandler(FileHandler): + terminator: str + namer: Optional[Callable[[str], str]] + rotator: Optional[Callable[[str, str], None]] + def __init__(self, filename: StrPath, mode: str, encoding: Optional[str] = ..., delay: bool = ...) -> None: ... + def rotation_filename(self, default_name: str) -> None: ... + def rotate(self, source: str, dest: str) -> None: ... + +if sys.version_info >= (3,): + class RotatingFileHandler(BaseRotatingHandler): + def __init__( + self, + filename: StrPath, + mode: str = ..., + maxBytes: int = ..., + backupCount: int = ..., + encoding: Optional[str] = ..., + delay: bool = ..., + ) -> None: ... + def doRollover(self) -> None: ... + +else: + class RotatingFileHandler(Handler): + def __init__( + self, + filename: str, + mode: str = ..., + maxBytes: int = ..., + backupCount: int = ..., + encoding: Optional[str] = ..., + delay: bool = ..., + ) -> None: ... + def doRollover(self) -> None: ... + +if sys.version_info >= (3,): + class TimedRotatingFileHandler(BaseRotatingHandler): + if sys.version_info >= (3, 4): + def __init__( + self, + filename: StrPath, + when: str = ..., + interval: int = ..., + backupCount: int = ..., + encoding: Optional[str] = ..., + delay: bool = ..., + utc: bool = ..., + atTime: Optional[datetime.datetime] = ..., + ) -> None: ... + else: + def __init__( + self, + filename: str, + when: str = ..., + interval: int = ..., + backupCount: int = ..., + encoding: Optional[str] = ..., + delay: bool = ..., + utc: bool = ..., + ) -> None: ... + def doRollover(self) -> None: ... + +else: + class TimedRotatingFileHandler(Handler): + def __init__( + self, + filename: str, + when: str = ..., + interval: int = ..., + backupCount: int = ..., + encoding: Optional[str] = ..., + delay: bool = ..., + utc: bool = ..., + ) -> None: ... + def doRollover(self) -> None: ... + +class SocketHandler(Handler): + retryStart: float + retryFactor: float + retryMax: float + if sys.version_info >= (3, 4): + def __init__(self, host: str, port: Optional[int]) -> None: ... + else: + def __init__(self, host: str, port: int) -> None: ... + def makeSocket(self, timeout: float = ...) -> SocketType: ... # timeout is undocumented + def makePickle(self, record: LogRecord) -> bytes: ... + def send(self, s: bytes) -> None: ... + def createSocket(self) -> None: ... + +class DatagramHandler(SocketHandler): + def makeSocket(self) -> SocketType: ... # type: ignore + +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 + unixsocket: bool # undocumented + socktype: SocketKind # undocumented + if sys.version_info >= (3,): + ident: str # 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: Union[Tuple[str, int], str] = ..., facility: int = ..., socktype: Optional[SocketKind] = ... + ) -> None: ... + def encodePriority(self, facility: Union[int, str], priority: Union[int, str]) -> int: ... + def mapPriority(self, levelName: str) -> str: ... + +class NTEventLogHandler(Handler): + def __init__(self, appname: str, dllname: Optional[str] = ..., logtype: str = ...) -> 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): + # TODO `secure` can also be an empty tuple + if sys.version_info >= (3,): + def __init__( + self, + mailhost: Union[str, Tuple[str, int]], + fromaddr: str, + toaddrs: List[str], + subject: str, + credentials: Optional[Tuple[str, str]] = ..., + secure: Union[Tuple[str], Tuple[str, str], None] = ..., + timeout: float = ..., + ) -> None: ... + else: + def __init__( + self, + mailhost: Union[str, Tuple[str, int]], + fromaddr: str, + toaddrs: List[str], + subject: str, + credentials: Optional[Tuple[str, str]] = ..., + secure: Union[Tuple[str], Tuple[str, str], None] = ..., + ) -> None: ... + def getSubject(self, record: LogRecord) -> str: ... + +class BufferingHandler(Handler): + buffer: List[LogRecord] + def __init__(self, capacity: int) -> None: ... + def shouldFlush(self, record: LogRecord) -> bool: ... + +class MemoryHandler(BufferingHandler): + if sys.version_info >= (3, 6): + def __init__( + self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ..., flushOnClose: bool = ... + ) -> None: ... + else: + def __init__(self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ...) -> None: ... + def setTarget(self, target: Handler) -> None: ... + +class HTTPHandler(Handler): + if sys.version_info >= (3, 5): + def __init__( + self, + host: str, + url: str, + method: str = ..., + secure: bool = ..., + credentials: Optional[Tuple[str, str]] = ..., + context: Optional[ssl.SSLContext] = ..., + ) -> None: ... + elif sys.version_info >= (3,): + def __init__( + self, host: str, url: str, method: str = ..., secure: bool = ..., credentials: Optional[Tuple[str, str]] = ... + ) -> None: ... + else: + def __init__(self, host: str, url: str, method: str = ...) -> None: ... + def mapLogRecord(self, record: LogRecord) -> Dict[str, Any]: ... + +if sys.version_info >= (3,): + class QueueHandler(Handler): + if sys.version_info >= (3, 7): + def __init__(self, queue: Union[SimpleQueue[Any], Queue[Any]]) -> None: ... + else: + def __init__(self, queue: Queue[Any]) -> None: ... + def prepare(self, record: LogRecord) -> Any: ... + def enqueue(self, record: LogRecord) -> None: ... + class QueueListener: + if sys.version_info >= (3, 7): + def __init__( + self, queue: Union[SimpleQueue[Any], Queue[Any]], *handlers: Handler, respect_handler_level: bool = ... + ) -> None: ... + elif sys.version_info >= (3, 5): + def __init__(self, queue: Queue[Any], *handlers: Handler, respect_handler_level: bool = ...) -> None: ... + else: + def __init__(self, queue: Queue, *handlers: Handler) -> 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: ... diff --git a/stdlib/VERSIONS b/stdlib/VERSIONS index b003f85fa720..8e0e49228e24 100644 --- a/stdlib/VERSIONS +++ b/stdlib/VERSIONS @@ -125,7 +125,7 @@ keyword: 2.7 lib2to3: 2.7 linecache: 2.7 locale: 2.7 -logging: 2.7 +logging: 3.6 lzma: 3.6 macpath: 2.7 macurl2path: 3.6 From 7761fdb894ec2f831fc6a4e1a96c388895576f7b Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Wed, 24 Feb 2021 22:39:01 +0100 Subject: [PATCH 2/7] Remove unnecessary branches from logging --- stdlib/@python2/logging/__init__.pyi | 838 ++++----------------------- stdlib/@python2/logging/config.pyi | 30 +- stdlib/@python2/logging/handlers.pyi | 197 ++----- stdlib/logging/__init__.pyi | 324 +++-------- stdlib/logging/config.pyi | 27 +- stdlib/logging/handlers.pyi | 221 +++---- 6 files changed, 305 insertions(+), 1332 deletions(-) diff --git a/stdlib/@python2/logging/__init__.pyi b/stdlib/@python2/logging/__init__.pyi index 865c527ac844..a683113285a1 100644 --- a/stdlib/@python2/logging/__init__.pyi +++ b/stdlib/@python2/logging/__init__.pyi @@ -1,4 +1,3 @@ -import sys import threading from _typeshed import StrPath from string import Template @@ -22,10 +21,7 @@ from typing import ( ) _SysExcInfoType = Union[Tuple[type, BaseException, Optional[TracebackType]], Tuple[None, None, None]] -if sys.version_info >= (3, 5): - _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException] -else: - _ExcInfoType = Union[None, bool, _SysExcInfoType] +_ExcInfoType = Union[None, bool, _SysExcInfoType] _ArgsType = Union[Tuple[Any, ...], Mapping[str, Any]] _FilterType = Union[Filter, Callable[[LogRecord], int]] _Level = Union[int, Text] @@ -38,11 +34,7 @@ _srcfile: Optional[str] def currentframe() -> FrameType: ... -if sys.version_info >= (3,): - _levelToName: Dict[int, str] - _nameToLevel: Dict[str, int] -else: - _levelNames: Dict[Union[int, str], Union[str, int]] # Union[int:str, str:int] +_levelNames: Dict[Union[int, str], Union[str, int]] # Union[int:str, str:int] class Filterer(object): filters: List[Filter] @@ -63,259 +55,60 @@ class Logger(Filterer): def isEnabledFor(self, level: int) -> bool: ... def getEffectiveLevel(self) -> int: ... def getChild(self, suffix: str) -> Logger: ... - if sys.version_info >= (3, 8): - def debug( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def info( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warning( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warn( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def error( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def exception( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def critical( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def log( - self, - level: int, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def _log( - self, - level: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_ExcInfoType] = ..., - extra: Optional[Dict[str, Any]] = ..., - stack_info: bool = ..., - stacklevel: int = ..., - ) -> None: ... # undocumented - elif sys.version_info >= (3,): - def debug( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def info( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warning( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warn( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def error( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def critical( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - fatal = critical - def log( - self, - level: int, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def exception( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def _log( - self, - level: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_ExcInfoType] = ..., - extra: Optional[Dict[str, Any]] = ..., - stack_info: bool = ..., - ) -> None: ... # undocumented - else: - def debug( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def info( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def warning( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - warn = warning - def error( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def critical( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - fatal = critical - def log( - self, - level: int, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def exception( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def _log( - self, - level: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_ExcInfoType] = ..., - extra: Optional[Dict[str, Any]] = ..., - ) -> None: ... # undocumented + def debug( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def info( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def warning( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + warn = warning + def error( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def critical( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + fatal = critical + def log( + self, + level: int, + msg: Any, + *args: Any, + exc_info: _ExcInfoType = ..., + extra: Optional[Dict[str, Any]] = ..., + **kwargs: Any, + ) -> None: ... + def exception( + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any + ) -> None: ... + def _log( + self, + level: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_ExcInfoType] = ..., + extra: Optional[Dict[str, Any]] = ..., + ) -> None: ... # undocumented def filter(self, record: LogRecord) -> bool: ... def addHandler(self, hdlr: Handler) -> None: ... def removeHandler(self, hdlr: Handler) -> None: ... - if sys.version_info >= (3, 8): - def findCaller(self, stack_info: bool = ..., stacklevel: int = ...) -> Tuple[str, int, str, Optional[str]]: ... - elif sys.version_info >= (3,): - def findCaller(self, stack_info: bool = ...) -> Tuple[str, int, str, Optional[str]]: ... - else: - def findCaller(self) -> Tuple[str, int, str]: ... + def findCaller(self) -> Tuple[str, int, str]: ... def handle(self, record: LogRecord) -> None: ... - if sys.version_info >= (3,): - def makeRecord( - self, - name: str, - level: int, - fn: str, - lno: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_SysExcInfoType], - func: Optional[str] = ..., - extra: Optional[Mapping[str, Any]] = ..., - sinfo: Optional[str] = ..., - ) -> LogRecord: ... - else: - def makeRecord( - self, - name: str, - level: int, - fn: str, - lno: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_SysExcInfoType], - func: Optional[str] = ..., - extra: Optional[Mapping[str, Any]] = ..., - ) -> LogRecord: ... - if sys.version_info >= (3,): - def hasHandlers(self) -> bool: ... + def makeRecord( + self, + name: str, + level: int, + fn: str, + lno: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_SysExcInfoType], + func: Optional[str] = ..., + extra: Optional[Mapping[str, Any]] = ..., + ) -> LogRecord: ... CRITICAL: int FATAL: int @@ -349,25 +142,10 @@ class Formatter: converter: Callable[[Optional[float]], struct_time] _fmt: Optional[str] datefmt: Optional[str] - if sys.version_info >= (3,): - _style: PercentStyle - default_time_format: str - default_msec_format: str - - if sys.version_info >= (3, 8): - def __init__( - self, fmt: Optional[str] = ..., datefmt: Optional[str] = ..., style: str = ..., validate: bool = ... - ) -> None: ... - elif sys.version_info >= (3,): - def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ..., style: str = ...) -> None: ... - else: - def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ...) -> None: ... + def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ...) -> None: ... def format(self, record: LogRecord) -> str: ... def formatTime(self, record: LogRecord, datefmt: Optional[str] = ...) -> str: ... def formatException(self, ei: _SysExcInfoType) -> str: ... - if sys.version_info >= (3,): - def formatMessage(self, record: LogRecord) -> str: ... # undocumented - def formatStack(self, stack_info: str) -> str: ... class Filter: def __init__(self, name: str = ...) -> None: ... @@ -393,35 +171,19 @@ class LogRecord: process: int processName: str relativeCreated: int - if sys.version_info >= (3,): - stack_info: Optional[str] thread: int threadName: str - if sys.version_info >= (3,): - def __init__( - self, - name: str, - level: int, - pathname: str, - lineno: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_SysExcInfoType], - func: Optional[str] = ..., - sinfo: Optional[str] = ..., - ) -> None: ... - else: - def __init__( - self, - name: str, - level: int, - pathname: str, - lineno: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_SysExcInfoType], - func: Optional[str] = ..., - ) -> None: ... + def __init__( + self, + name: str, + level: int, + pathname: str, + lineno: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_SysExcInfoType], + func: Optional[str] = ..., + ) -> None: ... def getMessage(self) -> str: ... class LoggerAdapter: @@ -429,456 +191,82 @@ class LoggerAdapter: extra: Mapping[str, Any] def __init__(self, logger: Logger, extra: Mapping[str, Any]) -> None: ... def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> Tuple[Any, MutableMapping[str, Any]]: ... - if sys.version_info >= (3, 8): - def debug( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def info( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warning( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warn( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def error( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def exception( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def critical( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def log( - self, - level: int, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - elif sys.version_info >= (3,): - def debug( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def info( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warning( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warn( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def error( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def exception( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def critical( - self, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def log( - self, - level: int, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - else: - def debug( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def info( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def warning( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def error( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def exception( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def critical( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def log( - self, - level: int, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def isEnabledFor(self, level: int) -> bool: ... - if sys.version_info >= (3,): - def getEffectiveLevel(self) -> int: ... - def setLevel(self, level: Union[int, str]) -> None: ... - def hasHandlers(self) -> bool: ... - if sys.version_info >= (3, 6): - def _log( - self, - level: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_ExcInfoType] = ..., - extra: Optional[Dict[str, Any]] = ..., - stack_info: bool = ..., - ) -> None: ... # undocumented - -if sys.version_info >= (3,): - def getLogger(name: Optional[str] = ...) -> Logger: ... - -else: - @overload - def getLogger() -> Logger: ... - @overload - def getLogger(name: Union[Text, str]) -> Logger: ... - -def getLoggerClass() -> type: ... - -if sys.version_info >= (3,): - def getLogRecordFactory() -> Callable[..., LogRecord]: ... - -if sys.version_info >= (3, 8): def debug( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def info( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def warning( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warn( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def error( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def critical( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def exception( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def log( - level: int, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - -elif sys.version_info >= (3,): - def debug( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def info( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warning( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def warn( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def error( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def critical( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def exception( - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, + self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def log( + self, level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., - stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... + def isEnabledFor(self, level: int) -> bool: ... -else: - def debug( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def info( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def warning( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - warn = warning - def error( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def critical( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def exception( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def log( - level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... +@overload +def getLogger() -> Logger: ... +@overload +def getLogger(name: Union[Text, str]) -> Logger: ... +def getLoggerClass() -> type: ... +def debug(msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ... +def info(msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ... +def warning(msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ... + +warn = warning + +def error(msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ... +def critical( + msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any +) -> None: ... +def exception( + msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any +) -> None: ... +def log( + level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any +) -> None: ... fatal = critical -if sys.version_info >= (3, 7): - def disable(level: int = ...) -> None: ... - -else: - def disable(level: int) -> None: ... - +def disable(level: int) -> None: ... def addLevelName(level: int, levelName: str) -> None: ... def getLevelName(level: Union[int, str]) -> Any: ... def makeLogRecord(dict: Mapping[str, Any]) -> LogRecord: ... - -if sys.version_info >= (3, 8): - def basicConfig( - *, - filename: Optional[StrPath] = ..., - filemode: str = ..., - format: str = ..., - datefmt: Optional[str] = ..., - style: str = ..., - level: Optional[_Level] = ..., - stream: Optional[IO[str]] = ..., - handlers: Optional[Iterable[Handler]] = ..., - force: bool = ..., - ) -> None: ... - -elif sys.version_info >= (3,): - def basicConfig( - *, - filename: Optional[StrPath] = ..., - filemode: str = ..., - format: str = ..., - datefmt: Optional[str] = ..., - style: str = ..., - level: Optional[_Level] = ..., - stream: Optional[IO[str]] = ..., - handlers: Optional[Iterable[Handler]] = ..., - ) -> None: ... - -else: - @overload - def basicConfig() -> None: ... - @overload - def basicConfig( - *, - filename: Optional[str] = ..., - filemode: str = ..., - format: str = ..., - datefmt: Optional[str] = ..., - level: Optional[_Level] = ..., - stream: IO[str] = ..., - ) -> None: ... - +@overload +def basicConfig() -> None: ... +@overload +def basicConfig( + *, + filename: Optional[str] = ..., + filemode: str = ..., + format: str = ..., + datefmt: Optional[str] = ..., + level: Optional[_Level] = ..., + stream: IO[str] = ..., +) -> None: ... def shutdown(handlerList: Sequence[Any] = ...) -> None: ... # handlerList is undocumented def setLoggerClass(klass: type) -> None: ... def captureWarnings(capture: bool) -> None: ... -if sys.version_info >= (3,): - def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ... - -if sys.version_info >= (3,): - lastResort: Optional[StreamHandler] - class StreamHandler(Handler): stream: IO[str] # undocumented - if sys.version_info >= (3, 2): - terminator: str def __init__(self, stream: Optional[IO[str]] = ...) -> None: ... - if sys.version_info >= (3, 7): - def setStream(self, stream: IO[str]) -> Optional[IO[str]]: ... class FileHandler(StreamHandler): baseFilename: str # undocumented @@ -901,18 +289,4 @@ class RootLogger(Logger): root: RootLogger -if sys.version_info >= (3,): - class PercentStyle(object): - default_format: str - asctime_format: str - asctime_search: str - _fmt: str - def __init__(self, fmt: str) -> None: ... - def usesTime(self) -> bool: ... - def format(self, record: Any) -> str: ... - class StrFormatStyle(PercentStyle): ... - class StringTemplateStyle(PercentStyle): - _tpl: Template - _STYLES: Dict[str, Tuple[PercentStyle, str]] - BASIC_FORMAT: str diff --git a/stdlib/@python2/logging/config.pyi b/stdlib/@python2/logging/config.pyi index 535d583d759a..695001221d79 100644 --- a/stdlib/@python2/logging/config.pyi +++ b/stdlib/@python2/logging/config.pyi @@ -1,32 +1,14 @@ -import sys from _typeshed import AnyPath, StrPath from threading import Thread from typing import IO, Any, Callable, Dict, Optional, Union -if sys.version_info >= (3,): - from configparser import RawConfigParser -else: - from ConfigParser import RawConfigParser +from ConfigParser import RawConfigParser -if sys.version_info >= (3, 7): - _Path = AnyPath -else: - _Path = StrPath +_Path = StrPath def dictConfig(config: Dict[str, Any]) -> None: ... - -if sys.version_info >= (3, 4): - def fileConfig( - fname: Union[_Path, IO[str], RawConfigParser], - defaults: Optional[Dict[str, str]] = ..., - disable_existing_loggers: bool = ..., - ) -> None: ... - def listen(port: int = ..., verify: Optional[Callable[[bytes], Optional[bytes]]] = ...) -> Thread: ... - -else: - def fileConfig( - fname: Union[str, IO[str]], defaults: Optional[Dict[str, str]] = ..., disable_existing_loggers: bool = ... - ) -> None: ... - def listen(port: int = ...) -> Thread: ... - +def fileConfig( + fname: Union[str, IO[str]], defaults: Optional[Dict[str, str]] = ..., disable_existing_loggers: bool = ... +) -> None: ... +def listen(port: int = ...) -> Thread: ... def stopListening() -> None: ... diff --git a/stdlib/@python2/logging/handlers.pyi b/stdlib/@python2/logging/handlers.pyi index 3c726fc2a3c0..9403409fce87 100644 --- a/stdlib/@python2/logging/handlers.pyi +++ b/stdlib/@python2/logging/handlers.pyi @@ -1,18 +1,11 @@ import datetime import ssl -import sys from _typeshed import StrPath from logging import FileHandler, Handler, LogRecord +from Queue import Queue from socket import SocketKind, SocketType from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple, Union -if sys.version_info >= (3, 7): - from queue import Queue, SimpleQueue -elif sys.version_info >= (3,): - from queue import Queue -else: - from Queue import Queue - DEFAULT_TCP_LOGGING_PORT: int DEFAULT_UDP_LOGGING_PORT: int DEFAULT_HTTP_LOGGING_PORT: int @@ -26,90 +19,36 @@ class WatchedFileHandler(FileHandler): def __init__(self, filename: StrPath, mode: str = ..., encoding: Optional[str] = ..., delay: bool = ...) -> None: ... def _statstream(self) -> None: ... -if sys.version_info >= (3,): - class BaseRotatingHandler(FileHandler): - terminator: str - namer: Optional[Callable[[str], str]] - rotator: Optional[Callable[[str, str], None]] - def __init__(self, filename: StrPath, mode: str, encoding: Optional[str] = ..., delay: bool = ...) -> None: ... - def rotation_filename(self, default_name: str) -> None: ... - def rotate(self, source: str, dest: str) -> None: ... - -if sys.version_info >= (3,): - class RotatingFileHandler(BaseRotatingHandler): - def __init__( - self, - filename: StrPath, - mode: str = ..., - maxBytes: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - ) -> None: ... - def doRollover(self) -> None: ... - -else: - class RotatingFileHandler(Handler): - def __init__( - self, - filename: str, - mode: str = ..., - maxBytes: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - ) -> None: ... - def doRollover(self) -> None: ... - -if sys.version_info >= (3,): - class TimedRotatingFileHandler(BaseRotatingHandler): - if sys.version_info >= (3, 4): - def __init__( - self, - filename: StrPath, - when: str = ..., - interval: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - utc: bool = ..., - atTime: Optional[datetime.datetime] = ..., - ) -> None: ... - else: - def __init__( - self, - filename: str, - when: str = ..., - interval: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - utc: bool = ..., - ) -> None: ... - def doRollover(self) -> None: ... +class RotatingFileHandler(Handler): + def __init__( + self, + filename: str, + mode: str = ..., + maxBytes: int = ..., + backupCount: int = ..., + encoding: Optional[str] = ..., + delay: bool = ..., + ) -> None: ... + def doRollover(self) -> None: ... -else: - class TimedRotatingFileHandler(Handler): - def __init__( - self, - filename: str, - when: str = ..., - interval: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - utc: bool = ..., - ) -> None: ... - def doRollover(self) -> None: ... +class TimedRotatingFileHandler(Handler): + def __init__( + self, + filename: str, + when: str = ..., + interval: int = ..., + backupCount: int = ..., + encoding: Optional[str] = ..., + delay: bool = ..., + utc: bool = ..., + ) -> None: ... + def doRollover(self) -> None: ... class SocketHandler(Handler): retryStart: float retryFactor: float retryMax: float - if sys.version_info >= (3, 4): - def __init__(self, host: str, port: Optional[int]) -> None: ... - else: - def __init__(self, host: str, port: int) -> None: ... + def __init__(self, host: str, port: int) -> None: ... def makeSocket(self, timeout: float = ...) -> SocketType: ... # timeout is undocumented def makePickle(self, record: LogRecord) -> bytes: ... def send(self, s: bytes) -> None: ... @@ -140,13 +79,6 @@ class SysLogHandler(Handler): 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 @@ -157,8 +89,6 @@ class SysLogHandler(Handler): LOG_LOCAL7: int unixsocket: bool # undocumented socktype: SocketKind # undocumented - if sys.version_info >= (3,): - ident: str # undocumented facility: int # undocumented priority_names: ClassVar[Dict[str, int]] # undocumented facility_names: ClassVar[Dict[str, int]] # undocumented @@ -178,27 +108,15 @@ class NTEventLogHandler(Handler): class SMTPHandler(Handler): # TODO `secure` can also be an empty tuple - if sys.version_info >= (3,): - def __init__( - self, - mailhost: Union[str, Tuple[str, int]], - fromaddr: str, - toaddrs: List[str], - subject: str, - credentials: Optional[Tuple[str, str]] = ..., - secure: Union[Tuple[str], Tuple[str, str], None] = ..., - timeout: float = ..., - ) -> None: ... - else: - def __init__( - self, - mailhost: Union[str, Tuple[str, int]], - fromaddr: str, - toaddrs: List[str], - subject: str, - credentials: Optional[Tuple[str, str]] = ..., - secure: Union[Tuple[str], Tuple[str, str], None] = ..., - ) -> None: ... + def __init__( + self, + mailhost: Union[str, Tuple[str, int]], + fromaddr: str, + toaddrs: List[str], + subject: str, + credentials: Optional[Tuple[str, str]] = ..., + secure: Union[Tuple[str], Tuple[str, str], None] = ..., + ) -> None: ... def getSubject(self, record: LogRecord) -> str: ... class BufferingHandler(Handler): @@ -207,52 +125,9 @@ class BufferingHandler(Handler): def shouldFlush(self, record: LogRecord) -> bool: ... class MemoryHandler(BufferingHandler): - if sys.version_info >= (3, 6): - def __init__( - self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ..., flushOnClose: bool = ... - ) -> None: ... - else: - def __init__(self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ...) -> None: ... + def __init__(self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ...) -> None: ... def setTarget(self, target: Handler) -> None: ... class HTTPHandler(Handler): - if sys.version_info >= (3, 5): - def __init__( - self, - host: str, - url: str, - method: str = ..., - secure: bool = ..., - credentials: Optional[Tuple[str, str]] = ..., - context: Optional[ssl.SSLContext] = ..., - ) -> None: ... - elif sys.version_info >= (3,): - def __init__( - self, host: str, url: str, method: str = ..., secure: bool = ..., credentials: Optional[Tuple[str, str]] = ... - ) -> None: ... - else: - def __init__(self, host: str, url: str, method: str = ...) -> None: ... + def __init__(self, host: str, url: str, method: str = ...) -> None: ... def mapLogRecord(self, record: LogRecord) -> Dict[str, Any]: ... - -if sys.version_info >= (3,): - class QueueHandler(Handler): - if sys.version_info >= (3, 7): - def __init__(self, queue: Union[SimpleQueue[Any], Queue[Any]]) -> None: ... - else: - def __init__(self, queue: Queue[Any]) -> None: ... - def prepare(self, record: LogRecord) -> Any: ... - def enqueue(self, record: LogRecord) -> None: ... - class QueueListener: - if sys.version_info >= (3, 7): - def __init__( - self, queue: Union[SimpleQueue[Any], Queue[Any]], *handlers: Handler, respect_handler_level: bool = ... - ) -> None: ... - elif sys.version_info >= (3, 5): - def __init__(self, queue: Queue[Any], *handlers: Handler, respect_handler_level: bool = ...) -> None: ... - else: - def __init__(self, queue: Queue, *handlers: Handler) -> 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: ... diff --git a/stdlib/logging/__init__.pyi b/stdlib/logging/__init__.pyi index 865c527ac844..98ea4c84d113 100644 --- a/stdlib/logging/__init__.pyi +++ b/stdlib/logging/__init__.pyi @@ -4,31 +4,13 @@ from _typeshed import StrPath from string import Template from time import struct_time from types import FrameType, TracebackType -from typing import ( - IO, - Any, - Callable, - Dict, - Iterable, - List, - Mapping, - MutableMapping, - Optional, - Sequence, - Text, - Tuple, - Union, - overload, -) +from typing import IO, Any, Callable, Dict, Iterable, List, Mapping, MutableMapping, Optional, Sequence, Tuple, Union, overload _SysExcInfoType = Union[Tuple[type, BaseException, Optional[TracebackType]], Tuple[None, None, None]] -if sys.version_info >= (3, 5): - _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException] -else: - _ExcInfoType = Union[None, bool, _SysExcInfoType] +_ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException] _ArgsType = Union[Tuple[Any, ...], Mapping[str, Any]] _FilterType = Union[Filter, Callable[[LogRecord], int]] -_Level = Union[int, Text] +_Level = Union[int, str] raiseExceptions: bool logThreads: bool @@ -38,11 +20,8 @@ _srcfile: Optional[str] def currentframe() -> FrameType: ... -if sys.version_info >= (3,): - _levelToName: Dict[int, str] - _nameToLevel: Dict[str, int] -else: - _levelNames: Dict[Union[int, str], Union[str, int]] # Union[int:str, str:int] +_levelToName: Dict[int, str] +_nameToLevel: Dict[str, int] class Filterer(object): filters: List[Filter] @@ -155,7 +134,7 @@ class Logger(Filterer): stack_info: bool = ..., stacklevel: int = ..., ) -> None: ... # undocumented - elif sys.version_info >= (3,): + else: def debug( self, msg: Any, @@ -239,83 +218,28 @@ class Logger(Filterer): extra: Optional[Dict[str, Any]] = ..., stack_info: bool = ..., ) -> None: ... # undocumented - else: - def debug( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def info( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def warning( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - warn = warning - def error( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def critical( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - fatal = critical - def log( - self, - level: int, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... - def exception( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def _log( - self, - level: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_ExcInfoType] = ..., - extra: Optional[Dict[str, Any]] = ..., - ) -> None: ... # undocumented def filter(self, record: LogRecord) -> bool: ... def addHandler(self, hdlr: Handler) -> None: ... def removeHandler(self, hdlr: Handler) -> None: ... if sys.version_info >= (3, 8): def findCaller(self, stack_info: bool = ..., stacklevel: int = ...) -> Tuple[str, int, str, Optional[str]]: ... - elif sys.version_info >= (3,): - def findCaller(self, stack_info: bool = ...) -> Tuple[str, int, str, Optional[str]]: ... else: - def findCaller(self) -> Tuple[str, int, str]: ... + def findCaller(self, stack_info: bool = ...) -> Tuple[str, int, str, Optional[str]]: ... def handle(self, record: LogRecord) -> None: ... - if sys.version_info >= (3,): - def makeRecord( - self, - name: str, - level: int, - fn: str, - lno: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_SysExcInfoType], - func: Optional[str] = ..., - extra: Optional[Mapping[str, Any]] = ..., - sinfo: Optional[str] = ..., - ) -> LogRecord: ... - else: - def makeRecord( - self, - name: str, - level: int, - fn: str, - lno: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_SysExcInfoType], - func: Optional[str] = ..., - extra: Optional[Mapping[str, Any]] = ..., - ) -> LogRecord: ... - if sys.version_info >= (3,): - def hasHandlers(self) -> bool: ... + def makeRecord( + self, + name: str, + level: int, + fn: str, + lno: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_SysExcInfoType], + func: Optional[str] = ..., + extra: Optional[Mapping[str, Any]] = ..., + sinfo: Optional[str] = ..., + ) -> LogRecord: ... + def hasHandlers(self) -> bool: ... CRITICAL: int FATAL: int @@ -349,25 +273,21 @@ class Formatter: converter: Callable[[Optional[float]], struct_time] _fmt: Optional[str] datefmt: Optional[str] - if sys.version_info >= (3,): - _style: PercentStyle - default_time_format: str - default_msec_format: str + _style: PercentStyle + default_time_format: str + default_msec_format: str if sys.version_info >= (3, 8): def __init__( self, fmt: Optional[str] = ..., datefmt: Optional[str] = ..., style: str = ..., validate: bool = ... ) -> None: ... - elif sys.version_info >= (3,): - def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ..., style: str = ...) -> None: ... else: - def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ...) -> None: ... + def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ..., style: str = ...) -> None: ... def format(self, record: LogRecord) -> str: ... def formatTime(self, record: LogRecord, datefmt: Optional[str] = ...) -> str: ... def formatException(self, ei: _SysExcInfoType) -> str: ... - if sys.version_info >= (3,): - def formatMessage(self, record: LogRecord) -> str: ... # undocumented - def formatStack(self, stack_info: str) -> str: ... + def formatMessage(self, record: LogRecord) -> str: ... # undocumented + def formatStack(self, stack_info: str) -> str: ... class Filter: def __init__(self, name: str = ...) -> None: ... @@ -393,35 +313,21 @@ class LogRecord: process: int processName: str relativeCreated: int - if sys.version_info >= (3,): - stack_info: Optional[str] + stack_info: Optional[str] thread: int threadName: str - if sys.version_info >= (3,): - def __init__( - self, - name: str, - level: int, - pathname: str, - lineno: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_SysExcInfoType], - func: Optional[str] = ..., - sinfo: Optional[str] = ..., - ) -> None: ... - else: - def __init__( - self, - name: str, - level: int, - pathname: str, - lineno: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_SysExcInfoType], - func: Optional[str] = ..., - ) -> None: ... + def __init__( + self, + name: str, + level: int, + pathname: str, + lineno: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_SysExcInfoType], + func: Optional[str] = ..., + sinfo: Optional[str] = ..., + ) -> None: ... def getMessage(self) -> str: ... class LoggerAdapter: @@ -511,7 +417,7 @@ class LoggerAdapter: extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... - elif sys.version_info >= (3,): + else: def debug( self, msg: Any, @@ -585,63 +491,23 @@ class LoggerAdapter: extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... - else: - def debug( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def info( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def warning( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def error( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def exception( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def critical( - self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def log( - self, - level: int, - msg: Any, - *args: Any, - exc_info: _ExcInfoType = ..., - extra: Optional[Dict[str, Any]] = ..., - **kwargs: Any, - ) -> None: ... def isEnabledFor(self, level: int) -> bool: ... - if sys.version_info >= (3,): - def getEffectiveLevel(self) -> int: ... - def setLevel(self, level: Union[int, str]) -> None: ... - def hasHandlers(self) -> bool: ... - if sys.version_info >= (3, 6): - def _log( - self, - level: int, - msg: Any, - args: _ArgsType, - exc_info: Optional[_ExcInfoType] = ..., - extra: Optional[Dict[str, Any]] = ..., - stack_info: bool = ..., - ) -> None: ... # undocumented - -if sys.version_info >= (3,): - def getLogger(name: Optional[str] = ...) -> Logger: ... - -else: - @overload - def getLogger() -> Logger: ... - @overload - def getLogger(name: Union[Text, str]) -> Logger: ... + def getEffectiveLevel(self) -> int: ... + def setLevel(self, level: Union[int, str]) -> None: ... + def hasHandlers(self) -> bool: ... + def _log( + self, + level: int, + msg: Any, + args: _ArgsType, + exc_info: Optional[_ExcInfoType] = ..., + extra: Optional[Dict[str, Any]] = ..., + stack_info: bool = ..., + ) -> None: ... # undocumented +def getLogger(name: Optional[str] = ...) -> Logger: ... def getLoggerClass() -> type: ... - -if sys.version_info >= (3,): - def getLogRecordFactory() -> Callable[..., LogRecord]: ... +def getLogRecordFactory() -> Callable[..., LogRecord]: ... if sys.version_info >= (3, 8): def debug( @@ -718,7 +584,7 @@ if sys.version_info >= (3, 8): **kwargs: Any, ) -> None: ... -elif sys.version_info >= (3,): +else: def debug( msg: Any, *args: Any, @@ -785,30 +651,6 @@ elif sys.version_info >= (3,): **kwargs: Any, ) -> None: ... -else: - def debug( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def info( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def warning( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - warn = warning - def error( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def critical( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def exception( - msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - def log( - level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any - ) -> None: ... - fatal = critical if sys.version_info >= (3, 7): @@ -835,7 +677,7 @@ if sys.version_info >= (3, 8): force: bool = ..., ) -> None: ... -elif sys.version_info >= (3,): +else: def basicConfig( *, filename: Optional[StrPath] = ..., @@ -848,34 +690,16 @@ elif sys.version_info >= (3,): handlers: Optional[Iterable[Handler]] = ..., ) -> None: ... -else: - @overload - def basicConfig() -> None: ... - @overload - def basicConfig( - *, - filename: Optional[str] = ..., - filemode: str = ..., - format: str = ..., - datefmt: Optional[str] = ..., - level: Optional[_Level] = ..., - stream: IO[str] = ..., - ) -> None: ... - def shutdown(handlerList: Sequence[Any] = ...) -> None: ... # handlerList is undocumented def setLoggerClass(klass: type) -> None: ... def captureWarnings(capture: bool) -> None: ... +def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ... -if sys.version_info >= (3,): - def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ... - -if sys.version_info >= (3,): - lastResort: Optional[StreamHandler] +lastResort: Optional[StreamHandler] class StreamHandler(Handler): stream: IO[str] # undocumented - if sys.version_info >= (3, 2): - terminator: str + terminator: str def __init__(self, stream: Optional[IO[str]] = ...) -> None: ... if sys.version_info >= (3, 7): def setStream(self, stream: IO[str]) -> Optional[IO[str]]: ... @@ -901,18 +725,20 @@ class RootLogger(Logger): root: RootLogger -if sys.version_info >= (3,): - class PercentStyle(object): - default_format: str - asctime_format: str - asctime_search: str - _fmt: str - def __init__(self, fmt: str) -> None: ... - def usesTime(self) -> bool: ... - def format(self, record: Any) -> str: ... - class StrFormatStyle(PercentStyle): ... - class StringTemplateStyle(PercentStyle): - _tpl: Template - _STYLES: Dict[str, Tuple[PercentStyle, str]] +class PercentStyle(object): + default_format: str + asctime_format: str + asctime_search: str + _fmt: str + def __init__(self, fmt: str) -> None: ... + def usesTime(self) -> bool: ... + def format(self, record: Any) -> str: ... + +class StrFormatStyle(PercentStyle): ... + +class StringTemplateStyle(PercentStyle): + _tpl: Template + +_STYLES: Dict[str, Tuple[PercentStyle, str]] BASIC_FORMAT: str diff --git a/stdlib/logging/config.pyi b/stdlib/logging/config.pyi index 535d583d759a..96aa05c0fe70 100644 --- a/stdlib/logging/config.pyi +++ b/stdlib/logging/config.pyi @@ -1,32 +1,19 @@ import sys from _typeshed import AnyPath, StrPath +from configparser import RawConfigParser from threading import Thread from typing import IO, Any, Callable, Dict, Optional, Union -if sys.version_info >= (3,): - from configparser import RawConfigParser -else: - from ConfigParser import RawConfigParser - if sys.version_info >= (3, 7): _Path = AnyPath else: _Path = StrPath def dictConfig(config: Dict[str, Any]) -> None: ... - -if sys.version_info >= (3, 4): - def fileConfig( - fname: Union[_Path, IO[str], RawConfigParser], - defaults: Optional[Dict[str, str]] = ..., - disable_existing_loggers: bool = ..., - ) -> None: ... - def listen(port: int = ..., verify: Optional[Callable[[bytes], Optional[bytes]]] = ...) -> Thread: ... - -else: - def fileConfig( - fname: Union[str, IO[str]], defaults: Optional[Dict[str, str]] = ..., disable_existing_loggers: bool = ... - ) -> None: ... - def listen(port: int = ...) -> Thread: ... - +def fileConfig( + fname: Union[_Path, IO[str], RawConfigParser], + defaults: Optional[Dict[str, str]] = ..., + disable_existing_loggers: bool = ..., +) -> None: ... +def listen(port: int = ..., verify: Optional[Callable[[bytes], Optional[bytes]]] = ...) -> Thread: ... def stopListening() -> None: ... diff --git a/stdlib/logging/handlers.pyi b/stdlib/logging/handlers.pyi index 3c726fc2a3c0..f3448292d379 100644 --- a/stdlib/logging/handlers.pyi +++ b/stdlib/logging/handlers.pyi @@ -8,10 +8,8 @@ from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple, Union if sys.version_info >= (3, 7): from queue import Queue, SimpleQueue -elif sys.version_info >= (3,): - from queue import Queue else: - from Queue import Queue + from queue import Queue DEFAULT_TCP_LOGGING_PORT: int DEFAULT_UDP_LOGGING_PORT: int @@ -26,90 +24,45 @@ class WatchedFileHandler(FileHandler): def __init__(self, filename: StrPath, mode: str = ..., encoding: Optional[str] = ..., delay: bool = ...) -> None: ... def _statstream(self) -> None: ... -if sys.version_info >= (3,): - class BaseRotatingHandler(FileHandler): - terminator: str - namer: Optional[Callable[[str], str]] - rotator: Optional[Callable[[str, str], None]] - def __init__(self, filename: StrPath, mode: str, encoding: Optional[str] = ..., delay: bool = ...) -> None: ... - def rotation_filename(self, default_name: str) -> None: ... - def rotate(self, source: str, dest: str) -> None: ... - -if sys.version_info >= (3,): - class RotatingFileHandler(BaseRotatingHandler): - def __init__( - self, - filename: StrPath, - mode: str = ..., - maxBytes: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - ) -> None: ... - def doRollover(self) -> None: ... - -else: - class RotatingFileHandler(Handler): - def __init__( - self, - filename: str, - mode: str = ..., - maxBytes: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - ) -> None: ... - def doRollover(self) -> None: ... +class BaseRotatingHandler(FileHandler): + terminator: str + namer: Optional[Callable[[str], str]] + rotator: Optional[Callable[[str, str], None]] + def __init__(self, filename: StrPath, mode: str, encoding: Optional[str] = ..., delay: bool = ...) -> None: ... + def rotation_filename(self, default_name: str) -> None: ... + def rotate(self, source: str, dest: str) -> None: ... -if sys.version_info >= (3,): - class TimedRotatingFileHandler(BaseRotatingHandler): - if sys.version_info >= (3, 4): - def __init__( - self, - filename: StrPath, - when: str = ..., - interval: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - utc: bool = ..., - atTime: Optional[datetime.datetime] = ..., - ) -> None: ... - else: - def __init__( - self, - filename: str, - when: str = ..., - interval: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - utc: bool = ..., - ) -> None: ... - def doRollover(self) -> None: ... +class RotatingFileHandler(BaseRotatingHandler): + def __init__( + self, + filename: StrPath, + mode: str = ..., + maxBytes: int = ..., + backupCount: int = ..., + encoding: Optional[str] = ..., + delay: bool = ..., + ) -> None: ... + def doRollover(self) -> None: ... -else: - class TimedRotatingFileHandler(Handler): - def __init__( - self, - filename: str, - when: str = ..., - interval: int = ..., - backupCount: int = ..., - encoding: Optional[str] = ..., - delay: bool = ..., - utc: bool = ..., - ) -> None: ... - def doRollover(self) -> None: ... +class TimedRotatingFileHandler(BaseRotatingHandler): + def __init__( + self, + filename: StrPath, + when: str = ..., + interval: int = ..., + backupCount: int = ..., + encoding: Optional[str] = ..., + delay: bool = ..., + utc: bool = ..., + atTime: Optional[datetime.datetime] = ..., + ) -> None: ... + def doRollover(self) -> None: ... class SocketHandler(Handler): retryStart: float retryFactor: float retryMax: float - if sys.version_info >= (3, 4): - def __init__(self, host: str, port: Optional[int]) -> None: ... - else: - def __init__(self, host: str, port: int) -> None: ... + def __init__(self, host: str, port: Optional[int]) -> None: ... def makeSocket(self, timeout: float = ...) -> SocketType: ... # timeout is undocumented def makePickle(self, record: LogRecord) -> bytes: ... def send(self, s: bytes) -> None: ... @@ -157,8 +110,7 @@ class SysLogHandler(Handler): LOG_LOCAL7: int unixsocket: bool # undocumented socktype: SocketKind # undocumented - if sys.version_info >= (3,): - ident: str # undocumented + ident: str # undocumented facility: int # undocumented priority_names: ClassVar[Dict[str, int]] # undocumented facility_names: ClassVar[Dict[str, int]] # undocumented @@ -178,27 +130,16 @@ class NTEventLogHandler(Handler): class SMTPHandler(Handler): # TODO `secure` can also be an empty tuple - if sys.version_info >= (3,): - def __init__( - self, - mailhost: Union[str, Tuple[str, int]], - fromaddr: str, - toaddrs: List[str], - subject: str, - credentials: Optional[Tuple[str, str]] = ..., - secure: Union[Tuple[str], Tuple[str, str], None] = ..., - timeout: float = ..., - ) -> None: ... - else: - def __init__( - self, - mailhost: Union[str, Tuple[str, int]], - fromaddr: str, - toaddrs: List[str], - subject: str, - credentials: Optional[Tuple[str, str]] = ..., - secure: Union[Tuple[str], Tuple[str, str], None] = ..., - ) -> None: ... + def __init__( + self, + mailhost: Union[str, Tuple[str, int]], + fromaddr: str, + toaddrs: List[str], + subject: str, + credentials: Optional[Tuple[str, str]] = ..., + secure: Union[Tuple[str], Tuple[str, str], None] = ..., + timeout: float = ..., + ) -> None: ... def getSubject(self, record: LogRecord) -> str: ... class BufferingHandler(Handler): @@ -207,52 +148,40 @@ class BufferingHandler(Handler): def shouldFlush(self, record: LogRecord) -> bool: ... class MemoryHandler(BufferingHandler): - if sys.version_info >= (3, 6): - def __init__( - self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ..., flushOnClose: bool = ... - ) -> None: ... - else: - def __init__(self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ...) -> None: ... + def __init__( + self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ..., flushOnClose: bool = ... + ) -> None: ... def setTarget(self, target: Handler) -> None: ... class HTTPHandler(Handler): - if sys.version_info >= (3, 5): - def __init__( - self, - host: str, - url: str, - method: str = ..., - secure: bool = ..., - credentials: Optional[Tuple[str, str]] = ..., - context: Optional[ssl.SSLContext] = ..., - ) -> None: ... - elif sys.version_info >= (3,): + def __init__( + self, + host: str, + url: str, + method: str = ..., + secure: bool = ..., + credentials: Optional[Tuple[str, str]] = ..., + context: Optional[ssl.SSLContext] = ..., + ) -> None: ... + def mapLogRecord(self, record: LogRecord) -> Dict[str, Any]: ... + +class QueueHandler(Handler): + if sys.version_info >= (3, 7): + def __init__(self, queue: Union[SimpleQueue[Any], Queue[Any]]) -> None: ... + else: + def __init__(self, queue: Queue[Any]) -> None: ... + def prepare(self, record: LogRecord) -> Any: ... + def enqueue(self, record: LogRecord) -> None: ... + +class QueueListener: + if sys.version_info >= (3, 7): def __init__( - self, host: str, url: str, method: str = ..., secure: bool = ..., credentials: Optional[Tuple[str, str]] = ... + self, queue: Union[SimpleQueue[Any], Queue[Any]], *handlers: Handler, respect_handler_level: bool = ... ) -> None: ... else: - def __init__(self, host: str, url: str, method: str = ...) -> None: ... - def mapLogRecord(self, record: LogRecord) -> Dict[str, Any]: ... - -if sys.version_info >= (3,): - class QueueHandler(Handler): - if sys.version_info >= (3, 7): - def __init__(self, queue: Union[SimpleQueue[Any], Queue[Any]]) -> None: ... - else: - def __init__(self, queue: Queue[Any]) -> None: ... - def prepare(self, record: LogRecord) -> Any: ... - def enqueue(self, record: LogRecord) -> None: ... - class QueueListener: - if sys.version_info >= (3, 7): - def __init__( - self, queue: Union[SimpleQueue[Any], Queue[Any]], *handlers: Handler, respect_handler_level: bool = ... - ) -> None: ... - elif sys.version_info >= (3, 5): - def __init__(self, queue: Queue[Any], *handlers: Handler, respect_handler_level: bool = ...) -> None: ... - else: - def __init__(self, queue: Queue, *handlers: Handler) -> 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 __init__(self, queue: Queue[Any], *handlers: Handler, respect_handler_level: bool = ...) -> 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: ... From 3723b19f1c1f89e7d876ab028a7b2e66073973bc Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Wed, 24 Feb 2021 22:44:22 +0100 Subject: [PATCH 3/7] Use builtin collections for logging --- stdlib/logging/__init__.pyi | 123 ++++++++++++++++++------------------ stdlib/logging/config.pyi | 7 +- stdlib/logging/handlers.pyi | 25 ++++---- 3 files changed, 79 insertions(+), 76 deletions(-) diff --git a/stdlib/logging/__init__.pyi b/stdlib/logging/__init__.pyi index 98ea4c84d113..97c1a8ec3913 100644 --- a/stdlib/logging/__init__.pyi +++ b/stdlib/logging/__init__.pyi @@ -1,12 +1,13 @@ import sys import threading from _typeshed import StrPath +from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence, Tuple from string import Template from time import struct_time from types import FrameType, TracebackType -from typing import IO, Any, Callable, Dict, Iterable, List, Mapping, MutableMapping, Optional, Sequence, Tuple, Union, overload +from typing import IO, Any, Optional, Union, overload -_SysExcInfoType = Union[Tuple[type, BaseException, Optional[TracebackType]], Tuple[None, None, None]] +_SysExcInfoType = Union[tuple[type, BaseException, Optional[TracebackType]], tuple[None, None, None]] _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException] _ArgsType = Union[Tuple[Any, ...], Mapping[str, Any]] _FilterType = Union[Filter, Callable[[LogRecord], int]] @@ -20,11 +21,11 @@ _srcfile: Optional[str] def currentframe() -> FrameType: ... -_levelToName: Dict[int, str] -_nameToLevel: Dict[str, int] +_levelToName: dict[int, str] +_nameToLevel: dict[str, int] class Filterer(object): - filters: List[Filter] + filters: list[Filter] def __init__(self) -> None: ... def addFilter(self, filter: _FilterType) -> None: ... def removeFilter(self, filter: _FilterType) -> None: ... @@ -35,7 +36,7 @@ class Logger(Filterer): level: int parent: Union[Logger, PlaceHolder] propagate: bool - handlers: List[Handler] + handlers: list[Handler] disabled: int def __init__(self, name: str, level: _Level = ...) -> None: ... def setLevel(self, level: _Level) -> None: ... @@ -50,7 +51,7 @@ class Logger(Filterer): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( @@ -60,7 +61,7 @@ class Logger(Filterer): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( @@ -70,7 +71,7 @@ class Logger(Filterer): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( @@ -80,7 +81,7 @@ class Logger(Filterer): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( @@ -90,7 +91,7 @@ class Logger(Filterer): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( @@ -100,7 +101,7 @@ class Logger(Filterer): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( @@ -110,7 +111,7 @@ class Logger(Filterer): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( @@ -121,7 +122,7 @@ class Logger(Filterer): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def _log( @@ -130,7 +131,7 @@ class Logger(Filterer): msg: Any, args: _ArgsType, exc_info: Optional[_ExcInfoType] = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., stack_info: bool = ..., stacklevel: int = ..., ) -> None: ... # undocumented @@ -141,7 +142,7 @@ class Logger(Filterer): *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( @@ -150,7 +151,7 @@ class Logger(Filterer): *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( @@ -159,7 +160,7 @@ class Logger(Filterer): *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( @@ -168,7 +169,7 @@ class Logger(Filterer): *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( @@ -177,7 +178,7 @@ class Logger(Filterer): *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( @@ -186,7 +187,7 @@ class Logger(Filterer): *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... fatal = critical @@ -197,7 +198,7 @@ class Logger(Filterer): *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( @@ -206,7 +207,7 @@ class Logger(Filterer): *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def _log( @@ -215,16 +216,16 @@ class Logger(Filterer): msg: Any, args: _ArgsType, exc_info: Optional[_ExcInfoType] = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., stack_info: bool = ..., ) -> None: ... # undocumented def filter(self, record: LogRecord) -> bool: ... def addHandler(self, hdlr: Handler) -> None: ... def removeHandler(self, hdlr: Handler) -> None: ... if sys.version_info >= (3, 8): - def findCaller(self, stack_info: bool = ..., stacklevel: int = ...) -> Tuple[str, int, str, Optional[str]]: ... + def findCaller(self, stack_info: bool = ..., stacklevel: int = ...) -> tuple[str, int, str, Optional[str]]: ... else: - def findCaller(self, stack_info: bool = ...) -> Tuple[str, int, str, Optional[str]]: ... + def findCaller(self, stack_info: bool = ...) -> tuple[str, int, str, Optional[str]]: ... def handle(self, record: LogRecord) -> None: ... def makeRecord( self, @@ -334,7 +335,7 @@ class LoggerAdapter: logger: Logger extra: Mapping[str, Any] def __init__(self, logger: Logger, extra: Mapping[str, Any]) -> None: ... - def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> Tuple[Any, MutableMapping[str, Any]]: ... + def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> tuple[Any, MutableMapping[str, Any]]: ... if sys.version_info >= (3, 8): def debug( self, @@ -343,7 +344,7 @@ class LoggerAdapter: exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( @@ -353,7 +354,7 @@ class LoggerAdapter: exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( @@ -363,7 +364,7 @@ class LoggerAdapter: exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( @@ -373,7 +374,7 @@ class LoggerAdapter: exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( @@ -383,7 +384,7 @@ class LoggerAdapter: exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( @@ -393,7 +394,7 @@ class LoggerAdapter: exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( @@ -403,7 +404,7 @@ class LoggerAdapter: exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( @@ -414,7 +415,7 @@ class LoggerAdapter: exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... else: @@ -424,7 +425,7 @@ class LoggerAdapter: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( @@ -433,7 +434,7 @@ class LoggerAdapter: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( @@ -442,7 +443,7 @@ class LoggerAdapter: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( @@ -451,7 +452,7 @@ class LoggerAdapter: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( @@ -460,7 +461,7 @@ class LoggerAdapter: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( @@ -469,7 +470,7 @@ class LoggerAdapter: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( @@ -478,7 +479,7 @@ class LoggerAdapter: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( @@ -488,7 +489,7 @@ class LoggerAdapter: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def isEnabledFor(self, level: int) -> bool: ... @@ -501,7 +502,7 @@ class LoggerAdapter: msg: Any, args: _ArgsType, exc_info: Optional[_ExcInfoType] = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., stack_info: bool = ..., ) -> None: ... # undocumented @@ -516,7 +517,7 @@ if sys.version_info >= (3, 8): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( @@ -525,7 +526,7 @@ if sys.version_info >= (3, 8): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( @@ -534,7 +535,7 @@ if sys.version_info >= (3, 8): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( @@ -543,7 +544,7 @@ if sys.version_info >= (3, 8): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( @@ -552,7 +553,7 @@ if sys.version_info >= (3, 8): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( @@ -561,7 +562,7 @@ if sys.version_info >= (3, 8): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( @@ -570,7 +571,7 @@ if sys.version_info >= (3, 8): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( @@ -580,7 +581,7 @@ if sys.version_info >= (3, 8): exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... @@ -590,7 +591,7 @@ else: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( @@ -598,7 +599,7 @@ else: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( @@ -606,7 +607,7 @@ else: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( @@ -614,7 +615,7 @@ else: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( @@ -622,7 +623,7 @@ else: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( @@ -630,7 +631,7 @@ else: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( @@ -638,7 +639,7 @@ else: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( @@ -647,7 +648,7 @@ else: *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., - extra: Optional[Dict[str, Any]] = ..., + extra: Optional[dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... @@ -739,6 +740,6 @@ class StrFormatStyle(PercentStyle): ... class StringTemplateStyle(PercentStyle): _tpl: Template -_STYLES: Dict[str, Tuple[PercentStyle, str]] +_STYLES: dict[str, tuple[PercentStyle, str]] BASIC_FORMAT: str diff --git a/stdlib/logging/config.pyi b/stdlib/logging/config.pyi index 96aa05c0fe70..c159cf7c99fc 100644 --- a/stdlib/logging/config.pyi +++ b/stdlib/logging/config.pyi @@ -1,18 +1,19 @@ import sys from _typeshed import AnyPath, StrPath +from collections.anc import Callable from configparser import RawConfigParser from threading import Thread -from typing import IO, Any, Callable, Dict, Optional, Union +from typing import IO, Any, Optional, Union if sys.version_info >= (3, 7): _Path = AnyPath else: _Path = StrPath -def dictConfig(config: Dict[str, Any]) -> None: ... +def dictConfig(config: dict[str, Any]) -> None: ... def fileConfig( fname: Union[_Path, IO[str], RawConfigParser], - defaults: Optional[Dict[str, str]] = ..., + defaults: Optional[dict[str, str]] = ..., disable_existing_loggers: bool = ..., ) -> None: ... def listen(port: int = ..., verify: Optional[Callable[[bytes], Optional[bytes]]] = ...) -> Thread: ... diff --git a/stdlib/logging/handlers.pyi b/stdlib/logging/handlers.pyi index f3448292d379..4c20d4af2b56 100644 --- a/stdlib/logging/handlers.pyi +++ b/stdlib/logging/handlers.pyi @@ -2,9 +2,10 @@ import datetime import ssl import sys from _typeshed import StrPath +from collections.abc import Callable from logging import FileHandler, Handler, LogRecord from socket import SocketKind, SocketType -from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple, Union +from typing import Any, ClassVar, Optional, Union if sys.version_info >= (3, 7): from queue import Queue, SimpleQueue @@ -112,11 +113,11 @@ class SysLogHandler(Handler): socktype: SocketKind # undocumented ident: str # 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 + 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: Union[Tuple[str, int], str] = ..., facility: int = ..., socktype: Optional[SocketKind] = ... + self, address: Union[tuple[str, int], str] = ..., facility: int = ..., socktype: Optional[SocketKind] = ... ) -> None: ... def encodePriority(self, facility: Union[int, str], priority: Union[int, str]) -> int: ... def mapPriority(self, levelName: str) -> str: ... @@ -132,18 +133,18 @@ class SMTPHandler(Handler): # TODO `secure` can also be an empty tuple def __init__( self, - mailhost: Union[str, Tuple[str, int]], + mailhost: Union[str, tuple[str, int]], fromaddr: str, - toaddrs: List[str], + toaddrs: list[str], subject: str, - credentials: Optional[Tuple[str, str]] = ..., - secure: Union[Tuple[str], Tuple[str, str], None] = ..., + credentials: Optional[tuple[str, str]] = ..., + secure: Union[tuple[str], tuple[str, str], None] = ..., timeout: float = ..., ) -> None: ... def getSubject(self, record: LogRecord) -> str: ... class BufferingHandler(Handler): - buffer: List[LogRecord] + buffer: list[LogRecord] def __init__(self, capacity: int) -> None: ... def shouldFlush(self, record: LogRecord) -> bool: ... @@ -160,10 +161,10 @@ class HTTPHandler(Handler): url: str, method: str = ..., secure: bool = ..., - credentials: Optional[Tuple[str, str]] = ..., + credentials: Optional[tuple[str, str]] = ..., context: Optional[ssl.SSLContext] = ..., ) -> None: ... - def mapLogRecord(self, record: LogRecord) -> Dict[str, Any]: ... + def mapLogRecord(self, record: LogRecord) -> dict[str, Any]: ... class QueueHandler(Handler): if sys.version_info >= (3, 7): From 8d75f6fac2d6562190132ce5a7b9aba8ef19cbe6 Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Wed, 24 Feb 2021 22:50:25 +0100 Subject: [PATCH 4/7] Fixes --- stdlib/logging/__init__.pyi | 4 ++-- stdlib/logging/config.pyi | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/stdlib/logging/__init__.pyi b/stdlib/logging/__init__.pyi index 97c1a8ec3913..6ccea201e73f 100644 --- a/stdlib/logging/__init__.pyi +++ b/stdlib/logging/__init__.pyi @@ -1,11 +1,11 @@ import sys import threading from _typeshed import StrPath -from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence, Tuple +from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence from string import Template from time import struct_time from types import FrameType, TracebackType -from typing import IO, Any, Optional, Union, overload +from typing import IO, Any, Optional, Tuple, Union, overload _SysExcInfoType = Union[tuple[type, BaseException, Optional[TracebackType]], tuple[None, None, None]] _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException] diff --git a/stdlib/logging/config.pyi b/stdlib/logging/config.pyi index c159cf7c99fc..89fa555faa8f 100644 --- a/stdlib/logging/config.pyi +++ b/stdlib/logging/config.pyi @@ -1,6 +1,6 @@ import sys from _typeshed import AnyPath, StrPath -from collections.anc import Callable +from collections.abc import Callable from configparser import RawConfigParser from threading import Thread from typing import IO, Any, Optional, Union From 187ea2006cc84c2bc54aec00dbfcc1362c78ea1a Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Wed, 24 Feb 2021 22:56:28 +0100 Subject: [PATCH 5/7] Work around mypy tuple bug --- stdlib/logging/__init__.pyi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stdlib/logging/__init__.pyi b/stdlib/logging/__init__.pyi index 6ccea201e73f..46d3c2dea895 100644 --- a/stdlib/logging/__init__.pyi +++ b/stdlib/logging/__init__.pyi @@ -7,7 +7,7 @@ from time import struct_time from types import FrameType, TracebackType from typing import IO, Any, Optional, Tuple, Union, overload -_SysExcInfoType = Union[tuple[type, BaseException, Optional[TracebackType]], tuple[None, None, None]] +_SysExcInfoType = Union[Tuple[type, BaseException, Optional[TracebackType]], Tuple[None, None, None]] _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException] _ArgsType = Union[Tuple[Any, ...], Mapping[str, Any]] _FilterType = Union[Filter, Callable[[LogRecord], int]] From e59d14eb6ca91912545b0d27e151bf93eb2073a7 Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Wed, 24 Feb 2021 22:57:37 +0100 Subject: [PATCH 6/7] Remove unused import --- stdlib/logging/__init__.pyi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stdlib/logging/__init__.pyi b/stdlib/logging/__init__.pyi index 46d3c2dea895..e78175c12d9a 100644 --- a/stdlib/logging/__init__.pyi +++ b/stdlib/logging/__init__.pyi @@ -5,7 +5,7 @@ from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequenc from string import Template from time import struct_time from types import FrameType, TracebackType -from typing import IO, Any, Optional, Tuple, Union, overload +from typing import IO, Any, Optional, Tuple, Union _SysExcInfoType = Union[Tuple[type, BaseException, Optional[TracebackType]], Tuple[None, None, None]] _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException] From 0b604f5fc1ba9ba27ffc18803bf5aaea51e73631 Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Wed, 24 Feb 2021 23:30:40 +0100 Subject: [PATCH 7/7] Use SupportsWrite instead of IO --- stdlib/logging/__init__.pyi | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/stdlib/logging/__init__.pyi b/stdlib/logging/__init__.pyi index e78175c12d9a..dc2eebeab457 100644 --- a/stdlib/logging/__init__.pyi +++ b/stdlib/logging/__init__.pyi @@ -1,6 +1,6 @@ import sys import threading -from _typeshed import StrPath +from _typeshed import StrPath, SupportsWrite from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence from string import Template from time import struct_time @@ -673,7 +673,7 @@ if sys.version_info >= (3, 8): datefmt: Optional[str] = ..., style: str = ..., level: Optional[_Level] = ..., - stream: Optional[IO[str]] = ..., + stream: Optional[SupportsWrite[str]] = ..., handlers: Optional[Iterable[Handler]] = ..., force: bool = ..., ) -> None: ... @@ -687,7 +687,7 @@ else: datefmt: Optional[str] = ..., style: str = ..., level: Optional[_Level] = ..., - stream: Optional[IO[str]] = ..., + stream: Optional[SupportsWrite[str]] = ..., handlers: Optional[Iterable[Handler]] = ..., ) -> None: ... @@ -699,11 +699,11 @@ def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ... lastResort: Optional[StreamHandler] class StreamHandler(Handler): - stream: IO[str] # undocumented + stream: SupportsWrite[str] # undocumented terminator: str - def __init__(self, stream: Optional[IO[str]] = ...) -> None: ... + def __init__(self, stream: Optional[SupportsWrite[str]] = ...) -> None: ... if sys.version_info >= (3, 7): - def setStream(self, stream: IO[str]) -> Optional[IO[str]]: ... + def setStream(self, stream: SupportsWrite[str]) -> Optional[SupportsWrite[str]]: ... class FileHandler(StreamHandler): baseFilename: str # undocumented