'FATAL', 'FileHandler', 'Filter', 'Formatter', 'Handler', 'INFO',

'LogRecord', 'Logger', 'LoggerAdapter', 'NOTSET', 'NullHandler',

'StreamHandler', 'WARN', 'WARNING', 'addLevelName', 'basicConfig',

'captureWarnings', 'critical', 'debug', 'disable', 'error',

'exception', 'fatal', 'getLevelName', 'getLogger', 'getLoggerClass',

'info', 'log', 'makeLogRecord', 'setLoggerClass', 'warn', 'warning',

"""Return the frame object for the caller's stack frame."""

try:

raise Exception

except:

CRITICAL : 'CRITICAL',

ERROR : 'ERROR',

WARNING : 'WARNING',

INFO : 'INFO',

DEBUG : 'DEBUG',

NOTSET : 'NOTSET',

'CRITICAL' : CRITICAL,

'ERROR' : ERROR,

'WARN' : WARNING,

'WARNING' : WARNING,

'INFO' : INFO,

'DEBUG' : DEBUG,

'NOTSET' : NOTSET,

"""

"""

_acquireLock()

try: #unlikely to cause an exception, but you never know...

_levelNames[level] = levelName

_levelNames[levelName] = level

finally:

if isinstance(level, int):

rv = level

elif str(level) == level:

if level not in _levelNames:

raise ValueError("Unknown level: %r" % level)

rv = _levelNames[level]

else:

raise TypeError("Level not an integer or a valid string: %r" % level)

"""

if _lock:

"""

if _lock:

"""

def __init__(self, name, level, pathname, lineno,

msg, args, exc_info, func=None, sinfo=None, **kwargs):

"""

ct = time.time()

self.name = name

self.msg = msg

#

# The following statement allows passing of a dictionary as a sole

# argument, so that you can do something like

# logging.debug("a %(a)d b %(b)s", {'a':1, 'b':2})

# Suggested by Stefan Behnel.

# Note that without the test for args[0], we get a problem because

# during formatting, we test to see if the arg is present using

# 'if self.args:'. If the event being logged is e.g. 'Value is %d'

# and if the passed arg fails 'if self.args:' then no formatting

# is done. For example, logger.warning('Value is %d', 0) would log

# 'Value is %d' instead of 'Value is 0'.

# For the use case of passing a dictionary, this should not be a

# problem.

if args and len(args) == 1 and isinstance(args[0], dict) and args[0]:

args = args[0]

self.args = args

self.levelname = getLevelName(level)

self.levelno = level

self.pathname = pathname

try:

self.filename = os.path.basename(pathname)

self.module = os.path.splitext(self.filename)[0]

except (TypeError, ValueError, AttributeError):

self.filename = pathname

self.module = "Unknown module"

self.exc_info = exc_info

self.exc_text = None # used to cache the traceback text

self.stack_info = sinfo

self.lineno = lineno

self.funcName = func

self.created = ct

self.msecs = (ct - int(ct)) * 1000

self.relativeCreated = (self.created - _startTime) * 1000

if logThreads and threading:

self.thread = threading.get_ident()

self.threadName = threading.current_thread().name

else: # pragma: no cover

self.thread = None

self.threadName = None

if not logMultiprocessing: # pragma: no cover

self.processName = None

else:

self.processName = 'MainProcess'

mp = sys.modules.get('multiprocessing')

if mp is not None:

# Errors may occur if multiprocessing has not finished loading

# yet - e.g. if a custom import hook causes third-party code

# to run when multiprocessing calls import. See issue 8200

# for an example

try:

self.processName = mp.current_process().name

except Exception: #pragma: no cover

pass

if logProcesses and hasattr(os, 'getpid'):

self.process = os.getpid()

else:

self.process = None

def __str__(self):

return '<LogRecord: %s, %s, %s, %s, "%s">'%(self.name, self.levelno,

self.pathname, self.lineno, self.msg)

def getMessage(self):

