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

   1 # Stubs for logging.handlers (Python 2.4)\r
   2 \r
   3 import datetime\r
   4 from logging import Handler, FileHandler, LogRecord\r
   5 from socket import SocketType\r
   6 import ssl\r
   7 import sys\r
   8 from typing import Any, Callable, Dict, List, Optional, Tuple, Union, overload\r
   9 if sys.version_info >= (3,):\r
  10     from queue import Queue\r
  11 else:\r
  12     from Queue import Queue\r
  13 # TODO update socket stubs to add SocketKind\r
  14 _SocketKind = int\r
  15 \r
  16 \r
  17 class WatchedFileHandler(Handler):\r
  18     @overload\r
  19     def __init__(self, filename: str) -> None: ...\r
  20     @overload\r
  21     def __init__(self, filename: str, mode: str) -> None: ...\r
  22     @overload\r
  23     def __init__(self, filename: str, mode: str,\r
  24                  encoding: Optional[str]) -> None: ...\r
  25     @overload\r
  26     def __init__(self, filename: str, mode: str, encoding: Optional[str],\r
  27                  delay: bool) -> None: ...\r
  28 \r
  29 \r
  30 if sys.version_info >= (3,):\r
  31     class BaseRotatingHandler(FileHandler):\r
  32         terminator = ...  # type: str\r
  33         namer = ...  # type: Optional[Callable[[str], str]]\r
  34         rotator = ...  # type: Optional[Callable[[str, str], None]]\r
  35         def __init__(self, filename: str, mode: str,\r
  36                      encoding: Optional[str] = ...,\r
  37                      delay: bool = ...) -> None: ...\r
  38         def rotation_filename(self, default_name: str) -> None: ...\r
  39         def rotate(self, source: str, dest: str) -> None: ...\r
  40 \r
  41 \r
  42 if sys.version_info >= (3,):\r
  43     class RotatingFileHandler(BaseRotatingHandler):\r
  44         def __init__(self, filename: str, mode: str = ..., maxBytes: int = ...,\r
  45                      backupCount: int = ..., encoding: Optional[str] = ...,\r
  46                      delay: bool = ...) -> None: ...\r
  47         def doRollover(self) -> None: ...\r
  48 else:\r
  49     class RotatingFileHandler(Handler):\r
  50         def __init__(self, filename: str, mode: str = ..., maxBytes: int = ...,\r
  51                      backupCount: int = ..., encoding: Optional[str] = ...,\r
  52                      delay: bool = ...) -> None: ...\r
  53         def doRollover(self) -> None: ...\r
  54 \r
  55 \r
  56 if sys.version_info >= (3,):\r
  57     class TimedRotatingFileHandler(BaseRotatingHandler):\r
  58         if sys.version_info >= (3, 4):\r
  59             def __init__(self, filename: str, when: str = ...,\r
  60                          interval: int = ...,\r
  61                          backupCount: int = ..., encoding: Optional[str] = ...,\r
  62                          delay: bool = ..., utc: bool = ...,\r
  63                          atTime: Optional[datetime.datetime] = ...) -> None: ...\r
  64         else:\r
  65             def __init__(self,\r
  66                          filename: str, when: str = ..., interval: int = ...,\r
  67                          backupCount: int = ..., encoding: Optional[str] = ...,\r
  68                          delay: bool = ..., utc: bool = ...) -> None: ...\r
  69         def doRollover(self) -> None: ...\r
  70 else:\r
  71     class TimedRotatingFileHandler:\r
  72         def __init__(self,\r
  73                      filename: str, when: str = ..., interval: int = ...,\r
  74                      backupCount: int = ..., encoding: Optional[str] = ...,\r
  75                      delay: bool = ..., utc: bool = ...) -> None: ...\r
  76         def doRollover(self) -> None: ...\r
  77 \r
  78 \r
  79 class SocketHandler(Handler):\r
  80     retryStart = ...  # type: float\r
  81     retryFactor = ...  # type: float\r
  82     retryMax = ...  # type: float\r
  83     if sys.version_info >= (3, 4):\r
  84         def __init__(self, host: str, port: Optional[int]) -> None: ...\r
  85     else:\r
  86         def __init__(self, host: str, port: int) -> None: ...\r
  87     def makeSocket(self) -> SocketType: ...\r
  88     def makePickle(self, record: LogRecord) -> bytes: ...\r
  89     def send(self, packet: bytes) -> None: ...\r
  90     def createSocket(self) -> None: ...\r
  91 \r
  92 \r
  93 class DatagramHandler(SocketHandler): ...\r
  94 \r
  95 \r
  96 class SysLogHandler(Handler):\r
  97     LOG_ALERT = ...  # type: int\r
  98     LOG_CRIT = ...  # type: int\r
  99     LOG_DEBUG = ...  # type: int\r
 100     LOG_EMERG = ...  # type: int\r
 101     LOG_ERR = ...  # type: int\r
 102     LOG_INFO = ...  # type: int\r
 103     LOG_NOTICE = ...  # type: int\r
 104     LOG_WARNING = ...  # type: int\r
 105     LOG_AUTH = ...  # type: int\r
 106     LOG_AUTHPRIV = ...  # type: int\r
 107     LOG_CRON = ...  # type: int\r
 108     LOG_DAEMON = ...  # type: int\r
 109     LOG_FTP = ...  # type: int\r
 110     LOG_KERN = ...  # type: int\r
 111     LOG_LPR = ...  # type: int\r
 112     LOG_MAIL = ...  # type: int\r
 113     LOG_NEWS = ...  # type: int\r
 114     LOG_SYSLOG = ...  # type: int\r
 115     LOG_USER = ...  # type: int\r
 116     LOG_UUCP = ...  # type: int\r
 117     LOG_LOCAL0 = ...  # type: int\r
 118     LOG_LOCAL1 = ...  # type: int\r
 119     LOG_LOCAL2 = ...  # type: int\r
 120     LOG_LOCAL3 = ...  # type: int\r
 121     LOG_LOCAL4 = ...  # type: int\r
 122     LOG_LOCAL5 = ...  # type: int\r
 123     LOG_LOCAL6 = ...  # type: int\r
 124     LOG_LOCAL7 = ...  # type: int\r
 125     def __init__(self, address: Union[Tuple[str, int], str] = ...,\r
 126             facility: int = ..., socktype: _SocketKind = ...) -> None: ...\r
 127     def encodePriority(self, facility: Union[int, str],\r
 128                        priority: Union[int, str]) -> int: ...\r
 129     def mapPriority(self, levelName: int) -> str: ...\r
 130 \r
 131 \r
 132 class NTEventLogHandler(Handler):\r
 133     def __init__(self, appname: str, dllname: str = ...,\r
 134                  logtype: str = ...) -> None: ...\r
 135     def getEventCategory(self, record: LogRecord) -> int: ...\r
 136     # TODO correct return value?\r
 137     def getEventType(self, record: LogRecord) -> int: ...\r
 138     def getMessageID(self, record: LogRecord) -> int: ...\r
 139 \r
 140 \r
 141 class SMTPHandler(Handler):\r
 142     # TODO `secure` can also be an empty tuple\r
 143     if sys.version_info >= (3,):\r
 144         def __init__(self, mailhost: Union[str, Tuple[str, int]], fromaddr: str,\r
 145                      toaddrs: List[str], subject: str,\r
 146                      credentials: Optional[Tuple[str, str]] = ...,\r
 147                      secure: Union[Tuple[str], Tuple[str, str], None] =...,\r
 148                      timeout: float = ...) -> None: ...\r
 149     else:\r
 150         def __init__(self,\r
 151                      mailhost: Union[str, Tuple[str, int]], fromaddr: str,\r
 152                      toaddrs: List[str], subject: str,\r
 153                      credentials: Optional[Tuple[str, str]] = ...,\r
 154                      secure: Union[Tuple[str], Tuple[str, str], None] =...) -> None: ...\r
 155     def getSubject(self, record: LogRecord) -> str: ...\r
 156 \r
 157 \r
 158 class BufferingHandler(Handler):\r
 159     def __init__(self, capacity: int) -> None: ...\r
 160     def shouldFlush(self, record: LogRecord) -> bool: ...\r
 161 \r
 162 class MemoryHandler(BufferingHandler):\r
 163     def __init__(self, capacity: int, flushLevel: int = ...,\r
 164                  target: Optional[Handler] =...) -> None: ...\r
 165     def setTarget(self, target: Handler) -> None: ...\r
 166 \r
 167 \r
 168 class HTTPHandler(Handler):\r
 169     if sys.version_info >= (3, 5):\r
 170         def __init__(self, host: str, url: str, method: str = ...,\r
 171                      secure: bool = ...,\r
 172                      credentials: Optional[Tuple[str, str]] = ...,\r
 173                      context: Optional[ssl.SSLContext] = ...) -> None: ...\r
 174     elif sys.version_info >= (3,):\r
 175         def __init__(self,\r
 176                      host: str, url: str, method: str = ..., secure: bool = ...,\r
 177                      credentials: Optional[Tuple[str, str]] = ...) -> None: ...\r
 178     else:\r
 179         def __init__(self,\r
 180                      host: str, url: str, method: str = ...) -> None: ...\r
 181     def mapLogRecord(self, record: LogRecord) -> Dict[str, Any]: ...\r
 182 \r
 183 \r
 184 if sys.version_info >= (3,):\r
 185     class QueueHandler(Handler):\r
 186         def __init__(self, queue: Queue) -> None: ...\r
 187         def prepare(self, record: LogRecord) -> Any: ...\r
 188         def enqueue(self, record: LogRecord) -> None: ...\r
 189 \r
 190     class QueueListener:\r
 191         if sys.version_info >= (3, 5):\r
 192             def __init__(self, queue: Queue, *handlers: Handler,\r
 193                          respect_handler_level: bool = ...) -> None: ...\r
 194         else:\r
 195             def __init__(self,\r
 196                          queue: Queue, *handlers: Handler) -> None: ...\r
 197         def dequeue(self, block: bool) -> LogRecord: ...\r
 198         def prepare(self, record: LogRecord) -> Any: ...\r
 199         def start(self) -> None: ...\r
 200         def stop(self) -> None: ...\r
 201         def enqueue_sentinel(self) -> None: ...\r