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