"""

msg = str(self.msg)

if self.args:

msg = msg % self.args

"""

global _logRecordFactory

"""

"""

rv = _logRecordFactory(None, None, "", 0, "", (), None, None)

rv.__dict__.update(dict)

default_format = '%(message)s'

asctime_format = '%(asctime)s'

asctime_search = '%(asctime)'

def __init__(self, fmt):

self._fmt = fmt or self.default_format

def usesTime(self):

return self._fmt.find(self.asctime_search) >= 0

def format(self, record):

default_format = '{message}'

asctime_format = '{asctime}'

asctime_search = '{asctime'

def format(self, record):

default_format = '${message}'

asctime_format = '${asctime}'

asctime_search = '${asctime}'

def __init__(self, fmt):

self._fmt = fmt or self.default_format

self._tpl = Template(self._fmt)

def usesTime(self):

fmt = self._fmt

return fmt.find('$asctime') >= 0 or fmt.find(self.asctime_format) >= 0

def format(self, record):

'%': PercentStyle,

'{': StrFormatStyle,

'$': StringTemplateStyle

"""

converter = time.localtime

def __init__(self, fmt=None, datefmt=None, style='%'):

"""

if style not in _STYLES:

raise ValueError('Style must be one of: %s' % ','.join(

_STYLES.keys()))

self._style = _STYLES[style](fmt)

self._fmt = self._style._fmt

self.datefmt = datefmt

default_time_format = '%Y-%m-%d %H:%M:%S'

default_msec_format = '%s,%03d'

def formatTime(self, record, datefmt=None):

"""

ct = self.converter(record.created)

if datefmt:

s = time.strftime(datefmt, ct)

else:

t = time.strftime(self.default_time_format, ct)

s = self.default_msec_format % (t, record.msecs)

return s

def formatException(self, ei):

"""

sio = io.StringIO()

tb = ei[2]

# See issues #9427, #1553375. Commented out for now.

#if getattr(self, 'fullstack', False):

# traceback.print_stack(tb.tb_frame.f_back, file=sio)

traceback.print_exception(ei[0], ei[1], tb, None, sio)

s = sio.getvalue()

sio.close()

if s[-1:] == "\n":

s = s[:-1]

return s

def usesTime(self):

"""

return self._style.usesTime()

def formatMessage(self, record):

return self._style.format(record)

def formatStack(self, stack_info):

"""

return stack_info

def format(self, record):

"""

record.message = record.getMessage()

if self.usesTime():

record.asctime = self.formatTime(record, self.datefmt)

s = self.formatMessage(record)

if record.exc_info:

# Cache the traceback text to avoid converting it multiple times

# (it's constant anyway)

if not record.exc_text:

record.exc_text = self.formatException(record.exc_info)

if record.exc_text:

if s[-1:] != "\n":

s = s + "\n"

s = s + record.exc_text

if record.stack_info:

if s[-1:] != "\n":

s = s + "\n"

s = s + self.formatStack(record.stack_info)

"""

def __init__(self, linefmt=None):

"""

if linefmt:

self.linefmt = linefmt

else:

self.linefmt = _defaultFormatter

def formatHeader(self, records):

"""

return ""

def formatFooter(self, records):

"""

return ""

def format(self, records):

"""

rv = ""

if len(records) > 0:

rv = rv + self.formatHeader(records)

for record in records:

rv = rv + self.linefmt.format(record)

rv = rv + self.formatFooter(records)

"""

def __init__(self, name=''):

"""

self.name = name

self.nlen = len(name)

def filter(self, record):

"""

if self.nlen == 0:

return True

elif self.name == record.name:

return True

elif record.name.find(self.name, 0, self.nlen) != 0:

return False

"""

def __init__(self):

"""

self.filters = []

def addFilter(self, filter):

"""

if not (filter in self.filters):

self.filters.append(filter)

def removeFilter(self, filter):

"""

if filter in self.filters:

self.filters.remove(filter)

def filter(self, record):

"""

