home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / logextensions.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  5.8 KB  |  212 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import logging
  5. LOGGING_ENABLED = True
  6. import sys
  7. from threading import currentThread
  8. _LogRecord = logging.LogRecord
  9.  
  10. class LogRecord(_LogRecord):
  11.     
  12.     def __init__(self, *a, **k):
  13.         _LogRecord.__init__(self, *a, **k)
  14.         self.threadCount = getattr(currentThread(), 'loopcount', 0)
  15.  
  16.     
  17.     def getMessage(self):
  18.         msg = self.msg
  19.         if type(msg) not in (unicode, str):
  20.             
  21.             try:
  22.                 msg = str(self.msg)
  23.             except UnicodeError:
  24.                 msg = repr(self.msg)
  25.             except:
  26.                 None<EXCEPTION MATCH>UnicodeError
  27.             
  28.  
  29.         None<EXCEPTION MATCH>UnicodeError
  30.         if self.args:
  31.             
  32.             try:
  33.                 msg = msg % self.args
  34.             except Exception:
  35.                 e = None
  36.                 
  37.                 try:
  38.                     return 'Error in log message (%r:%r): msg=%r, args=%r' % (self.filename, self.lineno, msg, self.args)
  39.                 except Exception:
  40.                     e2 = None
  41.                     return 'Error in log message (%r:%r)' % (self.filename, self.lineno)
  42.                 
  43.  
  44.                 None<EXCEPTION MATCH>Exception
  45.             
  46.  
  47.         None<EXCEPTION MATCH>Exception
  48.         if isinstance(msg, unicode):
  49.             msg = msg.encode('utf8')
  50.         
  51.         return msg
  52.  
  53.  
  54. logging.LogRecord = LogRecord
  55.  
  56. class StreamHandler(logging.Handler):
  57.     
  58.     def __init__(self, strm = None):
  59.         logging.Handler.__init__(self)
  60.         self._stream = strm
  61.         self.formatter = None
  62.         self.has_stream = True
  63.  
  64.     
  65.     def stream(self):
  66.         if self._stream is None and self.has_stream:
  67.             return sys.stderr
  68.         if self.has_stream:
  69.             return self._stream
  70.  
  71.     stream = property(stream)
  72.     
  73.     def flush(self):
  74.         
  75.         try:
  76.             self.stream.flush()
  77.         except:
  78.             if self._stream is not None:
  79.                 self._stream = None
  80.             else:
  81.                 self.has_stream = False
  82.  
  83.  
  84.     
  85.     def emit(self, record):
  86.         if not self.has_stream:
  87.             return None
  88.         
  89.         try:
  90.             msg = self.format(record)
  91.             fs = '%s\n'
  92.             
  93.             try:
  94.                 self.stream.write(fs % msg)
  95.             except UnicodeError:
  96.                 self.has_stream
  97.                 self.has_stream
  98.                 self.stream.write(fs % msg.encode('UTF-8'))
  99.             except Exception:
  100.                 self.has_stream = False
  101.             except:
  102.                 self.has_stream
  103.  
  104.         except (KeyboardInterrupt, SystemExit):
  105.             self.has_stream
  106.             self.has_stream
  107.             raise 
  108.         except:
  109.             self.has_stream
  110.             self.handleError(record)
  111.  
  112.  
  113.  
  114. logging.StreamHandler = StreamHandler
  115. logging.FileHandler.__bases__ = (StreamHandler,) + logging.FileHandler.__bases__[1:]
  116. _logcolors = [
  117.     (40, 'red bold'),
  118.     (30, 'yellow bold'),
  119.     (20, 'white'),
  120.     (10, 'grey')]
  121.  
  122. def logcolor_for_level(level):
  123.     for lvl, color in _logcolors:
  124.         if level >= lvl:
  125.             return color
  126.     
  127.     return color
  128.  
  129.  
  130. class ColorStreamHandler(StreamHandler):
  131.     pass
  132.  
  133. if getattr(getattr(sys, 'opts', None), 'console_color', False):
  134.     
  135.     try:
  136.         from gui.native.win import console
  137.     except ImportError:
  138.         pass
  139.  
  140.     
  141.     class ColorStreamHandler(StreamHandler):
  142.         
  143.         def emit(self, record):
  144.             console.color(logcolor_for_level(record.levelno)).__enter__()
  145.             
  146.             try:
  147.                 StreamHandler.emit(self, record)
  148.             finally:
  149.                 pass
  150.  
  151.  
  152.  
  153.  
  154.  
  155. def setup_sensitive_logs():
  156.     Logger = Logger
  157.     import logging
  158.     dev = getattr(sys, 'DEV', False)
  159.     full_log = getattr(getattr(sys, 'opts', None), 'full_log', False)
  160.     
  161.     nolog = lambda self, *a, **k: pass
  162.     for log_type in [
  163.         'critical',
  164.         'debug',
  165.         'error',
  166.         'exception',
  167.         'fatal',
  168.         'info',
  169.         'log',
  170.         'warn',
  171.         'warning']:
  172.         
  173.         def make_sensitive(name):
  174.             if dev or full_log:
  175.                 
  176.                 def sensitive(self, *a, **k):
  177.                     getattr(self, name)(*a, **k)
  178.  
  179.             else:
  180.                 sensitive = nolog
  181.             return sensitive
  182.  
  183.         func = make_sensitive(log_type)
  184.         setattr(Logger, log_type + '_s', func)
  185.     
  186.  
  187. setup_sensitive_logs()
  188. if not LOGGING_ENABLED:
  189.     
  190.     class NullRoot(object):
  191.         stream = None
  192.         setLevel = addHandler = info = (lambda : pass)
  193.  
  194.     
  195.     class NullLogger(object):
  196.         root = NullRoot()
  197.         handlers = []
  198.         debug = debug_s = info = info_s = warning = error = critical = (lambda : pass)
  199.  
  200.     _null_logger = NullLogger()
  201.     
  202.     class NullManager(object):
  203.         
  204.         def getLogger(self, name):
  205.             return _null_logger
  206.  
  207.  
  208.     _null_manager = NullManager()
  209.     NullLogger.manager = _null_manager
  210.     logging.Logger = NullLogger
  211.  
  212.