home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / logging / __init__.pyo (.txt) next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  26.2 KB  |  999 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __all__ = [
  5.     'BASIC_FORMAT',
  6.     'BufferingFormatter',
  7.     'CRITICAL',
  8.     'DEBUG',
  9.     'ERROR',
  10.     'FATAL',
  11.     'FileHandler',
  12.     'Filter',
  13.     'Formatter',
  14.     'Handler',
  15.     'INFO',
  16.     'LogRecord',
  17.     'Logger',
  18.     'LoggerAdapter',
  19.     'NOTSET',
  20.     'NullHandler',
  21.     'StreamHandler',
  22.     'WARN',
  23.     'WARNING',
  24.     'addLevelName',
  25.     'basicConfig',
  26.     'captureWarnings',
  27.     'critical',
  28.     'debug',
  29.     'disable',
  30.     'error',
  31.     'exception',
  32.     'fatal',
  33.     'getLevelName',
  34.     'getLogger',
  35.     'getLoggerClass',
  36.     'info',
  37.     'log',
  38.     'makeLogRecord',
  39.     'setLoggerClass',
  40.     'warn',
  41.     'warning']
  42. import sys
  43. import os
  44. import types
  45. import time
  46. import string
  47. import cStringIO
  48. import traceback
  49.  
  50. try:
  51.     import codecs
  52. except ImportError:
  53.     codecs = None
  54.  
  55.  
  56. try:
  57.     import thread
  58.     import threading
  59. except ImportError:
  60.     thread = None
  61.  
  62. __author__ = 'Vinay Sajip <vinay_sajip@red-dove.com>'
  63. __status__ = 'production'
  64. __version__ = '0.5.0.5'
  65. __date__ = '17 February 2009'
  66. if hasattr(sys, 'frozen'):
  67.     _srcfile = 'logging%s__init__%s' % (os.sep, __file__[-4:])
  68. elif string.lower(__file__[-4:]) in ('.pyc', '.pyo'):
  69.     _srcfile = __file__[:-4] + '.py'
  70. else:
  71.     _srcfile = __file__
  72. _srcfile = os.path.normcase(_srcfile)
  73.  
  74. def currentframe():
  75.     
  76.     try:
  77.         raise Exception
  78.     except:
  79.         return sys.exc_traceback.tb_frame.f_back
  80.  
  81.  
  82. if hasattr(sys, '_getframe'):
  83.     
  84.     currentframe = lambda : sys._getframe(3)
  85.  
  86. _startTime = time.time()
  87. raiseExceptions = 1
  88. logThreads = 1
  89. logMultiprocessing = 1
  90. logProcesses = 1
  91. CRITICAL = 50
  92. FATAL = CRITICAL
  93. ERROR = 40
  94. WARNING = 30
  95. WARN = WARNING
  96. INFO = 20
  97. DEBUG = 10
  98. NOTSET = 0
  99. _levelNames = {
  100.     CRITICAL: 'CRITICAL',
  101.     ERROR: 'ERROR',
  102.     WARNING: 'WARNING',
  103.     INFO: 'INFO',
  104.     DEBUG: 'DEBUG',
  105.     NOTSET: 'NOTSET',
  106.     'CRITICAL': CRITICAL,
  107.     'ERROR': ERROR,
  108.     'WARN': WARNING,
  109.     'WARNING': WARNING,
  110.     'INFO': INFO,
  111.     'DEBUG': DEBUG,
  112.     'NOTSET': NOTSET }
  113.  
  114. def getLevelName(level):
  115.     return _levelNames.get(level, 'Level %s' % level)
  116.  
  117.  
  118. def addLevelName(level, levelName):
  119.     _acquireLock()
  120.     
  121.     try:
  122.         _levelNames[level] = levelName
  123.         _levelNames[levelName] = level
  124.     finally:
  125.         _releaseLock()
  126.  
  127.  
  128. _lock = None
  129.  
  130. def _acquireLock():
  131.     global _lock
  132.     if not _lock and thread:
  133.         _lock = threading.RLock()
  134.     
  135.     if _lock:
  136.         _lock.acquire()
  137.     
  138.  
  139.  
  140. def _releaseLock():
  141.     if _lock:
  142.         _lock.release()
  143.     
  144.  
  145.  
  146. class LogRecord:
  147.     
  148.     def __init__(self, name, level, pathname, lineno, msg, args, exc_info, func = None):
  149.         ct = time.time()
  150.         self.name = name
  151.         self.msg = msg
  152.         if args and len(args) == 1 and type(args[0]) == types.DictType and args[0]:
  153.             args = args[0]
  154.         
  155.         self.args = args
  156.         self.levelname = getLevelName(level)
  157.         self.levelno = level
  158.         self.pathname = pathname
  159.         
  160.         try:
  161.             self.filename = os.path.basename(pathname)
  162.             self.module = os.path.splitext(self.filename)[0]
  163.         except (TypeError, ValueError, AttributeError):
  164.             self.filename = pathname
  165.             self.module = 'Unknown module'
  166.  
  167.         self.exc_info = exc_info
  168.         self.exc_text = None
  169.         self.lineno = lineno
  170.         self.funcName = func
  171.         self.created = ct
  172.         self.msecs = (ct - long(ct)) * 1000
  173.         self.relativeCreated = (self.created - _startTime) * 1000
  174.         if logThreads and thread:
  175.             self.thread = thread.get_ident()
  176.             self.threadName = threading.current_thread().name
  177.         else:
  178.             self.thread = None
  179.             self.threadName = None
  180.         if logMultiprocessing:
  181.             current_process = current_process
  182.             import multiprocessing
  183.             self.processName = current_process().name
  184.         else:
  185.             self.processName = None
  186.         if logProcesses and hasattr(os, 'getpid'):
  187.             self.process = os.getpid()
  188.         else:
  189.             self.process = None
  190.  
  191.     
  192.     def __str__(self):
  193.         return '<LogRecord: %s, %s, %s, %s, "%s">' % (self.name, self.levelno, self.pathname, self.lineno, self.msg)
  194.  
  195.     
  196.     def getMessage(self):
  197.         if not hasattr(types, 'UnicodeType'):
  198.             msg = str(self.msg)
  199.         else:
  200.             msg = self.msg
  201.             if type(msg) not in (types.UnicodeType, types.StringType):
  202.                 
  203.                 try:
  204.                     msg = str(self.msg)
  205.                 except UnicodeError:
  206.                     msg = self.msg
  207.                 except:
  208.                     None<EXCEPTION MATCH>UnicodeError
  209.                 
  210.  
  211.             None<EXCEPTION MATCH>UnicodeError
  212.         if self.args:
  213.             msg = msg % self.args
  214.         
  215.         return msg
  216.  
  217.  
  218.  
  219. def makeLogRecord(dict):
  220.     rv = LogRecord(None, None, '', 0, '', (), None, None)
  221.     rv.__dict__.update(dict)
  222.     return rv
  223.  
  224.  
  225. class Formatter:
  226.     converter = time.localtime
  227.     
  228.     def __init__(self, fmt = None, datefmt = None):
  229.         if fmt:
  230.             self._fmt = fmt
  231.         else:
  232.             self._fmt = '%(message)s'
  233.         self.datefmt = datefmt
  234.  
  235.     
  236.     def formatTime(self, record, datefmt = None):
  237.         ct = self.converter(record.created)
  238.         if datefmt:
  239.             s = time.strftime(datefmt, ct)
  240.         else:
  241.             t = time.strftime('%Y-%m-%d %H:%M:%S', ct)
  242.             s = '%s,%03d' % (t, record.msecs)
  243.         return s
  244.  
  245.     
  246.     def formatException(self, ei):
  247.         sio = cStringIO.StringIO()
  248.         traceback.print_exception(ei[0], ei[1], ei[2], None, sio)
  249.         s = sio.getvalue()
  250.         sio.close()
  251.         if s[-1:] == '\n':
  252.             s = s[:-1]
  253.         
  254.         return s
  255.  
  256.     
  257.     def format(self, record):
  258.         record.message = record.getMessage()
  259.         if string.find(self._fmt, '%(asctime)') >= 0:
  260.             record.asctime = self.formatTime(record, self.datefmt)
  261.         
  262.         s = self._fmt % record.__dict__
  263.         if record.exc_info:
  264.             if not record.exc_text:
  265.                 record.exc_text = self.formatException(record.exc_info)
  266.             
  267.         
  268.         if record.exc_text:
  269.             if s[-1:] != '\n':
  270.                 s = s + '\n'
  271.             
  272.             s = s + record.exc_text
  273.         
  274.         return s
  275.  
  276.  
  277. _defaultFormatter = Formatter()
  278.  
  279. class BufferingFormatter:
  280.     
  281.     def __init__(self, linefmt = None):
  282.         if linefmt:
  283.             self.linefmt = linefmt
  284.         else:
  285.             self.linefmt = _defaultFormatter
  286.  
  287.     
  288.     def formatHeader(self, records):
  289.         return ''
  290.  
  291.     
  292.     def formatFooter(self, records):
  293.         return ''
  294.  
  295.     
  296.     def format(self, records):
  297.         rv = ''
  298.         if len(records) > 0:
  299.             rv = rv + self.formatHeader(records)
  300.             for record in records:
  301.                 rv = rv + self.linefmt.format(record)
  302.             
  303.             rv = rv + self.formatFooter(records)
  304.         
  305.         return rv
  306.  
  307.  
  308.  
  309. class Filter:
  310.     
  311.     def __init__(self, name = ''):
  312.         self.name = name
  313.         self.nlen = len(name)
  314.  
  315.     
  316.     def filter(self, record):
  317.         if self.nlen == 0:
  318.             return 1
  319.         if self.name == record.name:
  320.             return 1
  321.         if string.find(record.name, self.name, 0, self.nlen) != 0:
  322.             return 0
  323.         return record.name[self.nlen] == '.'
  324.  
  325.  
  326.  
  327. class Filterer:
  328.     
  329.     def __init__(self):
  330.         self.filters = []
  331.  
  332.     
  333.     def addFilter(self, filter):
  334.         if filter not in self.filters:
  335.             self.filters.append(filter)
  336.         
  337.  
  338.     
  339.     def removeFilter(self, filter):
  340.         if filter in self.filters:
  341.             self.filters.remove(filter)
  342.         
  343.  
  344.     
  345.     def filter(self, record):
  346.         rv = 1
  347.         for f in self.filters:
  348.             if not f.filter(record):
  349.                 rv = 0
  350.                 break
  351.                 continue
  352.         
  353.         return rv
  354.  
  355.  
  356. _handlers = { }
  357. _handlerList = []
  358.  
  359. class Handler(Filterer):
  360.     
  361.     def __init__(self, level = NOTSET):
  362.         Filterer.__init__(self)
  363.         self.level = level
  364.         self.formatter = None
  365.         _acquireLock()
  366.         
  367.         try:
  368.             _handlers[self] = 1
  369.             _handlerList.insert(0, self)
  370.         finally:
  371.             _releaseLock()
  372.  
  373.         self.createLock()
  374.  
  375.     
  376.     def createLock(self):
  377.         if thread:
  378.             self.lock = threading.RLock()
  379.         else:
  380.             self.lock = None
  381.  
  382.     
  383.     def acquire(self):
  384.         if self.lock:
  385.             self.lock.acquire()
  386.         
  387.  
  388.     
  389.     def release(self):
  390.         if self.lock:
  391.             self.lock.release()
  392.         
  393.  
  394.     
  395.     def setLevel(self, level):
  396.         self.level = level
  397.  
  398.     
  399.     def format(self, record):
  400.         if self.formatter:
  401.             fmt = self.formatter
  402.         else:
  403.             fmt = _defaultFormatter
  404.         return fmt.format(record)
  405.  
  406.     
  407.     def emit(self, record):
  408.         raise NotImplementedError, 'emit must be implemented by Handler subclasses'
  409.  
  410.     
  411.     def handle(self, record):
  412.         rv = self.filter(record)
  413.         if rv:
  414.             self.acquire()
  415.             
  416.             try:
  417.                 self.emit(record)
  418.             finally:
  419.                 self.release()
  420.  
  421.         
  422.         return rv
  423.  
  424.     
  425.     def setFormatter(self, fmt):
  426.         self.formatter = fmt
  427.  
  428.     
  429.     def flush(self):
  430.         pass
  431.  
  432.     
  433.     def close(self):
  434.         _acquireLock()
  435.         
  436.         try:
  437.             del _handlers[self]
  438.             _handlerList.remove(self)
  439.         finally:
  440.             _releaseLock()
  441.  
  442.  
  443.     
  444.     def handleError(self, record):
  445.         if raiseExceptions:
  446.             ei = sys.exc_info()
  447.             
  448.             try:
  449.                 traceback.print_exception(ei[0], ei[1], ei[2], None, sys.stderr)
  450.             except IOError:
  451.                 pass
  452.             finally:
  453.                 del ei
  454.  
  455.         
  456.  
  457.  
  458.  
  459. class StreamHandler(Handler):
  460.     
  461.     def __init__(self, strm = None):
  462.         Handler.__init__(self)
  463.         if strm is None:
  464.             strm = sys.stderr
  465.         
  466.         self.stream = strm
  467.  
  468.     
  469.     def flush(self):
  470.         if self.stream and hasattr(self.stream, 'flush'):
  471.             self.stream.flush()
  472.         
  473.  
  474.     
  475.     def emit(self, record):
  476.         
  477.         try:
  478.             msg = self.format(record)
  479.             stream = self.stream
  480.             fs = '%s\n'
  481.             if not hasattr(types, 'UnicodeType'):
  482.                 stream.write(fs % msg)
  483.             else:
  484.                 
  485.                 try:
  486.                     if isinstance(msg, unicode) and getattr(stream, 'encoding', None):
  487.                         fs = fs.decode(stream.encoding)
  488.                         
  489.                         try:
  490.                             stream.write(fs % msg)
  491.                         except UnicodeEncodeError:
  492.                             stream.write((fs % msg).encode(stream.encoding))
  493.                         except:
  494.                             None<EXCEPTION MATCH>UnicodeEncodeError
  495.                         
  496.  
  497.                     None<EXCEPTION MATCH>UnicodeEncodeError
  498.                     stream.write(fs % msg)
  499.                 except UnicodeError:
  500.                     stream.write(fs % msg.encode('UTF-8'))
  501.  
  502.             self.flush()
  503.         except (KeyboardInterrupt, SystemExit):
  504.             raise 
  505.         except:
  506.             self.handleError(record)
  507.  
  508.  
  509.  
  510.  
  511. class FileHandler(StreamHandler):
  512.     
  513.     def __init__(self, filename, mode = 'a', encoding = None, delay = 0):
  514.         if codecs is None:
  515.             encoding = None
  516.         
  517.         self.baseFilename = os.path.abspath(filename)
  518.         self.mode = mode
  519.         self.encoding = encoding
  520.         if delay:
  521.             Handler.__init__(self)
  522.             self.stream = None
  523.         else:
  524.             StreamHandler.__init__(self, self._open())
  525.  
  526.     
  527.     def close(self):
  528.         if self.stream:
  529.             self.flush()
  530.             if hasattr(self.stream, 'close'):
  531.                 self.stream.close()
  532.             
  533.             StreamHandler.close(self)
  534.             self.stream = None
  535.         
  536.  
  537.     
  538.     def _open(self):
  539.         if self.encoding is None:
  540.             stream = open(self.baseFilename, self.mode)
  541.         else:
  542.             stream = codecs.open(self.baseFilename, self.mode, self.encoding)
  543.         return stream
  544.  
  545.     
  546.     def emit(self, record):
  547.         if self.stream is None:
  548.             self.stream = self._open()
  549.         
  550.         StreamHandler.emit(self, record)
  551.  
  552.  
  553.  
  554. class PlaceHolder:
  555.     
  556.     def __init__(self, alogger):
  557.         self.loggerMap = {
  558.             alogger: None }
  559.  
  560.     
  561.     def append(self, alogger):
  562.         if alogger not in self.loggerMap:
  563.             self.loggerMap[alogger] = None
  564.         
  565.  
  566.  
  567. _loggerClass = None
  568.  
  569. def setLoggerClass(klass):
  570.     global _loggerClass
  571.     if klass != Logger:
  572.         if not issubclass(klass, Logger):
  573.             raise TypeError, 'logger not derived from logging.Logger: ' + klass.__name__
  574.         issubclass(klass, Logger)
  575.     
  576.     _loggerClass = klass
  577.  
  578.  
  579. def getLoggerClass():
  580.     return _loggerClass
  581.  
  582.  
  583. class Manager:
  584.     
  585.     def __init__(self, rootnode):
  586.         self.root = rootnode
  587.         self.disable = 0
  588.         self.emittedNoHandlerWarning = 0
  589.         self.loggerDict = { }
  590.  
  591.     
  592.     def getLogger(self, name):
  593.         rv = None
  594.         _acquireLock()
  595.         
  596.         try:
  597.             if name in self.loggerDict:
  598.                 rv = self.loggerDict[name]
  599.                 if isinstance(rv, PlaceHolder):
  600.                     ph = rv
  601.                     rv = _loggerClass(name)
  602.                     rv.manager = self
  603.                     self.loggerDict[name] = rv
  604.                     self._fixupChildren(ph, rv)
  605.                     self._fixupParents(rv)
  606.                 
  607.             else:
  608.                 rv = _loggerClass(name)
  609.                 rv.manager = self
  610.                 self.loggerDict[name] = rv
  611.                 self._fixupParents(rv)
  612.         finally:
  613.             _releaseLock()
  614.  
  615.         return rv
  616.  
  617.     
  618.     def _fixupParents(self, alogger):
  619.         name = alogger.name
  620.         i = string.rfind(name, '.')
  621.         rv = None
  622.         while i > 0 and not rv:
  623.             substr = name[:i]
  624.             if substr not in self.loggerDict:
  625.                 self.loggerDict[substr] = PlaceHolder(alogger)
  626.             else:
  627.                 obj = self.loggerDict[substr]
  628.                 if isinstance(obj, Logger):
  629.                     rv = obj
  630.                 else:
  631.                     obj.append(alogger)
  632.             i = string.rfind(name, '.', 0, i - 1)
  633.         if not rv:
  634.             rv = self.root
  635.         
  636.         alogger.parent = rv
  637.  
  638.     
  639.     def _fixupChildren(self, ph, alogger):
  640.         name = alogger.name
  641.         namelen = len(name)
  642.         for c in ph.loggerMap.keys():
  643.             if c.parent.name[:namelen] != name:
  644.                 alogger.parent = c.parent
  645.                 c.parent = alogger
  646.                 continue
  647.         
  648.  
  649.  
  650.  
  651. class Logger(Filterer):
  652.     
  653.     def __init__(self, name, level = NOTSET):
  654.         Filterer.__init__(self)
  655.         self.name = name
  656.         self.level = level
  657.         self.parent = None
  658.         self.propagate = 1
  659.         self.handlers = []
  660.         self.disabled = 0
  661.  
  662.     
  663.     def setLevel(self, level):
  664.         self.level = level
  665.  
  666.     
  667.     def debug(self, msg, *args, **kwargs):
  668.         if self.isEnabledFor(DEBUG):
  669.             self._log(DEBUG, msg, args, **kwargs)
  670.         
  671.  
  672.     
  673.     def info(self, msg, *args, **kwargs):
  674.         if self.isEnabledFor(INFO):
  675.             self._log(INFO, msg, args, **kwargs)
  676.         
  677.  
  678.     
  679.     def warning(self, msg, *args, **kwargs):
  680.         if self.isEnabledFor(WARNING):
  681.             self._log(WARNING, msg, args, **kwargs)
  682.         
  683.  
  684.     warn = warning
  685.     
  686.     def error(self, msg, *args, **kwargs):
  687.         if self.isEnabledFor(ERROR):
  688.             self._log(ERROR, msg, args, **kwargs)
  689.         
  690.  
  691.     
  692.     def exception(self, msg, *args):
  693.         self.error(*(msg,) + args, **{
  694.             'exc_info': 1 })
  695.  
  696.     
  697.     def critical(self, msg, *args, **kwargs):
  698.         if self.isEnabledFor(CRITICAL):
  699.             self._log(CRITICAL, msg, args, **kwargs)
  700.         
  701.  
  702.     fatal = critical
  703.     
  704.     def log(self, level, msg, *args, **kwargs):
  705.         if type(level) != types.IntType:
  706.             if raiseExceptions:
  707.                 raise TypeError, 'level must be an integer'
  708.             raiseExceptions
  709.             return None
  710.         type(level) != types.IntType
  711.         if self.isEnabledFor(level):
  712.             self._log(level, msg, args, **kwargs)
  713.         
  714.  
  715.     
  716.     def findCaller(self):
  717.         f = currentframe().f_back
  718.         rv = ('(unknown file)', 0, '(unknown function)')
  719.         while hasattr(f, 'f_code'):
  720.             co = f.f_code
  721.             filename = os.path.normcase(co.co_filename)
  722.             if filename == _srcfile:
  723.                 f = f.f_back
  724.                 continue
  725.             
  726.             rv = (filename, f.f_lineno, co.co_name)
  727.             break
  728.         return rv
  729.  
  730.     
  731.     def makeRecord(self, name, level, fn, lno, msg, args, exc_info, func = None, extra = None):
  732.         rv = LogRecord(name, level, fn, lno, msg, args, exc_info, func)
  733.         if extra is not None:
  734.             for key in extra:
  735.                 if key in ('message', 'asctime') or key in rv.__dict__:
  736.                     raise KeyError('Attempt to overwrite %r in LogRecord' % key)
  737.                 key in rv.__dict__
  738.                 rv.__dict__[key] = extra[key]
  739.             
  740.         
  741.         return rv
  742.  
  743.     
  744.     def _log(self, level, msg, args, exc_info = None, extra = None):
  745.         if _srcfile:
  746.             
  747.             try:
  748.                 (fn, lno, func) = self.findCaller()
  749.             except ValueError:
  750.                 (fn, lno, func) = ('(unknown file)', 0, '(unknown function)')
  751.             except:
  752.                 None<EXCEPTION MATCH>ValueError
  753.             
  754.  
  755.         None<EXCEPTION MATCH>ValueError
  756.         (fn, lno, func) = ('(unknown file)', 0, '(unknown function)')
  757.         if exc_info:
  758.             if type(exc_info) != types.TupleType:
  759.                 exc_info = sys.exc_info()
  760.             
  761.         
  762.         record = self.makeRecord(self.name, level, fn, lno, msg, args, exc_info, func, extra)
  763.         self.handle(record)
  764.  
  765.     
  766.     def handle(self, record):
  767.         if not (self.disabled) and self.filter(record):
  768.             self.callHandlers(record)
  769.         
  770.  
  771.     
  772.     def addHandler(self, hdlr):
  773.         if hdlr not in self.handlers:
  774.             self.handlers.append(hdlr)
  775.         
  776.  
  777.     
  778.     def removeHandler(self, hdlr):
  779.         if hdlr in self.handlers:
  780.             hdlr.acquire()
  781.             
  782.             try:
  783.                 self.handlers.remove(hdlr)
  784.             finally:
  785.                 hdlr.release()
  786.  
  787.         
  788.  
  789.     
  790.     def callHandlers(self, record):
  791.         c = self
  792.         found = 0
  793.         while c:
  794.             for hdlr in c.handlers:
  795.                 found = found + 1
  796.                 if record.levelno >= hdlr.level:
  797.                     hdlr.handle(record)
  798.                     continue
  799.             
  800.             if not c.propagate:
  801.                 c = None
  802.                 continue
  803.             c = c.parent
  804.         if found == 0 and raiseExceptions and not (self.manager.emittedNoHandlerWarning):
  805.             sys.stderr.write('No handlers could be found for logger "%s"\n' % self.name)
  806.             self.manager.emittedNoHandlerWarning = 1
  807.         
  808.  
  809.     
  810.     def getEffectiveLevel(self):
  811.         logger = self
  812.         while logger:
  813.             if logger.level:
  814.                 return logger.level
  815.             logger = logger.parent
  816.             continue
  817.             logger.level
  818.         return NOTSET
  819.  
  820.     
  821.     def isEnabledFor(self, level):
  822.         if self.manager.disable >= level:
  823.             return 0
  824.         return level >= self.getEffectiveLevel()
  825.  
  826.  
  827.  
  828. class RootLogger(Logger):
  829.     
  830.     def __init__(self, level):
  831.         Logger.__init__(self, 'root', level)
  832.  
  833.  
  834. _loggerClass = Logger
  835.  
  836. class LoggerAdapter:
  837.     
  838.     def __init__(self, logger, extra):
  839.         self.logger = logger
  840.         self.extra = extra
  841.  
  842.     
  843.     def process(self, msg, kwargs):
  844.         kwargs['extra'] = self.extra
  845.         return (msg, kwargs)
  846.  
  847.     
  848.     def debug(self, msg, *args, **kwargs):
  849.         (msg, kwargs) = self.process(msg, kwargs)
  850.         self.logger.debug(msg, *args, **kwargs)
  851.  
  852.     
  853.     def info(self, msg, *args, **kwargs):
  854.         (msg, kwargs) = self.process(msg, kwargs)
  855.         self.logger.info(msg, *args, **kwargs)
  856.  
  857.     
  858.     def warning(self, msg, *args, **kwargs):
  859.         (msg, kwargs) = self.process(msg, kwargs)
  860.         self.logger.warning(msg, *args, **kwargs)
  861.  
  862.     
  863.     def error(self, msg, *args, **kwargs):
  864.         (msg, kwargs) = self.process(msg, kwargs)
  865.         self.logger.error(msg, *args, **kwargs)
  866.  
  867.     
  868.     def exception(self, msg, *args, **kwargs):
  869.         (msg, kwargs) = self.process(msg, kwargs)
  870.         kwargs['exc_info'] = 1
  871.         self.logger.error(msg, *args, **kwargs)
  872.  
  873.     
  874.     def critical(self, msg, *args, **kwargs):
  875.         (msg, kwargs) = self.process(msg, kwargs)
  876.         self.logger.critical(msg, *args, **kwargs)
  877.  
  878.     
  879.     def log(self, level, msg, *args, **kwargs):
  880.         (msg, kwargs) = self.process(msg, kwargs)
  881.         self.logger.log(level, msg, *args, **kwargs)
  882.  
  883.  
  884. root = RootLogger(WARNING)
  885. Logger.root = root
  886. Logger.manager = Manager(Logger.root)
  887. BASIC_FORMAT = '%(levelname)s:%(name)s:%(message)s'
  888.  
  889. def basicConfig(**kwargs):
  890.     if len(root.handlers) == 0:
  891.         filename = kwargs.get('filename')
  892.         if filename:
  893.             mode = kwargs.get('filemode', 'a')
  894.             hdlr = FileHandler(filename, mode)
  895.         else:
  896.             stream = kwargs.get('stream')
  897.             hdlr = StreamHandler(stream)
  898.         fs = kwargs.get('format', BASIC_FORMAT)
  899.         dfs = kwargs.get('datefmt', None)
  900.         fmt = Formatter(fs, dfs)
  901.         hdlr.setFormatter(fmt)
  902.         root.addHandler(hdlr)
  903.         level = kwargs.get('level')
  904.         if level is not None:
  905.             root.setLevel(level)
  906.         
  907.     
  908.  
  909.  
  910. def getLogger(name = None):
  911.     if name:
  912.         return Logger.manager.getLogger(name)
  913.     return root
  914.  
  915.  
  916. def critical(msg, *args, **kwargs):
  917.     if len(root.handlers) == 0:
  918.         basicConfig()
  919.     
  920.     root.critical(*(msg,) + args, **kwargs)
  921.  
  922. fatal = critical
  923.  
  924. def error(msg, *args, **kwargs):
  925.     if len(root.handlers) == 0:
  926.         basicConfig()
  927.     
  928.     root.error(*(msg,) + args, **kwargs)
  929.  
  930.  
  931. def exception(msg, *args):
  932.     error(*(msg,) + args, **{
  933.         'exc_info': 1 })
  934.  
  935.  
  936. def warning(msg, *args, **kwargs):
  937.     if len(root.handlers) == 0:
  938.         basicConfig()
  939.     
  940.     root.warning(*(msg,) + args, **kwargs)
  941.  
  942. warn = warning
  943.  
  944. def info(msg, *args, **kwargs):
  945.     if len(root.handlers) == 0:
  946.         basicConfig()
  947.     
  948.     root.info(*(msg,) + args, **kwargs)
  949.  
  950.  
  951. def debug(msg, *args, **kwargs):
  952.     if len(root.handlers) == 0:
  953.         basicConfig()
  954.     
  955.     root.debug(*(msg,) + args, **kwargs)
  956.  
  957.  
  958. def log(level, msg, *args, **kwargs):
  959.     if len(root.handlers) == 0:
  960.         basicConfig()
  961.     
  962.     root.log(*(level, msg) + args, **kwargs)
  963.  
  964.  
  965. def disable(level):
  966.     root.manager.disable = level
  967.  
  968.  
  969. def shutdown(handlerList = _handlerList):
  970.     for h in handlerList[:]:
  971.         
  972.         try:
  973.             h.flush()
  974.             h.close()
  975.         continue
  976.         if raiseExceptions:
  977.             raise 
  978.         raiseExceptions
  979.         continue
  980.  
  981.     
  982.  
  983.  
  984. try:
  985.     import atexit
  986.     atexit.register(shutdown)
  987. except ImportError:
  988.     
  989.     def exithook(status, old_exit = sys.exit):
  990.         
  991.         try:
  992.             shutdown()
  993.         finally:
  994.             old_exit(status)
  995.  
  996.  
  997.     sys.exit = exithook
  998.  
  999.