rv = True

for f in self.filters:

if hasattr(f, 'filter'):

result = f.filter(record)

else:

result = f(record) # assume callable - will raise if not

if not result:

rv = False

break

"""

# This function can be called during module teardown, when globals are

# set to None. If _acquireLock is None, assume this is the case and do

# nothing.

if _acquireLock is not None:

_acquireLock()

try:

if wr in _handlerList:

_handlerList.remove(wr)

finally:

"""

_acquireLock()

try:

_handlerList.append(weakref.ref(handler, _removeHandlerRef))

finally:

"""

def __init__(self, level=NOTSET):

"""

Filterer.__init__(self)

self._name = None

self.level = _checkLevel(level)

self.formatter = None

# Add the handler to the global _handlerList (for cleanup on shutdown)

_addHandlerRef(self)

self.createLock()

def get_name(self):

return self._name

def set_name(self, name):

_acquireLock()

try:

if self._name in _handlers:

del _handlers[self._name]

self._name = name

if name:

_handlers[name] = self

finally:

_releaseLock()

name = property(get_name, set_name)

def createLock(self):

"""

if threading:

self.lock = threading.RLock()

else: #pragma: no cover

self.lock = None

def acquire(self):

"""

if self.lock:

self.lock.acquire()

def release(self):

"""

if self.lock:

self.lock.release()

def setLevel(self, level):

"""

self.level = _checkLevel(level)

def format(self, record):

"""

if self.formatter:

fmt = self.formatter

else:

fmt = _defaultFormatter

return fmt.format(record)

def emit(self, record):

"""

raise NotImplementedError('emit must be implemented '

'by Handler subclasses')

def handle(self, record):

"""

rv = self.filter(record)

if rv:

self.acquire()

try:

self.emit(record)

finally:

self.release()

return rv

def setFormatter(self, fmt):

"""

self.formatter = fmt

def flush(self):

"""

pass

def close(self):

"""

#get the module data lock, as we're updating a shared structure.

_acquireLock()

try: #unlikely to raise an exception, but you never know...

if self._name and self._name in _handlers:

del _handlers[self._name]

finally:

_releaseLock()

def handleError(self, record):

"""

if raiseExceptions and sys.stderr: # see issue 13807

ei = sys.exc_info()

try:

traceback.print_exception(ei[0], ei[1], ei[2],

None, sys.stderr)

sys.stderr.write('Logged from file %s, line %s\n' % (

record.filename, record.lineno))

except IOError: #pragma: no cover

pass # see issue 5971

finally:

"""

terminator = '\n'

def __init__(self, stream=None):

"""

Handler.__init__(self)

if stream is None:

stream = sys.stderr

self.stream = stream

def flush(self):

"""

self.acquire()

try:

if self.stream and hasattr(self.stream, "flush"):

self.stream.flush()

finally:

self.release()

def emit(self, record):

"""

try:

msg = self.format(record)

stream = self.stream

stream.write(msg)

stream.write(self.terminator)

self.flush()

except (KeyboardInterrupt, SystemExit): #pragma: no cover

raise

except:

"""

def __init__(self, filename, mode='a', encoding=None, delay=False):

"""

#keep the absolute path, otherwise derived classes which use this

#may come a cropper when the current directory changes

self.baseFilename = os.path.abspath(filename)

self.mode = mode

self.encoding = encoding

if delay:

#We don't open the stream, but we still need to call the

#Handler constructor to set level, formatter, lock etc.

Handler.__init__(self)

self.stream = None

else:

StreamHandler.__init__(self, self._open())

def close(self):

"""

self.acquire()

try:

if self.stream:

self.flush()

if hasattr(self.stream, "close"):

self.stream.close()

StreamHandler.close(self)

self.stream = None

finally:

self.release()

def _open(self):

"""

return open(self.baseFilename, self.mode, encoding=self.encoding)

def emit(self, record):

"""

if self.stream is None:

self.stream = self._open()