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