.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stdlib/logging/__init__.pyi

   1 import sys
   2 import threading
   3 from _typeshed import StrPath, SupportsWrite
   4 from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence
   5 from io import TextIOWrapper
   6 from string import Template
   7 from time import struct_time
   8 from types import FrameType, TracebackType
   9 from typing import Any, ClassVar, Generic, Optional, Pattern, TextIO, Tuple, Type, TypeVar, Union, overload
  10 from typing_extensions import Literal
  11
  12 _SysExcInfoType = Union[Tuple[Type[BaseException], BaseException, Optional[TracebackType]], Tuple[None, None, None]]
  13 _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException]
  14 _ArgsType = Union[Tuple[object, ...], Mapping[str, object]]
  15 _FilterType = Union[Filter, Callable[[LogRecord], int]]
  16 _Level = Union[int, str]
  17 _FormatStyle = Literal["%", "{", "$"]
  18
  19 raiseExceptions: bool
  20 logThreads: bool
  21 logMultiprocessing: bool
  22 logProcesses: bool
  23 _srcfile: str | None
  24
  25 def currentframe() -> FrameType: ...
  26
  27 _levelToName: dict[int, str]
  28 _nameToLevel: dict[str, int]
  29
  30 class Filterer(object):
  31     filters: list[Filter]
  32     def __init__(self) -> None: ...
  33     def addFilter(self, filter: _FilterType) -> None: ...
  34     def removeFilter(self, filter: _FilterType) -> None: ...
  35     def filter(self, record: LogRecord) -> bool: ...
  36
  37 class Manager(object):  # undocumented
  38     root: RootLogger
  39     disable: int
  40     emittedNoHandlerWarning: bool
  41     loggerDict: dict[str, Logger | PlaceHolder]
  42     loggerClass: Type[Logger] | None
  43     logRecordFactory: Callable[..., LogRecord] | None
  44     def __init__(self, rootnode: RootLogger) -> None: ...
  45     def getLogger(self, name: str) -> Logger: ...
  46     def setLoggerClass(self, klass: Type[Logger]) -> None: ...
  47     def setLogRecordFactory(self, factory: Callable[..., LogRecord]) -> None: ...
  48
  49 class Logger(Filterer):
  50     name: str  # undocumented
  51     level: int  # undocumented
  52     parent: Logger | None  # undocumented
  53     propagate: bool
  54     handlers: list[Handler]  # undocumented
  55     disabled: bool  # undocumented
  56     root: ClassVar[RootLogger]  # undocumented
  57     manager: Manager  # undocumented
  58     def __init__(self, name: str, level: _Level = ...) -> None: ...
  59     def setLevel(self, level: _Level) -> None: ...
  60     def isEnabledFor(self, level: int) -> bool: ...
  61     def getEffectiveLevel(self) -> int: ...
  62     def getChild(self, suffix: str) -> Logger: ...
  63     if sys.version_info >= (3, 8):
  64         def debug(
  65             self,
  66             msg: object,
  67             *args: object,
  68             exc_info: _ExcInfoType = ...,
  69             stack_info: bool = ...,
  70             stacklevel: int = ...,
  71             extra: Mapping[str, object] | None = ...,
  72         ) -> None: ...
  73         def info(
  74             self,
  75             msg: object,
  76             *args: object,
  77             exc_info: _ExcInfoType = ...,
  78             stack_info: bool = ...,
  79             stacklevel: int = ...,
  80             extra: Mapping[str, object] | None = ...,
  81         ) -> None: ...
  82         def warning(
  83             self,
  84             msg: object,
  85             *args: object,
  86             exc_info: _ExcInfoType = ...,
  87             stack_info: bool = ...,
  88             stacklevel: int = ...,
  89             extra: Mapping[str, object] | None = ...,
  90         ) -> None: ...
  91         def warn(
  92             self,
  93             msg: object,
  94             *args: object,
  95             exc_info: _ExcInfoType = ...,
  96             stack_info: bool = ...,
  97             stacklevel: int = ...,
  98             extra: Mapping[str, object] | None = ...,
  99         ) -> None: ...
 100         def error(
 101             self,
 102             msg: object,
 103             *args: object,
 104             exc_info: _ExcInfoType = ...,
 105             stack_info: bool = ...,
 106             stacklevel: int = ...,
 107             extra: Mapping[str, object] | None = ...,
 108         ) -> None: ...
 109         def exception(
 110             self,
 111             msg: object,
 112             *args: object,
 113             exc_info: _ExcInfoType = ...,
 114             stack_info: bool = ...,
 115             stacklevel: int = ...,
 116             extra: Mapping[str, object] | None = ...,
 117         ) -> None: ...
 118         def critical(
 119             self,
 120             msg: object,
 121             *args: object,
 122             exc_info: _ExcInfoType = ...,
 123             stack_info: bool = ...,
 124             stacklevel: int = ...,
 125             extra: Mapping[str, object] | None = ...,
 126         ) -> None: ...
 127         def log(
 128             self,
 129             level: int,
 130             msg: object,
 131             *args: object,
 132             exc_info: _ExcInfoType = ...,
 133             stack_info: bool = ...,
 134             stacklevel: int = ...,
 135             extra: Mapping[str, object] | None = ...,
 136         ) -> None: ...
 137         def _log(
 138             self,
 139             level: int,
 140             msg: object,
 141             args: _ArgsType,
 142             exc_info: _ExcInfoType | None = ...,
 143             extra: Mapping[str, object] | None = ...,
 144             stack_info: bool = ...,
 145             stacklevel: int = ...,
 146         ) -> None: ...  # undocumented
 147     else:
 148         def debug(
 149             self,
 150             msg: object,
 151             *args: object,
 152             exc_info: _ExcInfoType = ...,
 153             stack_info: bool = ...,
 154             extra: Mapping[str, object] | None = ...,
 155         ) -> None: ...
 156         def info(
 157             self,
 158             msg: object,
 159             *args: object,
 160             exc_info: _ExcInfoType = ...,
 161             stack_info: bool = ...,
 162             extra: Mapping[str, object] | None = ...,
 163         ) -> None: ...
 164         def warning(
 165             self,
 166             msg: object,
 167             *args: object,
 168             exc_info: _ExcInfoType = ...,
 169             stack_info: bool = ...,
 170             extra: Mapping[str, object] | None = ...,
 171         ) -> None: ...
 172         def warn(
 173             self,
 174             msg: object,
 175             *args: object,
 176             exc_info: _ExcInfoType = ...,
 177             stack_info: bool = ...,
 178             extra: Mapping[str, object] | None = ...,
 179         ) -> None: ...
 180         def error(
 181             self,
 182             msg: object,
 183             *args: object,
 184             exc_info: _ExcInfoType = ...,
 185             stack_info: bool = ...,
 186             extra: Mapping[str, object] | None = ...,
 187         ) -> None: ...
 188         def critical(
 189             self,
 190             msg: object,
 191             *args: object,
 192             exc_info: _ExcInfoType = ...,
 193             stack_info: bool = ...,
 194             extra: Mapping[str, object] | None = ...,
 195         ) -> None: ...
 196         def log(
 197             self,
 198             level: int,
 199             msg: object,
 200             *args: object,
 201             exc_info: _ExcInfoType = ...,
 202             stack_info: bool = ...,
 203             extra: Mapping[str, object] | None = ...,
 204         ) -> None: ...
 205         def exception(
 206             self,
 207             msg: object,
 208             *args: object,
 209             exc_info: _ExcInfoType = ...,
 210             stack_info: bool = ...,
 211             extra: Mapping[str, object] | None = ...,
 212         ) -> None: ...
 213         def _log(
 214             self,
 215             level: int,
 216             msg: object,
 217             args: _ArgsType,
 218             exc_info: _ExcInfoType | None = ...,
 219             extra: Mapping[str, object] | None = ...,
 220             stack_info: bool = ...,
 221         ) -> None: ...  # undocumented
 222     fatal = critical
 223     def filter(self, record: LogRecord) -> bool: ...
 224     def addHandler(self, hdlr: Handler) -> None: ...
 225     def removeHandler(self, hdlr: Handler) -> None: ...
 226     if sys.version_info >= (3, 8):
 227         def findCaller(self, stack_info: bool = ..., stacklevel: int = ...) -> tuple[str, int, str, str | None]: ...
 228     else:
 229         def findCaller(self, stack_info: bool = ...) -> tuple[str, int, str, str | None]: ...
 230     def handle(self, record: LogRecord) -> None: ...
 231     def makeRecord(
 232         self,
 233         name: str,
 234         level: int,
 235         fn: str,
 236         lno: int,
 237         msg: object,
 238         args: _ArgsType,
 239         exc_info: _SysExcInfoType | None,
 240         func: str | None = ...,
 241         extra: Mapping[str, object] | None = ...,
 242         sinfo: str | None = ...,
 243     ) -> LogRecord: ...
 244     def hasHandlers(self) -> bool: ...
 245     def callHandlers(self, record: LogRecord) -> None: ...  # undocumented
 246
 247 CRITICAL: int
 248 FATAL: int
 249 ERROR: int
 250 WARNING: int
 251 WARN: int
 252 INFO: int
 253 DEBUG: int
 254 NOTSET: int
 255
 256 class Handler(Filterer):
 257     level: int  # undocumented
 258     formatter: Formatter | None  # undocumented
 259     lock: threading.Lock | None  # undocumented
 260     name: str | None  # undocumented
 261     def __init__(self, level: _Level = ...) -> None: ...
 262     def get_name(self) -> str: ...  # undocumented
 263     def set_name(self, name: str) -> None: ...  # undocumented
 264     def createLock(self) -> None: ...
 265     def acquire(self) -> None: ...
 266     def release(self) -> None: ...
 267     def setLevel(self, level: _Level) -> None: ...
 268     def setFormatter(self, fmt: Formatter | None) -> None: ...
 269     def filter(self, record: LogRecord) -> bool: ...
 270     def flush(self) -> None: ...
 271     def close(self) -> None: ...
 272     def handle(self, record: LogRecord) -> bool: ...
 273     def handleError(self, record: LogRecord) -> None: ...
 274     def format(self, record: LogRecord) -> str: ...
 275     def emit(self, record: LogRecord) -> None: ...
 276
 277 class Formatter:
 278     converter: Callable[[float | None], struct_time]
 279     _fmt: str | None  # undocumented
 280     datefmt: str | None  # undocumented
 281     _style: PercentStyle  # undocumented
 282     default_time_format: str
 283     if sys.version_info >= (3, 9):
 284         default_msec_format: str | None
 285     else:
 286         default_msec_format: str
 287
 288     if sys.version_info >= (3, 8):
 289         def __init__(
 290             self, fmt: str | None = ..., datefmt: str | None = ..., style: _FormatStyle = ..., validate: bool = ...
 291         ) -> None: ...
 292     else:
 293         def __init__(self, fmt: str | None = ..., datefmt: str | None = ..., style: _FormatStyle = ...) -> None: ...
 294     def format(self, record: LogRecord) -> str: ...
 295     def formatTime(self, record: LogRecord, datefmt: str | None = ...) -> str: ...
 296     def formatException(self, ei: _SysExcInfoType) -> str: ...
 297     def formatMessage(self, record: LogRecord) -> str: ...  # undocumented
 298     def formatStack(self, stack_info: str) -> str: ...
 299     def usesTime(self) -> bool: ...  # undocumented
 300
 301 class BufferingFormatter:
 302     linefmt: Formatter
 303     def __init__(self, linefmt: Formatter | None = ...) -> None: ...
 304     def formatHeader(self, records: Sequence[LogRecord]) -> str: ...
 305     def formatFooter(self, records: Sequence[LogRecord]) -> str: ...
 306     def format(self, records: Sequence[LogRecord]) -> str: ...
 307
 308 class Filter:
 309     name: str  # undocumented
 310     nlen: int  # undocumented
 311     def __init__(self, name: str = ...) -> None: ...
 312     def filter(self, record: LogRecord) -> bool: ...
 313
 314 class LogRecord:
 315     # args can be set to None by logging.handlers.QueueHandler
 316     # (see https://bugs.python.org/issue44473)
 317     args: _ArgsType | None
 318     asctime: str
 319     created: float
 320     exc_info: _SysExcInfoType | None
 321     exc_text: str | None
 322     filename: str
 323     funcName: str
 324     levelname: str
 325     levelno: int
 326     lineno: int
 327     module: str
 328     msecs: float
 329     message: str
 330     msg: str
 331     name: str
 332     pathname: str
 333     process: int | None
 334     processName: str | None
 335     relativeCreated: float
 336     stack_info: str | None
 337     thread: int | None
 338     threadName: str | None
 339     def __init__(
 340         self,
 341         name: str,
 342         level: int,
 343         pathname: str,
 344         lineno: int,
 345         msg: object,
 346         args: _ArgsType | None,
 347         exc_info: _SysExcInfoType | None,
 348         func: str | None = ...,
 349         sinfo: str | None = ...,
 350     ) -> None: ...
 351     def getMessage(self) -> str: ...
 352
 353 _L = TypeVar("_L", Logger, LoggerAdapter[Logger], LoggerAdapter[Any])
 354
 355 class LoggerAdapter(Generic[_L]):
 356     logger: _L
 357     manager: Manager  # undocumented
 358     if sys.version_info >= (3, 10):
 359         extra: Mapping[str, object] | None
 360         def __init__(self, logger: _L, extra: Mapping[str, object] | None) -> None: ...
 361     else:
 362         extra: Mapping[str, object]
 363         def __init__(self, logger: _L, extra: Mapping[str, object]) -> None: ...
 364     def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> tuple[Any, MutableMapping[str, Any]]: ...
 365     if sys.version_info >= (3, 8):
 366         def debug(
 367             self,
 368             msg: object,
 369             *args: object,
 370             exc_info: _ExcInfoType = ...,
 371             stack_info: bool = ...,
 372             stacklevel: int = ...,
 373             extra: Mapping[str, object] | None = ...,
 374             **kwargs: object,
 375         ) -> None: ...
 376         def info(
 377             self,
 378             msg: object,
 379             *args: object,
 380             exc_info: _ExcInfoType = ...,
 381             stack_info: bool = ...,
 382             stacklevel: int = ...,
 383             extra: Mapping[str, object] | None = ...,
 384             **kwargs: object,
 385         ) -> None: ...
 386         def warning(
 387             self,
 388             msg: object,
 389             *args: object,
 390             exc_info: _ExcInfoType = ...,
 391             stack_info: bool = ...,
 392             stacklevel: int = ...,
 393             extra: Mapping[str, object] | None = ...,
 394             **kwargs: object,
 395         ) -> None: ...
 396         def warn(
 397             self,
 398             msg: object,
 399             *args: object,
 400             exc_info: _ExcInfoType = ...,
 401             stack_info: bool = ...,
 402             stacklevel: int = ...,
 403             extra: Mapping[str, object] | None = ...,
 404             **kwargs: object,
 405         ) -> None: ...
 406         def error(
 407             self,
 408             msg: object,
 409             *args: object,
 410             exc_info: _ExcInfoType = ...,
 411             stack_info: bool = ...,
 412             stacklevel: int = ...,
 413             extra: Mapping[str, object] | None = ...,
 414             **kwargs: object,
 415         ) -> None: ...
 416         def exception(
 417             self,
 418             msg: object,
 419             *args: object,
 420             exc_info: _ExcInfoType = ...,
 421             stack_info: bool = ...,
 422             stacklevel: int = ...,
 423             extra: Mapping[str, object] | None = ...,
 424             **kwargs: object,
 425         ) -> None: ...
 426         def critical(
 427             self,
 428             msg: object,
 429             *args: object,
 430             exc_info: _ExcInfoType = ...,
 431             stack_info: bool = ...,
 432             stacklevel: int = ...,
 433             extra: Mapping[str, object] | None = ...,
 434             **kwargs: object,
 435         ) -> None: ...
 436         def log(
 437             self,
 438             level: int,
 439             msg: object,
 440             *args: object,
 441             exc_info: _ExcInfoType = ...,
 442             stack_info: bool = ...,
 443             stacklevel: int = ...,
 444             extra: Mapping[str, object] | None = ...,
 445             **kwargs: object,
 446         ) -> None: ...
 447     else:
 448         def debug(
 449             self,
 450             msg: object,
 451             *args: object,
 452             exc_info: _ExcInfoType = ...,
 453             stack_info: bool = ...,
 454             extra: Mapping[str, object] | None = ...,
 455             **kwargs: object,
 456         ) -> None: ...
 457         def info(
 458             self,
 459             msg: object,
 460             *args: object,
 461             exc_info: _ExcInfoType = ...,
 462             stack_info: bool = ...,
 463             extra: Mapping[str, object] | None = ...,
 464             **kwargs: object,
 465         ) -> None: ...
 466         def warning(
 467             self,
 468             msg: object,
 469             *args: object,
 470             exc_info: _ExcInfoType = ...,
 471             stack_info: bool = ...,
 472             extra: Mapping[str, object] | None = ...,
 473             **kwargs: object,
 474         ) -> None: ...
 475         def warn(
 476             self,
 477             msg: object,
 478             *args: object,
 479             exc_info: _ExcInfoType = ...,
 480             stack_info: bool = ...,
 481             extra: Mapping[str, object] | None = ...,
 482             **kwargs: object,
 483         ) -> None: ...
 484         def error(
 485             self,
 486             msg: object,
 487             *args: object,
 488             exc_info: _ExcInfoType = ...,
 489             stack_info: bool = ...,
 490             extra: Mapping[str, object] | None = ...,
 491             **kwargs: object,
 492         ) -> None: ...
 493         def exception(
 494             self,
 495             msg: object,
 496             *args: object,
 497             exc_info: _ExcInfoType = ...,
 498             stack_info: bool = ...,
 499             extra: Mapping[str, object] | None = ...,
 500             **kwargs: object,
 501         ) -> None: ...
 502         def critical(
 503             self,
 504             msg: object,
 505             *args: object,
 506             exc_info: _ExcInfoType = ...,
 507             stack_info: bool = ...,
 508             extra: Mapping[str, object] | None = ...,
 509             **kwargs: object,
 510         ) -> None: ...
 511         def log(
 512             self,
 513             level: int,
 514             msg: object,
 515             *args: object,
 516             exc_info: _ExcInfoType = ...,
 517             stack_info: bool = ...,
 518             extra: Mapping[str, object] | None = ...,
 519             **kwargs: object,
 520         ) -> None: ...
 521     def isEnabledFor(self, level: int) -> bool: ...
 522     def getEffectiveLevel(self) -> int: ...
 523     def setLevel(self, level: _Level) -> None: ...
 524     def hasHandlers(self) -> bool: ...
 525     def _log(
 526         self,
 527         level: int,
 528         msg: object,
 529         args: _ArgsType,
 530         exc_info: _ExcInfoType | None = ...,
 531         extra: Mapping[str, object] | None = ...,
 532         stack_info: bool = ...,
 533     ) -> None: ...  # undocumented
 534     @property
 535     def name(self) -> str: ...  # undocumented
 536
 537 def getLogger(name: str | None = ...) -> Logger: ...
 538 def getLoggerClass() -> Type[Logger]: ...
 539 def getLogRecordFactory() -> Callable[..., LogRecord]: ...
 540
 541 if sys.version_info >= (3, 8):
 542     def debug(
 543         msg: object,
 544         *args: object,
 545         exc_info: _ExcInfoType = ...,
 546         stack_info: bool = ...,
 547         stacklevel: int = ...,
 548         extra: Mapping[str, object] | None = ...,
 549     ) -> None: ...
 550     def info(
 551         msg: object,
 552         *args: object,
 553         exc_info: _ExcInfoType = ...,
 554         stack_info: bool = ...,
 555         stacklevel: int = ...,
 556         extra: Mapping[str, object] | None = ...,
 557     ) -> None: ...
 558     def warning(
 559         msg: object,
 560         *args: object,
 561         exc_info: _ExcInfoType = ...,
 562         stack_info: bool = ...,
 563         stacklevel: int = ...,
 564         extra: Mapping[str, object] | None = ...,
 565     ) -> None: ...
 566     def warn(
 567         msg: object,
 568         *args: object,
 569         exc_info: _ExcInfoType = ...,
 570         stack_info: bool = ...,
 571         stacklevel: int = ...,
 572         extra: Mapping[str, object] | None = ...,
 573     ) -> None: ...
 574     def error(
 575         msg: object,
 576         *args: object,
 577         exc_info: _ExcInfoType = ...,
 578         stack_info: bool = ...,
 579         stacklevel: int = ...,
 580         extra: Mapping[str, object] | None = ...,
 581     ) -> None: ...
 582     def critical(
 583         msg: object,
 584         *args: object,
 585         exc_info: _ExcInfoType = ...,
 586         stack_info: bool = ...,
 587         stacklevel: int = ...,
 588         extra: Mapping[str, object] | None = ...,
 589     ) -> None: ...
 590     def exception(
 591         msg: object,
 592         *args: object,
 593         exc_info: _ExcInfoType = ...,
 594         stack_info: bool = ...,
 595         stacklevel: int = ...,
 596         extra: Mapping[str, object] | None = ...,
 597     ) -> None: ...
 598     def log(
 599         level: int,
 600         msg: object,
 601         *args: object,
 602         exc_info: _ExcInfoType = ...,
 603         stack_info: bool = ...,
 604         stacklevel: int = ...,
 605         extra: Mapping[str, object] | None = ...,
 606     ) -> None: ...
 607
 608 else:
 609     def debug(
 610         msg: object, *args: object, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Mapping[str, object] | None = ...
 611     ) -> None: ...
 612     def info(
 613         msg: object, *args: object, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Mapping[str, object] | None = ...
 614     ) -> None: ...
 615     def warning(
 616         msg: object, *args: object, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Mapping[str, object] | None = ...
 617     ) -> None: ...
 618     def warn(
 619         msg: object, *args: object, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Mapping[str, object] | None = ...
 620     ) -> None: ...
 621     def error(
 622         msg: object, *args: object, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Mapping[str, object] | None = ...
 623     ) -> None: ...
 624     def critical(
 625         msg: object, *args: object, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Mapping[str, object] | None = ...
 626     ) -> None: ...
 627     def exception(
 628         msg: object, *args: object, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Mapping[str, object] | None = ...
 629     ) -> None: ...
 630     def log(
 631         level: int,
 632         msg: object,
 633         *args: object,
 634         exc_info: _ExcInfoType = ...,
 635         stack_info: bool = ...,
 636         extra: Mapping[str, object] | None = ...,
 637     ) -> None: ...
 638
 639 fatal = critical
 640
 641 if sys.version_info >= (3, 7):
 642     def disable(level: int = ...) -> None: ...
 643
 644 else:
 645     def disable(level: int) -> None: ...
 646
 647 def addLevelName(level: int, levelName: str) -> None: ...
 648 def getLevelName(level: _Level) -> Any: ...
 649 def makeLogRecord(dict: Mapping[str, object]) -> LogRecord: ...
 650
 651 if sys.version_info >= (3, 9):
 652     def basicConfig(
 653         *,
 654         filename: StrPath | None = ...,
 655         filemode: str = ...,
 656         format: str = ...,
 657         datefmt: str | None = ...,
 658         style: _FormatStyle = ...,
 659         level: _Level | None = ...,
 660         stream: SupportsWrite[str] | None = ...,
 661         handlers: Iterable[Handler] | None = ...,
 662         force: bool | None = ...,
 663         encoding: str | None = ...,
 664         errors: str | None = ...,
 665     ) -> None: ...
 666
 667 elif sys.version_info >= (3, 8):
 668     def basicConfig(
 669         *,
 670         filename: StrPath | None = ...,
 671         filemode: str = ...,
 672         format: str = ...,
 673         datefmt: str | None = ...,
 674         style: _FormatStyle = ...,
 675         level: _Level | None = ...,
 676         stream: SupportsWrite[str] | None = ...,
 677         handlers: Iterable[Handler] | None = ...,
 678         force: bool = ...,
 679     ) -> None: ...
 680
 681 else:
 682     def basicConfig(
 683         *,
 684         filename: StrPath | None = ...,
 685         filemode: str = ...,
 686         format: str = ...,
 687         datefmt: str | None = ...,
 688         style: _FormatStyle = ...,
 689         level: _Level | None = ...,
 690         stream: SupportsWrite[str] | None = ...,
 691         handlers: Iterable[Handler] | None = ...,
 692     ) -> None: ...
 693
 694 def shutdown(handlerList: Sequence[Any] = ...) -> None: ...  # handlerList is undocumented
 695 def setLoggerClass(klass: Type[Logger]) -> None: ...
 696 def captureWarnings(capture: bool) -> None: ...
 697 def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ...
 698
 699 lastResort: StreamHandler[Any] | None
 700
 701 _StreamT = TypeVar("_StreamT", bound=SupportsWrite[str])
 702
 703 class StreamHandler(Handler, Generic[_StreamT]):
 704     stream: _StreamT  # undocumented
 705     terminator: str
 706     @overload
 707     def __init__(self: StreamHandler[TextIO], stream: None = ...) -> None: ...
 708     @overload
 709     def __init__(self: StreamHandler[_StreamT], stream: _StreamT) -> None: ...
 710     if sys.version_info >= (3, 7):
 711         def setStream(self, stream: _StreamT) -> _StreamT | None: ...
 712
 713 class FileHandler(StreamHandler[TextIOWrapper]):
 714     baseFilename: str  # undocumented
 715     mode: str  # undocumented
 716     encoding: str | None  # undocumented
 717     delay: bool  # undocumented
 718     if sys.version_info >= (3, 9):
 719         errors: str | None  # undocumented
 720         def __init__(
 721             self, filename: StrPath, mode: str = ..., encoding: str | None = ..., delay: bool = ..., errors: str | None = ...
 722         ) -> None: ...
 723     else:
 724         def __init__(self, filename: StrPath, mode: str = ..., encoding: str | None = ..., delay: bool = ...) -> None: ...
 725     def _open(self) -> TextIOWrapper: ...  # undocumented
 726
 727 class NullHandler(Handler): ...
 728
 729 class PlaceHolder:  # undocumented
 730     loggerMap: dict[Logger, None]
 731     def __init__(self, alogger: Logger) -> None: ...
 732     def append(self, alogger: Logger) -> None: ...
 733
 734 # Below aren't in module docs but still visible
 735
 736 class RootLogger(Logger):
 737     def __init__(self, level: int) -> None: ...
 738
 739 root: RootLogger
 740
 741 class PercentStyle(object):  # undocumented
 742     default_format: str
 743     asctime_format: str
 744     asctime_search: str
 745     if sys.version_info >= (3, 8):
 746         validation_pattern: Pattern[str]
 747     _fmt: str
 748     def __init__(self, fmt: str) -> None: ...
 749     def usesTime(self) -> bool: ...
 750     if sys.version_info >= (3, 8):
 751         def validate(self) -> None: ...
 752     def format(self, record: Any) -> str: ...
 753
 754 class StrFormatStyle(PercentStyle):  # undocumented
 755     fmt_spec = Any
 756     field_spec = Any
 757
 758 class StringTemplateStyle(PercentStyle):  # undocumented
 759     _tpl: Template
 760
 761 _STYLES: dict[str, tuple[PercentStyle, str]]
 762
 763 BASIC_FORMAT: str