.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/stdlib/2and3/logging/__init__.pyi

   1 # Stubs for logging (Python 3.4)\r
   2 \r
   3 from typing import (\r
   4     Any, Callable, Dict, Iterable, List, Mapping, MutableMapping, Optional, IO,\r
   5     Tuple, Text, Union, overload,\r
   6 )\r
   7 from string import Template\r
   8 from time import struct_time\r
   9 from types import TracebackType\r
  10 import sys\r
  11 import threading\r
  12 \r
  13 _SysExcInfoType = Union[Tuple[type, BaseException, Optional[TracebackType]],\r
  14                         Tuple[None, None, None]]\r
  15 if sys.version_info >= (3, 5):\r
  16     _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException]\r
  17 else:\r
  18     _ExcInfoType = Union[None, bool, _SysExcInfoType]\r
  19 _ArgsType = Union[Tuple[Any, ...], Dict[str, Any]]\r
  20 _FilterType = Union['Filter', Callable[['LogRecord'], int]]\r
  21 _Level = Union[int, Text]\r
  22 \r
  23 raiseExceptions: bool\r
  24 \r
  25 if sys.version_info >= (3,):\r
  26     _levelToName = ...  # type: Dict[int, str]\r
  27     _nameToLevel = ...  # type: Dict[str, int]\r
  28 else:\r
  29     _levelNames = ...  # type: dict\r
  30 \r
  31 class Filterer(object):\r
  32     filters = ...  # type: List[Filter]\r
  33     def __init__(self) -> None: ...\r
  34     def addFilter(self, filter: Filter) -> None: ...\r
  35     def removeFilter(self, filter: Filter) -> None: ...\r
  36     def filter(self, record: 'LogRecord') -> bool: ...\r
  37 \r
  38 class Logger(Filterer):\r
  39     name = ...  # type: str\r
  40     level = ...  # type: int\r
  41     parent = ...  # type: Union[Logger, PlaceHolder]\r
  42     propagate = ...  # type: bool\r
  43     handlers = ...  # type: List[Handler]\r
  44     disabled = ...  # type: int\r
  45     def __init__(self, name: str, level: _Level = ...) -> None: ...\r
  46     def setLevel(self, lvl: Union[int, str]) -> None: ...\r
  47     def isEnabledFor(self, lvl: int) -> bool: ...\r
  48     def getEffectiveLevel(self) -> int: ...\r
  49     def getChild(self, suffix: str) -> 'Logger': ...\r
  50     if sys.version_info >= (3,):\r
  51         def debug(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  52                   stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
  53                   **kwargs: Any) -> None: ...\r
  54         def info(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  55                  stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
  56                  **kwargs: Any) -> None: ...\r
  57         def warning(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  58                     stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
  59                     **kwargs: Any) -> None: ...\r
  60         def warn(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  61                  stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
  62                  **kwargs: Any) -> None: ...\r
  63         def error(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  64                   stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
  65                   **kwargs: Any) -> None: ...\r
  66         def critical(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  67                      stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
  68                      **kwargs: Any) -> None: ...\r
  69         def log(self, lvl: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  70                 stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
  71                 **kwargs: Any) -> None: ...\r
  72         def exception(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  73                       stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
  74                       **kwargs: Any) -> None: ...\r
  75     else:\r
  76         def debug(self,\r
  77                   msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  78                   extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
  79         def info(self,\r
  80                  msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  81                  extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
  82         def warning(self,\r
  83                     msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  84                     extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
  85         def warn(self,\r
  86                  msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  87                  extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
  88         def error(self,\r
  89                   msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  90                   extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
  91         def critical(self,\r
  92                      msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  93                      extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
  94         def log(self,\r
  95                 lvl: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  96                 extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
  97         def exception(self,\r
  98                       msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
  99                       extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 100     def addFilter(self, filt: _FilterType) -> None: ...\r
 101     def removeFilter(self, filt: _FilterType) -> None: ...\r
 102     def filter(self, record: 'LogRecord') -> bool: ...\r
 103     def addHandler(self, hdlr: 'Handler') -> None: ...\r
 104     def removeHandler(self, hdlr: 'Handler') -> None: ...\r
 105     if sys.version_info >= (3,):\r
 106         def findCaller(self, stack_info: bool = ...) -> Tuple[str, int, str, Optional[str]]: ...\r
 107     else:\r
 108         def findCaller(self) -> Tuple[str, int, str]: ...\r
 109     def handle(self, record: 'LogRecord') -> None: ...\r
 110     if sys.version_info >= (3,):\r
 111         def makeRecord(self, name: str, lvl: int, fn: str, lno: int, msg: Any,\r
 112                        args: Mapping[str, Any],\r
 113                        exc_info: Optional[_SysExcInfoType],\r
 114                        func: Optional[str] = ...,\r
 115                        extra: Optional[Mapping[str, Any]] = ...,\r
 116                        sinfo: Optional[str] = ...) -> LogRecord: ...\r
 117     else:\r
 118         def makeRecord(self,\r
 119                        name: str, lvl: int, fn: str, lno: int, msg: Any,\r
 120                        args: Mapping[str, Any],\r
 121                        exc_info: Optional[_SysExcInfoType],\r
 122                        func: Optional[str] = ...,\r
 123                        extra: Optional[Mapping[str, Any]] = ...) -> LogRecord: ...\r
 124     if sys.version_info >= (3,):\r
 125         def hasHandlers(self) -> bool: ...\r
 126 \r
 127 \r
 128 CRITICAL = ...  # type: int\r
 129 FATAL = ...  # type: int\r
 130 ERROR = ...  # type: int\r
 131 WARNING = ...  # type: int\r
 132 WARN = ...  # type: int\r
 133 INFO = ...  # type: int\r
 134 DEBUG = ...  # type: int\r
 135 NOTSET = ...  # type: int\r
 136 \r
 137 \r
 138 class Handler(Filterer):\r
 139     level = ...  # type: int\r
 140     formatter = ...  # type: Optional[Formatter]\r
 141     lock = ...  # type: Optional[threading.Lock]\r
 142     def __init__(self, level: _Level = ...) -> None: ...\r
 143     def createLock(self) -> None: ...\r
 144     def acquire(self) -> None: ...\r
 145     def release(self) -> None: ...\r
 146     def setLevel(self, lvl: Union[int, str]) -> None: ...\r
 147     def setFormatter(self, form: 'Formatter') -> None: ...\r
 148     def addFilter(self, filt: _FilterType) -> None: ...\r
 149     def removeFilter(self, filt: _FilterType) -> None: ...\r
 150     def filter(self, record: 'LogRecord') -> bool: ...\r
 151     def flush(self) -> None: ...\r
 152     def close(self) -> None: ...\r
 153     def handle(self, record: 'LogRecord') -> None: ...\r
 154     def handleError(self, record: 'LogRecord') -> None: ...\r
 155     def format(self, record: 'LogRecord') -> str: ...\r
 156     def emit(self, record: 'LogRecord') -> None: ...\r
 157 \r
 158 \r
 159 class Formatter:\r
 160     converter = ...  # type: Callable[[Optional[float]], struct_time]\r
 161     _fmt = ...  # type: Optional[str]\r
 162     datefmt = ...  # type: Optional[str]\r
 163     if sys.version_info >= (3,):\r
 164         _style = ...  # type: PercentStyle\r
 165         default_time_format = ...  # type: str\r
 166         default_msec_format = ...  # type: str\r
 167 \r
 168     if sys.version_info >= (3,):\r
 169         def __init__(self, fmt: Optional[str] = ...,\r
 170                      datefmt: Optional[str] =...,\r
 171                      style: str = ...) -> None: ...\r
 172     else:\r
 173         def __init__(self,\r
 174                      fmt: Optional[str] = ...,\r
 175                      datefmt: Optional[str] =...) -> None: ...\r
 176 \r
 177     def format(self, record: 'LogRecord') -> str: ...\r
 178     def formatTime(self, record: 'LogRecord', datefmt: str = ...) -> str: ...\r
 179     def formatException(self, exc_info: _SysExcInfoType) -> str: ...\r
 180     if sys.version_info >= (3,):\r
 181         def formatStack(self, stack_info: str) -> str: ...\r
 182 \r
 183 \r
 184 class Filter:\r
 185     def __init__(self, name: str = ...) -> None: ...\r
 186     def filter(self, record: 'LogRecord') -> int: ...\r
 187 \r
 188 \r
 189 class LogRecord:\r
 190     args = ...  # type: _ArgsType\r
 191     asctime = ...  # type: str\r
 192     created = ...  # type: int\r
 193     exc_info = ...  # type: Optional[_SysExcInfoType]\r
 194     filename = ...  # type: str\r
 195     funcName = ...  # type: str\r
 196     levelname = ...  # type: str\r
 197     levelno = ...  # type: int\r
 198     lineno = ...  # type: int\r
 199     module = ...  # type: str\r
 200     msecs = ...  # type: int\r
 201     message = ...  # type: str\r
 202     msg = ...  # type: str\r
 203     name = ...  # type: str\r
 204     pathname = ...  # type: str\r
 205     process = ...  # type: int\r
 206     processName = ...  # type: str\r
 207     relativeCreated = ...  # type: int\r
 208     if sys.version_info >= (3,):\r
 209         stack_info = ...  # type: Optional[str]\r
 210     thread = ...  # type: int\r
 211     threadName = ...  # type: str\r
 212     if sys.version_info >= (3,):\r
 213         def __init__(self, name: str, level: int, pathname: str, lineno: int,\r
 214                      msg: Any, args: _ArgsType,\r
 215                      exc_info: Optional[_SysExcInfoType],\r
 216                      func: Optional[str] = ...,\r
 217                      sinfo: Optional[str] = ...) -> None: ...\r
 218     else:\r
 219         def __init__(self,\r
 220                      name: str, level: int, pathname: str, lineno: int,\r
 221                      msg: Any, args: _ArgsType,\r
 222                      exc_info: Optional[_SysExcInfoType],\r
 223                      func: Optional[str] = ...) -> None: ...\r
 224     def getMessage(self) -> str: ...\r
 225 \r
 226 \r
 227 class LoggerAdapter:\r
 228     def __init__(self, logger: Logger, extra: Mapping[str, Any]) -> None: ...\r
 229     def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> Tuple[Any, MutableMapping[str, Any]]: ...\r
 230     if sys.version_info >= (3,):\r
 231         def debug(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 232                   stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 233                   **kwargs: Any) -> None: ...\r
 234         def info(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 235                  stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 236                  **kwargs: Any) -> None: ...\r
 237         def warning(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 238                     stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 239                     **kwargs: Any) -> None: ...\r
 240         def error(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 241                   stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 242                   **kwargs: Any) -> None: ...\r
 243         def exception(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 244                       stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 245                       **kwargs: Any) -> None: ...\r
 246         def critical(self, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 247                      stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 248                      **kwargs: Any) -> None: ...\r
 249         def log(self, lvl: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 250                 stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 251                 **kwargs: Any) -> None: ...\r
 252     else:\r
 253         def debug(self,\r
 254                   msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 255                   extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 256         def info(self,\r
 257                  msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 258                  extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 259         def warning(self,\r
 260                     msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 261                     extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 262         def error(self,\r
 263                   msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 264                   extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 265         def exception(self,\r
 266                       msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 267                       extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 268         def critical(self,\r
 269                      msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 270                      extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 271         def log(self,\r
 272                 lvl: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 273                 extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 274     def isEnabledFor(self, lvl: int) -> bool: ...\r
 275     if sys.version_info >= (3,):\r
 276         def getEffectiveLevel(self) -> int: ...\r
 277         def setLevel(self, lvl: Union[int, str]) -> None: ...\r
 278         def hasHandlers(self) -> bool: ...\r
 279 \r
 280 \r
 281 if sys.version_info >= (3,):\r
 282     def getLogger(name: Optional[str] = ...) -> Logger: ...\r
 283 else:\r
 284     @overload\r
 285     def getLogger() -> Logger: ...\r
 286     @overload\r
 287     def getLogger(name: Union[Text, str]) -> Logger: ...\r
 288 def getLoggerClass() -> type: ...\r
 289 if sys.version_info >= (3,):\r
 290     def getLogRecordFactory() -> Callable[..., LogRecord]: ...\r
 291 \r
 292 if sys.version_info >= (3,):\r
 293     def debug(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 294               stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 295               **kwargs: Any) -> None: ...\r
 296     def info(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 297              stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 298              **kwargs: Any) -> None: ...\r
 299     def warning(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 300                 stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 301                 **kwargs: Any) -> None: ...\r
 302     def warn(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 303              stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 304              **kwargs: Any) -> None: ...\r
 305     def error(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 306               stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 307               **kwargs: Any) -> None: ...\r
 308     def critical(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 309                  stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 310                  **kwargs: Any) -> None: ...\r
 311     def exception(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 312                   stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 313                   **kwargs: Any) -> None: ...\r
 314     def log(lvl: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 315             stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ...,\r
 316             **kwargs: Any) -> None: ...\r
 317 else:\r
 318     def debug(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 319               extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 320     def info(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 321              extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 322     def warning(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 323                 extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 324     def warn(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 325              extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 326     def error(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 327               extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 328     def critical(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 329                  extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 330     def exception(msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 331                   extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 332     def log(lvl: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ...,\r
 333             extra: Optional[Dict[str, Any]] = ..., **kwargs: Any) -> None: ...\r
 334 fatal = critical\r
 335 \r
 336 def disable(lvl: int) -> None: ...\r
 337 def addLevelName(lvl: int, levelName: str) -> None: ...\r
 338 def getLevelName(lvl: int) -> str: ...\r
 339 \r
 340 def makeLogRecord(attrdict: Mapping[str, Any]) -> LogRecord: ...\r
 341 \r
 342 if sys.version_info >= (3,):\r
 343     def basicConfig(*, filename: str = ..., filemode: str = ...,\r
 344                     format: str = ..., datefmt: str = ..., style: str = ...,\r
 345                     level: _Level = ..., stream: IO[str] = ...,\r
 346                     handlers: Iterable[Handler] = ...) -> None: ...\r
 347 else:\r
 348     @overload\r
 349     def basicConfig() -> None: ...\r
 350     @overload\r
 351     def basicConfig(*, filename: str = ..., filemode: str = ...,\r
 352                     format: str = ..., datefmt: str = ...,\r
 353                     level: _Level = ..., stream: IO[str] = ...) -> None: ...\r
 354 def shutdown() -> None: ...\r
 355 \r
 356 def setLoggerClass(klass: type) -> None: ...\r
 357 \r
 358 def captureWarnings(capture: bool) -> None: ...\r
 359 \r
 360 if sys.version_info >= (3,):\r
 361     def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ...\r
 362 \r
 363 \r
 364 if sys.version_info >= (3,):\r
 365     lastResort = ...  # type: Optional['StreamHandler']\r
 366 \r
 367 \r
 368 class StreamHandler(Handler):\r
 369     stream = ...  # type: IO[str]\r
 370     if sys.version_info >= (3,):\r
 371         terminator = ...  # type: str\r
 372     def __init__(self, stream: Optional[IO[str]] = ...) -> None: ...\r
 373 \r
 374 \r
 375 class FileHandler(Handler):\r
 376     baseFilename = ...  # type: str\r
 377     mode = ...  # type: str\r
 378     encoding = ...  # type: Optional[str]\r
 379     delay = ...  # type: bool\r
 380     def __init__(self, filename: str, mode: str = ...,\r
 381                  encoding: Optional[str] = ..., delay: bool = ...) -> None: ...\r
 382 \r
 383 \r
 384 class NullHandler(Handler): ...\r
 385 \r
 386 \r
 387 class PlaceHolder:\r
 388     def __init__(self, alogger: Logger) -> None: ...\r
 389     def append(self, alogger: Logger) -> None: ...\r
 390 \r
 391 \r
 392 # Below aren't in module docs but still visible\r
 393 \r
 394 class RootLogger(Logger): ...\r
 395 \r
 396 root = ...  # type: RootLogger\r
 397 \r
 398 \r
 399 if sys.version_info >= (3,):\r
 400     class PercentStyle(object):\r
 401         default_format = ...  # type: str\r
 402         asctime_format = ...  # type: str\r
 403         asctime_search = ...  # type: str\r
 404         _fmt = ...  # type: str\r
 405 \r
 406         def __init__(self, fmt: str) -> None: ...\r
 407         def usesTime(self) -> bool: ...\r
 408         def format(self, record: Any) -> str: ...\r
 409 \r
 410     class StrFormatStyle(PercentStyle):\r
 411         ...\r
 412 \r
 413     class StringTemplateStyle(PercentStyle):\r
 414         _tpl = ...  # type: Template\r
 415 \r
 416     _STYLES = ...  # type: Dict[str, Tuple[PercentStyle, str]]\r
 417 \r
 418 \r
 419 BASIC_FORMAT = ...  # type: str\r