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

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

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

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

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

"""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 _lock:

"""

if _lock:

"""

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

msg, args, exc_info, func=None):

"""

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.warn('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 (

type(args[0]) == types.DictType

) 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.lineno = lineno

self.funcName = func

self.created = ct

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

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

if logThreads and thread:

self.thread = thread.get_ident()

self.threadName = threading.current_thread().name

else:

self.thread = None

self.threadName = None

if not logMultiprocessing:

self.processName = None

elif 'multiprocessing' not in sys.modules:

self.processName = 'MainProcess'

else:

self.processName = sys.modules['multiprocessing'].current_process().name

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):

"""

if not hasattr(types, "UnicodeType"): #if no unicode support...

msg = str(self.msg)

else:

msg = self.msg

if type(msg) not in (types.UnicodeType, types.StringType):

try:

msg = str(self.msg)

except UnicodeError:

msg = self.msg #Defer encoding till later

if self.args:

msg = msg % self.args

"""

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

rv.__dict__.update(dict)

"""

converter = time.localtime

def __init__(self, fmt=None, datefmt=None):

"""

if fmt:

self._fmt = fmt

else:

self._fmt = "%(message)s"

self.datefmt = datefmt

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

"""

ct = self.converter(record.created)

if datefmt:

s = time.strftime(datefmt, ct)

else:

t = time.strftime("%Y-%m-%d %H:%M:%S", ct)

s = "%s,%03d" % (t, record.msecs)

return s

def formatException(self, ei):

"""

sio = cStringIO.StringIO()

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

s = sio.getvalue()

sio.close()

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

s = s[:-1]

return s

def format(self, record):

"""

record.message = record.getMessage()

if string.find(self._fmt,"%(asctime)") >= 0:

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

s = self._fmt % record.__dict__

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"

try:

s = s + record.exc_text

except UnicodeError:

# Sometimes filenames have non-ASCII chars, which can lead

# to errors when s is Unicode and record.exc_text is str

# See issue 8924

s = s + record.exc_text.decode(sys.getfilesystemencoding())

"""

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 1

elif self.name == record.name:

return 1

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

return 0

"""

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 = 1

for f in self.filters:

if not f.filter(record):

rv = 0

break

"""

def __init__(self, level=NOTSET):

"""

Filterer.__init__(self)

self.level = level

self.formatter = None

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

_acquireLock()

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

_handlers[self] = 1

_handlerList.insert(0, self)

finally:

_releaseLock()

self.createLock()

def createLock(self):

"""

if thread:

self.lock = threading.RLock()

else:

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 = 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 in _handlers:

del _handlers[self]

if self in _handlerList:

_handlerList.remove(self)

finally:

_releaseLock()

def handleError(self, record):

"""

if raiseExceptions:

ei = sys.exc_info()

try:

traceback.print_exception(ei[0], ei[1], ei[2], None, sys.stderr)

except IOError:

pass # see issue 5971

finally:

"""

def __init__(self, strm=None):

"""

Handler.__init__(self)

if strm is None:

strm = sys.stderr

self.stream = strm

def flush(self):

"""

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

self.stream.flush()

def emit(self, record):

"""

try:

msg = self.format(record)

stream = self.stream

fs = "%s\n"

if not hasattr(types, "UnicodeType"): #if no unicode support...

stream.write(fs % msg)

else:

try:

if (isinstance(msg, unicode) and

getattr(stream, 'encoding', None)):

fs = fs.decode(stream.encoding)

try:

stream.write(fs % msg)

except UnicodeEncodeError:

#Printing to terminals sometimes fails. For example,

#with an encoding of 'cp1251', the above write will

#work if written to a stream opened or wrapped by

#the codecs module, but fail when writing to a

#terminal even when the codepage is set to cp1251.

#An extra encoding step seems to be needed.

stream.write((fs % msg).encode(stream.encoding))

else:

stream.write(fs % msg)

except UnicodeError:

stream.write(fs % msg.encode("UTF-8"))

self.flush()

except (KeyboardInterrupt, SystemExit):

raise

except:

"""

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

"""

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

#may come a cropper when the current directory changes

if codecs is None:

encoding = None

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):

"""

if self.stream:

self.flush()

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

self.stream.close()

StreamHandler.close(self)

self.stream = None

def _open(self):

"""

if self.encoding is None:

stream = open(self.baseFilename, self.mode)

else:

stream = codecs.open(self.baseFilename, self.mode, self.encoding)

return stream

def emit(self, record):

"""

if self.stream is None:

self.stream = self._open()

"""

def __init__(self, alogger):

"""

#self.loggers = [alogger]

self.loggerMap = { alogger : None }

def append(self, alogger):

"""

#if alogger not in self.loggers:

if alogger not in self.loggerMap:

#self.loggers.append(alogger)

"""

if klass != Logger:

if not issubclass(klass, Logger):

raise TypeError, "logger not derived from logging.Logger: " + \

klass.__name__

global _loggerClass

"""

"""

def __init__(self, rootnode):

"""

self.root = rootnode

self.disable = 0

self.emittedNoHandlerWarning = 0

self.loggerDict = {}

def getLogger(self, name):

"""

rv = None

_acquireLock()

try:

if name in self.loggerDict:

rv = self.loggerDict[name]

if isinstance(rv, PlaceHolder):

ph = rv

rv = _loggerClass(name)

rv.manager = self

self.loggerDict[name] = rv

self._fixupChildren(ph, rv)

self._fixupParents(rv)

else:

rv = _loggerClass(name)

rv.manager = self

self.loggerDict[name] = rv

self._fixupParents(rv)

finally:

_releaseLock()

return rv

def _fixupParents(self, alogger):

"""

name = alogger.name

i = string.rfind(name, ".")

rv = None

while (i > 0) and not rv:

substr = name[:i]

if substr not in self.loggerDict:

self.loggerDict[substr] = PlaceHolder(alogger)

else:

obj = self.loggerDict[substr]

if isinstance(obj, Logger):

rv = obj

else:

assert isinstance(obj, PlaceHolder)

obj.append(alogger)

i = string.rfind(name, ".", 0, i - 1)

if not rv:

rv = self.root

alogger.parent = rv

def _fixupChildren(self, ph, alogger):

"""

name = alogger.name

namelen = len(name)

for c in ph.loggerMap.keys():

#The if means ... if not c.parent.name.startswith(nm)

#if string.find(c.parent.name, nm) <> 0:

if c.parent.name[:namelen] != name:

alogger.parent = c.parent