home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1716 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  12.8 KB  |  408 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import bdb
  5. import cmd
  6. import linecache
  7. import os
  8. import sys
  9. from IPython import PyColorize, ColorANSI, ipapi
  10. from IPython.genutils import Term
  11. from IPython.excolors import exception_colors
  12. has_pydb = False
  13. prompt = 'ipdb> '
  14. if '-pydb' in sys.argv:
  15.     
  16.     try:
  17.         import pydb
  18.         if hasattr(pydb.pydb, 'runl') and pydb.version > '1.17':
  19.             has_pydb = True
  20.     except ImportError:
  21.         print 'Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available'
  22.     except:
  23.         None<EXCEPTION MATCH>ImportError
  24.     
  25.  
  26. None<EXCEPTION MATCH>ImportError
  27. if has_pydb:
  28.     from pydb import Pdb as OldPdb
  29.     prompt = 'ipydb> '
  30. else:
  31.     from pdb import Pdb as OldPdb
  32.  
  33. def BdbQuit_excepthook(et, ev, tb):
  34.     if et == bdb.BdbQuit:
  35.         print 'Exiting Debugger.'
  36.     else:
  37.         BdbQuit_excepthook.excepthook_ori(et, ev, tb)
  38.  
  39.  
  40. def BdbQuit_IPython_excepthook(self, et, ev, tb):
  41.     print 'Exiting Debugger.'
  42.  
  43.  
  44. class Tracer(object):
  45.     
  46.     def __init__(self, colors = None):
  47.         global __IPYTHON__
  48.         
  49.         try:
  50.             __IPYTHON__
  51.         except NameError:
  52.             __IPYTHON__ = ipapi.get(True, False)
  53.             BdbQuit_excepthook.excepthook_ori = sys.excepthook
  54.             sys.excepthook = BdbQuit_excepthook
  55.             def_colors = 'NoColor'
  56.             
  57.             try:
  58.                 import rlcompleter
  59.                 import readline
  60.                 readline.parse_and_bind('tab: complete')
  61.             except ImportError:
  62.                 pass
  63.             except:
  64.                 None<EXCEPTION MATCH>ImportError
  65.             
  66.  
  67.             None<EXCEPTION MATCH>ImportError
  68.  
  69.         ip = ipapi.get()
  70.         def_colors = ip.options.colors
  71.         ip.set_custom_exc((bdb.BdbQuit,), BdbQuit_IPython_excepthook)
  72.         if colors is None:
  73.             colors = def_colors
  74.         
  75.         self.debugger = Pdb(colors)
  76.  
  77.     
  78.     def __call__(self):
  79.         self.debugger.set_trace(sys._getframe().f_back)
  80.  
  81.  
  82.  
  83. def decorate_fn_with_doc(new_fn, old_fn, additional_text = ''):
  84.     
  85.     def wrapper(*args, **kw):
  86.         return new_fn(*args, **kw)
  87.  
  88.     if old_fn.__doc__:
  89.         wrapper.__doc__ = old_fn.__doc__ + additional_text
  90.     
  91.     return wrapper
  92.  
  93.  
  94. def _file_lines(fname):
  95.     
  96.     try:
  97.         outfile = open(fname)
  98.     except IOError:
  99.         return []
  100.  
  101.     out = outfile.readlines()
  102.     outfile.close()
  103.     return out
  104.  
  105.  
  106. class Pdb(OldPdb):
  107.     if sys.version[:3] >= '2.5' or has_pydb:
  108.         
  109.         def __init__(self, color_scheme = 'NoColor', completekey = None, stdin = None, stdout = None):
  110.             if has_pydb and completekey is None:
  111.                 OldPdb.__init__(self, stdin = stdin, stdout = Term.cout)
  112.             else:
  113.                 OldPdb.__init__(self, completekey, stdin, stdout)
  114.             self.prompt = prompt
  115.             self.is_pydb = has_pydb
  116.             if self.is_pydb:
  117.                 import pydb.fns as pydb
  118.                 
  119.                 self.checkline = lambda filename, lineno: pydb.fns.checkline(self, filename, lineno)
  120.                 self.curframe = None
  121.                 self.do_restart = self.new_do_restart
  122.                 self.old_all_completions = __IPYTHON__.Completer.all_completions
  123.                 __IPYTHON__.Completer.all_completions = self.all_completions
  124.                 self.do_list = decorate_fn_with_doc(self.list_command_pydb, OldPdb.do_list)
  125.                 self.do_l = self.do_list
  126.                 self.do_frame = decorate_fn_with_doc(self.new_do_frame, OldPdb.do_frame)
  127.             
  128.             self.aliases = { }
  129.             self.color_scheme_table = exception_colors()
  130.             C = ColorANSI.TermColors
  131.             cst = self.color_scheme_table
  132.             cst['NoColor'].colors.breakpoint_enabled = C.NoColor
  133.             cst['NoColor'].colors.breakpoint_disabled = C.NoColor
  134.             cst['Linux'].colors.breakpoint_enabled = C.LightRed
  135.             cst['Linux'].colors.breakpoint_disabled = C.Red
  136.             cst['LightBG'].colors.breakpoint_enabled = C.LightRed
  137.             cst['LightBG'].colors.breakpoint_disabled = C.Red
  138.             self.set_colors(color_scheme)
  139.             self.parser = PyColorize.Parser()
  140.  
  141.     else:
  142.         
  143.         def __init__(self, color_scheme = 'NoColor'):
  144.             bdb.Bdb.__init__(self)
  145.             cmd.Cmd.__init__(self, completekey = None)
  146.             self.prompt = 'ipdb> '
  147.             self.aliases = { }
  148.             self.mainpyfile = ''
  149.             self._wait_for_mainpyfile = 0
  150.             
  151.             try:
  152.                 self.rcLines = _file_lines(os.path.join(os.environ['HOME'], '.pdbrc'))
  153.             except KeyError:
  154.                 self.rcLines = []
  155.  
  156.             self.rcLines.extend(_file_lines('.pdbrc'))
  157.             self.color_scheme_table = exception_colors()
  158.             C = ColorANSI.TermColors
  159.             cst = self.color_scheme_table
  160.             cst['NoColor'].colors.breakpoint_enabled = C.NoColor
  161.             cst['NoColor'].colors.breakpoint_disabled = C.NoColor
  162.             cst['Linux'].colors.breakpoint_enabled = C.LightRed
  163.             cst['Linux'].colors.breakpoint_disabled = C.Red
  164.             cst['LightBG'].colors.breakpoint_enabled = C.LightRed
  165.             cst['LightBG'].colors.breakpoint_disabled = C.Red
  166.             self.set_colors(color_scheme)
  167.             self.parser = PyColorize.Parser()
  168.  
  169.     
  170.     def set_colors(self, scheme):
  171.         self.color_scheme_table.set_active_scheme(scheme)
  172.  
  173.     
  174.     def interaction(self, frame, traceback):
  175.         __IPYTHON__.set_completer_frame(frame)
  176.         OldPdb.interaction(self, frame, traceback)
  177.  
  178.     
  179.     def new_do_up(self, arg):
  180.         OldPdb.do_up(self, arg)
  181.         __IPYTHON__.set_completer_frame(self.curframe)
  182.  
  183.     do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
  184.     
  185.     def new_do_down(self, arg):
  186.         OldPdb.do_down(self, arg)
  187.         __IPYTHON__.set_completer_frame(self.curframe)
  188.  
  189.     do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
  190.     
  191.     def new_do_frame(self, arg):
  192.         OldPdb.do_frame(self, arg)
  193.         __IPYTHON__.set_completer_frame(self.curframe)
  194.  
  195.     
  196.     def new_do_quit(self, arg):
  197.         if hasattr(self, 'old_all_completions'):
  198.             __IPYTHON__.Completer.all_completions = self.old_all_completions
  199.         
  200.         return OldPdb.do_quit(self, arg)
  201.  
  202.     do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
  203.     
  204.     def new_do_restart(self, arg):
  205.         self.msg("Restart doesn't make sense here. Using 'quit' instead.")
  206.         return self.do_quit(arg)
  207.  
  208.     
  209.     def postloop(self):
  210.         __IPYTHON__.set_completer_frame(None)
  211.  
  212.     
  213.     def print_stack_trace(self):
  214.         
  215.         try:
  216.             for frame_lineno in self.stack:
  217.                 self.print_stack_entry(frame_lineno, context = 5)
  218.         except KeyboardInterrupt:
  219.             pass
  220.  
  221.  
  222.     
  223.     def print_stack_entry(self, frame_lineno, prompt_prefix = '\n-> ', context = 3):
  224.         print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
  225.         (frame, lineno) = frame_lineno
  226.         filename = frame.f_code.co_filename
  227.         __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
  228.  
  229.     
  230.     def format_stack_entry(self, frame_lineno, lprefix = ': ', context = 3):
  231.         import linecache
  232.         import repr
  233.         ret = []
  234.         Colors = self.color_scheme_table.active_colors
  235.         ColorsNormal = Colors.Normal
  236.         tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
  237.         tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
  238.         tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
  239.         tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
  240.         (frame, lineno) = frame_lineno
  241.         return_value = ''
  242.         if '__return__' in frame.f_locals:
  243.             rv = frame.f_locals['__return__']
  244.             return_value += repr.repr(rv) + '\n'
  245.         
  246.         ret.append(return_value)
  247.         filename = self.canonic(frame.f_code.co_filename)
  248.         link = tpl_link % filename
  249.         if frame.f_code.co_name:
  250.             func = frame.f_code.co_name
  251.         else:
  252.             func = '<lambda>'
  253.         call = ''
  254.         if func != '?':
  255.             if '__args__' in frame.f_locals:
  256.                 args = repr.repr(frame.f_locals['__args__'])
  257.             else:
  258.                 args = '()'
  259.             call = tpl_call % (func, args)
  260.         
  261.         if frame is self.curframe:
  262.             ret.append('> ')
  263.         else:
  264.             ret.append('  ')
  265.         ret.append('%s(%s)%s\n' % (link, lineno, call))
  266.         start = lineno - 1 - context // 2
  267.         lines = linecache.getlines(filename)
  268.         start = max(start, 0)
  269.         start = min(start, len(lines) - context)
  270.         lines = lines[start:start + context]
  271.         for i, line in enumerate(lines):
  272.             show_arrow = start + 1 + i == lineno
  273.             if not frame is self.curframe or show_arrow or tpl_line_em:
  274.                 pass
  275.             linetpl = tpl_line
  276.             ret.append(self._Pdb__format_line(linetpl, filename, start + 1 + i, line, arrow = show_arrow))
  277.         
  278.         return ''.join(ret)
  279.  
  280.     
  281.     def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
  282.         bp_mark = ''
  283.         bp_mark_color = ''
  284.         scheme = self.color_scheme_table.active_scheme_name
  285.         (new_line, err) = self.parser.format2(line, 'str', scheme)
  286.         if not err:
  287.             line = new_line
  288.         
  289.         bp = None
  290.         if lineno in self.get_file_breaks(filename):
  291.             bps = self.get_breaks(filename, lineno)
  292.             bp = bps[-1]
  293.         
  294.         if bp:
  295.             Colors = self.color_scheme_table.active_colors
  296.             bp_mark = str(bp.number)
  297.             bp_mark_color = Colors.breakpoint_enabled
  298.             if not bp.enabled:
  299.                 bp_mark_color = Colors.breakpoint_disabled
  300.             
  301.         
  302.         numbers_width = 7
  303.         if arrow:
  304.             pad = numbers_width - len(str(lineno)) - len(bp_mark)
  305.             if pad >= 3:
  306.                 marker = '-' * (pad - 3) + '-> '
  307.             elif pad == 2:
  308.                 marker = '> '
  309.             elif pad == 1:
  310.                 marker = '>'
  311.             else:
  312.                 marker = ''
  313.             num = '%s%s' % (marker, str(lineno))
  314.             line = tpl_line % (bp_mark_color + bp_mark, num, line)
  315.         else:
  316.             num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
  317.             line = tpl_line % (bp_mark_color + bp_mark, num, line)
  318.         return line
  319.  
  320.     
  321.     def list_command_pydb(self, arg):
  322.         (filename, first, last) = OldPdb.parse_list_cmd(self, arg)
  323.         if filename is not None:
  324.             self.print_list_lines(filename, first, last)
  325.         
  326.  
  327.     
  328.     def print_list_lines(self, filename, first, last):
  329.         
  330.         try:
  331.             Colors = self.color_scheme_table.active_colors
  332.             ColorsNormal = Colors.Normal
  333.             tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
  334.             tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
  335.             src = []
  336.             for lineno in range(first, last + 1):
  337.                 line = linecache.getline(filename, lineno)
  338.                 if not line:
  339.                     break
  340.                 
  341.                 if lineno == self.curframe.f_lineno:
  342.                     line = self._Pdb__format_line(tpl_line_em, filename, lineno, line, arrow = True)
  343.                 else:
  344.                     line = self._Pdb__format_line(tpl_line, filename, lineno, line, arrow = False)
  345.                 src.append(line)
  346.                 self.lineno = lineno
  347.             
  348.             print >>Term.cout, ''.join(src)
  349.         except KeyboardInterrupt:
  350.             pass
  351.  
  352.  
  353.     
  354.     def do_list(self, arg):
  355.         self.lastcmd = 'list'
  356.         last = None
  357.         if arg:
  358.             
  359.             try:
  360.                 x = eval(arg, { }, { })
  361.                 if type(x) == type(()):
  362.                     (first, last) = x
  363.                     first = int(first)
  364.                     last = int(last)
  365.                     if last < first:
  366.                         last = first + last
  367.                     
  368.                 else:
  369.                     first = max(1, int(x) - 5)
  370.             print '*** Error in argument:', `arg`
  371.             return None
  372.  
  373.         elif self.lineno is None:
  374.             first = max(1, self.curframe.f_lineno - 5)
  375.         else:
  376.             first = self.lineno + 1
  377.         if last is None:
  378.             last = first + 10
  379.         
  380.         self.print_list_lines(self.curframe.f_code.co_filename, first, last)
  381.         lineno = first
  382.         filename = self.curframe.f_code.co_filename
  383.         __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
  384.  
  385.     do_l = do_list
  386.     
  387.     def do_pdef(self, arg):
  388.         namespaces = [
  389.             ('Locals', self.curframe.f_locals),
  390.             ('Globals', self.curframe.f_globals)]
  391.         __IPYTHON__.magic_pdef(arg, namespaces = namespaces)
  392.  
  393.     
  394.     def do_pdoc(self, arg):
  395.         namespaces = [
  396.             ('Locals', self.curframe.f_locals),
  397.             ('Globals', self.curframe.f_globals)]
  398.         __IPYTHON__.magic_pdoc(arg, namespaces = namespaces)
  399.  
  400.     
  401.     def do_pinfo(self, arg):
  402.         namespaces = [
  403.             ('Locals', self.curframe.f_locals),
  404.             ('Globals', self.curframe.f_globals)]
  405.         __IPYTHON__.magic_pinfo('pinfo %s' % arg, namespaces = namespaces)
  406.  
  407.  
  408.