home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1812 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  42.1 KB  |  1,494 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import __main__
  5. import commands
  6.  
  7. try:
  8.     import doctest
  9. except ImportError:
  10.     pass
  11.  
  12. import os
  13. import platform
  14. import re
  15. import shlex
  16. import shutil
  17. import subprocess
  18. import sys
  19. import tempfile
  20. import time
  21. import types
  22. import warnings
  23.  
  24. try:
  25.     import curses
  26.     import termios
  27. except ImportError:
  28.     USE_CURSES = False
  29.  
  30. USE_CURSES = hasattr(curses, 'initscr')
  31. import IPython
  32. from IPython.Itpl import Itpl, itpl, printpl
  33. from IPython import DPyGetOpt, platutils
  34. from IPython.generics import result_display
  35. import IPython.ipapi as IPython
  36. from IPython.external.path import path
  37. if os.name == 'nt':
  38.     from IPython.winconsole import get_console_size
  39.  
  40.  
  41. try:
  42.     set
  43. except:
  44.     from sets import Set as set
  45.  
  46.  
  47. class Error(Exception):
  48.     pass
  49.  
  50.  
  51. class IOStream:
  52.     
  53.     def __init__(self, stream, fallback):
  54.         if not hasattr(stream, 'write') or not hasattr(stream, 'flush'):
  55.             stream = fallback
  56.         
  57.         self.stream = stream
  58.         self._swrite = stream.write
  59.         self.flush = stream.flush
  60.  
  61.     
  62.     def write(self, data):
  63.         
  64.         try:
  65.             self._swrite(data)
  66.         except:
  67.             
  68.             try:
  69.                 print >>self.stream, data,
  70.             print >>sys.stderr, 'ERROR - failed to write data to stream:', self.stream
  71.  
  72.  
  73.  
  74.     
  75.     def close(self):
  76.         pass
  77.  
  78.  
  79.  
  80. class IOTerm:
  81.     
  82.     def __init__(self, cin = None, cout = None, cerr = None):
  83.         self.cin = IOStream(cin, sys.stdin)
  84.         self.cout = IOStream(cout, sys.stdout)
  85.         self.cerr = IOStream(cerr, sys.stderr)
  86.  
  87.  
  88. Term = IOTerm()
  89. import IPython.rlineimpl as readline
  90. if sys.platform == 'win32' and readline.have_readline:
  91.     Term = IOTerm(cout = readline._outputfile, cerr = readline._outputfile)
  92.  
  93.  
  94. def warn(msg, level = 2, exit_val = 1):
  95.     if level > 0:
  96.         header = [
  97.             '',
  98.             '',
  99.             'WARNING: ',
  100.             'ERROR: ',
  101.             'FATAL ERROR: ']
  102.         print >>Term.cerr, '%s%s' % (header[level], msg)
  103.         if level == 4:
  104.             print >>Term.cerr, 'Exiting.\n'
  105.             sys.exit(exit_val)
  106.         
  107.     
  108.  
  109.  
  110. def info(msg):
  111.     warn(msg, level = 1)
  112.  
  113.  
  114. def error(msg):
  115.     warn(msg, level = 3)
  116.  
  117.  
  118. def fatal(msg, exit_val = 1):
  119.     warn(msg, exit_val = exit_val, level = 4)
  120.  
  121.  
  122. def debugx(expr, pre_msg = ''):
  123.     cf = sys._getframe(1)
  124.     print '[DBG:%s] %s%s -> %r' % (cf.f_code.co_name, pre_msg, expr, eval(expr, cf.f_globals, cf.f_locals))
  125.  
  126. StringTypes = types.StringTypes
  127.  
  128. try:
  129.     import resource
  130.     
  131.     def clocku():
  132.         return resource.getrusage(resource.RUSAGE_SELF)[0]
  133.  
  134.     
  135.     def clocks():
  136.         return resource.getrusage(resource.RUSAGE_SELF)[1]
  137.  
  138.     
  139.     def clock():
  140.         (u, s) = resource.getrusage(resource.RUSAGE_SELF)[:2]
  141.         return u + s
  142.  
  143.     
  144.     def clock2():
  145.         return resource.getrusage(resource.RUSAGE_SELF)[:2]
  146.  
  147. except ImportError:
  148.     clocku = clocks = clock = time.clock
  149.     
  150.     def clock2():
  151.         return (time.clock(), 0)
  152.  
  153.  
  154.  
  155. def timings_out(reps, func, *args, **kw):
  156.     reps = int(reps)
  157.     if reps == 1:
  158.         start = clock()
  159.         out = func(*args, **kw)
  160.         tot_time = clock() - start
  161.     else:
  162.         rng = xrange(reps - 1)
  163.         start = clock()
  164.         for dummy in rng:
  165.             func(*args, **kw)
  166.         
  167.         out = func(*args, **kw)
  168.         tot_time = clock() - start
  169.     av_time = tot_time / reps
  170.     return (tot_time, av_time, out)
  171.  
  172.  
  173. def timings(reps, func, *args, **kw):
  174.     return timings_out(reps, func, *args, **kw)[0:2]
  175.  
  176.  
  177. def timing(func, *args, **kw):
  178.     return timings_out(1, func, *args, **kw)[0]
  179.  
  180.  
  181. def arg_split(s, posix = False):
  182.     lex = shlex.shlex(s, posix = posix)
  183.     lex.whitespace_split = True
  184.     return list(lex)
  185.  
  186.  
  187. def system(cmd, verbose = 0, debug = 0, header = ''):
  188.     stat = 0
  189.     if verbose or debug:
  190.         print header + cmd
  191.     
  192.     sys.stdout.flush()
  193.     if not debug:
  194.         stat = os.system(cmd)
  195.     
  196.     return stat
  197.  
  198.  
  199. def abbrev_cwd():
  200.     cwd = os.getcwd().replace('\\', '/')
  201.     drivepart = ''
  202.     tail = cwd
  203.     if sys.platform == 'win32':
  204.         if len(cwd) < 4:
  205.             return cwd
  206.         (drivepart, tail) = os.path.splitdrive(cwd)
  207.     
  208.     parts = tail.split('/')
  209.     if len(parts) > 2:
  210.         tail = '/'.join(parts[-2:])
  211.     
  212.     if not cwd == '/' or '/':
  213.         pass
  214.     return drivepart + tail
  215.  
  216.  
  217. def shell(cmd, verbose = 0, debug = 0, header = ''):
  218.     stat = 0
  219.     if verbose or debug:
  220.         print header + cmd
  221.     
  222.     sys.stdout.flush()
  223.     if not debug:
  224.         platutils.set_term_title('IPy ' + cmd)
  225.         os.system(cmd)
  226.         platutils.set_term_title('IPy ' + abbrev_cwd())
  227.     
  228.  
  229. if os.name in ('nt', 'dos'):
  230.     shell_ori = shell
  231.     
  232.     def shell(cmd, verbose = 0, debug = 0, header = ''):
  233.         if os.getcwd().startswith('\\\\'):
  234.             path = os.getcwd()
  235.             os.chdir('c:')
  236.             
  237.             try:
  238.                 shell_ori('"pushd %s&&"' % path + cmd, verbose, debug, header)
  239.             finally:
  240.                 os.chdir(path)
  241.  
  242.         else:
  243.             shell_ori(cmd, verbose, debug, header)
  244.  
  245.     shell.__doc__ = shell_ori.__doc__
  246.  
  247.  
  248. def getoutput(cmd, verbose = 0, debug = 0, header = '', split = 0):
  249.     if verbose or debug:
  250.         print header + cmd
  251.     
  252.     if not debug:
  253.         output = os.popen(cmd).read()
  254.         if output.endswith('\n'):
  255.             output = output[:-1]
  256.         
  257.         if split:
  258.             return output.split('\n')
  259.         return output
  260.     debug
  261.  
  262.  
  263. def getoutputerror(cmd, verbose = 0, debug = 0, header = '', split = 0):
  264.     if verbose or debug:
  265.         print header + cmd
  266.     
  267.     if not cmd:
  268.         if split:
  269.             return ([], [])
  270.         return ('', '')
  271.     cmd
  272.     if not debug:
  273.         (pin, pout, perr) = os.popen3(cmd)
  274.         tout = pout.read().rstrip()
  275.         terr = perr.read().rstrip()
  276.         pin.close()
  277.         pout.close()
  278.         perr.close()
  279.         if split:
  280.             return (tout.split('\n'), terr.split('\n'))
  281.         return (tout, terr)
  282.     debug
  283.  
  284. xsys = system
  285. bq = getoutput
  286.  
  287. class SystemExec:
  288.     
  289.     def __init__(self, verbose = 0, debug = 0, header = '', split = 0):
  290.         setattr_list(self, 'verbose debug header split')
  291.  
  292.     
  293.     def system(self, cmd):
  294.         system(cmd, self.verbose, self.debug, self.header)
  295.  
  296.     
  297.     def shell(self, cmd):
  298.         shell(cmd, self.verbose, self.debug, self.header)
  299.  
  300.     xsys = system
  301.     
  302.     def getoutput(self, cmd):
  303.         return getoutput(cmd, self.verbose, self.debug, self.header, self.split)
  304.  
  305.     
  306.     def getoutputerror(self, cmd):
  307.         return getoutputerror(cmd, self.verbose, self.debug, self.header, self.split)
  308.  
  309.     bq = getoutput
  310.  
  311.  
  312. def mutex_opts(dict, ex_op):
  313.     for op1, op2 in ex_op:
  314.         if op1 in dict and op2 in dict:
  315.             raise ValueError, '\n*** ERROR in Arguments *** Options ' + op1 + ' and ' + op2 + ' are mutually exclusive.'
  316.         op2 in dict
  317.     
  318.  
  319.  
  320. def get_py_filename(name):
  321.     name = os.path.expanduser(name)
  322.     if not os.path.isfile(name) and not name.endswith('.py'):
  323.         name += '.py'
  324.     
  325.     if os.path.isfile(name):
  326.         return name
  327.     raise IOError, 'File `%s` not found.' % name
  328.  
  329.  
  330. def filefind(fname, alt_dirs = None):
  331.     if alt_dirs is None:
  332.         
  333.         try:
  334.             alt_dirs = get_home_dir()
  335.         except HomeDirError:
  336.             alt_dirs = os.getcwd()
  337.         except:
  338.             None<EXCEPTION MATCH>HomeDirError
  339.         
  340.  
  341.     None<EXCEPTION MATCH>HomeDirError
  342.     search = [
  343.         fname] + list_strings(alt_dirs)
  344.     search = map(os.path.expanduser, search)
  345.     fname = search[0]
  346.     if os.path.isfile(fname):
  347.         return fname
  348.     for direc in search[1:]:
  349.         testname = os.path.join(direc, fname)
  350.         if os.path.isfile(testname):
  351.             return testname
  352.     
  353.     raise IOError, 'File' + `fname` + ' not found in current or supplied directories:' + `alt_dirs`
  354.  
  355.  
  356. def file_read(filename):
  357.     fobj = open(filename, 'r')
  358.     source = fobj.read()
  359.     fobj.close()
  360.     return source
  361.  
  362.  
  363. def file_readlines(filename):
  364.     fobj = open(filename, 'r')
  365.     lines = fobj.readlines()
  366.     fobj.close()
  367.     return lines
  368.  
  369.  
  370. def target_outdated(target, deps):
  371.     
  372.     try:
  373.         target_time = os.path.getmtime(target)
  374.     except os.error:
  375.         return 1
  376.  
  377.     for dep in deps:
  378.         dep_time = os.path.getmtime(dep)
  379.         if dep_time > target_time:
  380.             return 1
  381.     
  382.     return 0
  383.  
  384.  
  385. def target_update(target, deps, cmd):
  386.     if target_outdated(target, deps):
  387.         xsys(cmd)
  388.     
  389.  
  390.  
  391. def unquote_ends(istr):
  392.     if not istr:
  393.         return istr
  394.     if (istr[0] == "'" or istr[-1] == "'" or istr[0] == '"') and istr[-1] == '"':
  395.         return istr[1:-1]
  396.     return istr
  397.  
  398.  
  399. def process_cmdline(argv, names = [], defaults = { }, usage = ''):
  400.     getopt = DPyGetOpt.DPyGetOpt()
  401.     getopt.setIgnoreCase(0)
  402.     getopt.parseConfiguration(names)
  403.     
  404.     try:
  405.         getopt.processArguments(argv)
  406.     except DPyGetOpt.ArgumentError:
  407.         exc = None
  408.         print usage
  409.         warn('"%s"' % exc, level = 4)
  410.  
  411.     defaults.update(getopt.optionValues)
  412.     args = getopt.freeValues
  413.     return (defaults, args)
  414.  
  415.  
  416. def optstr2types(ostr):
  417.     typeconv = {
  418.         None: '',
  419.         int: '',
  420.         float: '' }
  421.     typemap = {
  422.         's': None,
  423.         'i': int,
  424.         'f': float }
  425.     opt_re = re.compile('([\\w]*)([^:=]*:?=?)([sif]?)')
  426.     for w in ostr.split():
  427.         (oname, alias, otype) = opt_re.match(w).groups()
  428.         if otype == '' or alias == '!':
  429.             otype = 'i'
  430.         
  431.         typeconv[typemap[otype]] += oname + ' '
  432.     
  433.     return typeconv
  434.  
  435.  
  436. def read_dict(filename, type_conv = None, **opt):
  437.     opt.setdefault('purge', 0)
  438.     opt.setdefault('fs', None)
  439.     opt.setdefault('strip', 0)
  440.     opt.setdefault('warn', 1)
  441.     opt.setdefault('no_empty', 0)
  442.     opt.setdefault('unique', '')
  443.     if type(opt['unique']) in StringTypes:
  444.         unique_keys = qw(opt['unique'])
  445.     elif type(opt['unique']) in (types.TupleType, types.ListType):
  446.         unique_keys = opt['unique']
  447.     else:
  448.         raise ValueError, 'Unique keys must be given as a string, List or Tuple'
  449.     dict = type(opt['unique']) in StringTypes
  450.     if '\n' in filename:
  451.         lines = filename.splitlines()
  452.         file = None
  453.     else:
  454.         file = open(filename, 'r')
  455.         lines = file.readlines()
  456.     for line in lines:
  457.         line = line.strip()
  458.         if len(line) and line[0] == '#':
  459.             continue
  460.         
  461.         if len(line) > 0:
  462.             lsplit = line.split(opt['fs'], 1)
  463.             
  464.             try:
  465.                 (key, val) = lsplit
  466.             except ValueError:
  467.                 key = lsplit[0]
  468.                 val = ''
  469.  
  470.             key = key.strip()
  471.             if opt['strip']:
  472.                 val = val.strip()
  473.             
  474.             if val == "''" or val == '""':
  475.                 val = ''
  476.             
  477.             if opt['no_empty']:
  478.                 if val == '' or val.isspace():
  479.                     continue
  480.                 
  481.             
  482.             try:
  483.                 if dict[key] and key in unique_keys:
  484.                     dict[key] = val
  485.                 elif type(dict[key]) is types.ListType:
  486.                     dict[key].append(val)
  487.                 else:
  488.                     dict[key] = [
  489.                         dict[key],
  490.                         val]
  491.             except KeyError:
  492.                 dict[key] = val
  493.             except:
  494.                 None<EXCEPTION MATCH>KeyError
  495.             
  496.  
  497.         None<EXCEPTION MATCH>KeyError
  498.     
  499.     if opt['purge']:
  500.         accepted_keys = qwflat(type_conv.values())
  501.         for key in dict.keys():
  502.             if key in accepted_keys:
  503.                 continue
  504.             
  505.             del dict[key]
  506.         
  507.     
  508.     if type_conv == None:
  509.         return dict
  510.     conversions = type_conv.keys()
  511.     
  512.     try:
  513.         conversions.remove(None)
  514.     except:
  515.         type_conv == None
  516.  
  517.     for convert in conversions:
  518.         for val in qw(type_conv[convert]):
  519.             
  520.             try:
  521.                 dict[val] = convert(dict[val])
  522.             continue
  523.             except KeyError:
  524.                 type_conv == None
  525.                 e = type_conv == None
  526.                 if opt['warn'] == 0:
  527.                     pass
  528.                 elif opt['warn'] == 1:
  529.                     print >>sys.stderr, 'Warning: key', val, 'not found in file', filename
  530.                 elif opt['warn'] == 2:
  531.                     raise KeyError, e
  532.                 else:
  533.                     raise ValueError, 'Warning level must be 0,1 or 2'
  534.                 opt['warn'] == 0
  535.             
  536.  
  537.         
  538.     
  539.     return dict
  540.  
  541.  
  542. def flag_calls(func):
  543.     
  544.     def wrapper(*args, **kw):
  545.         wrapper.called = False
  546.         out = func(*args, **kw)
  547.         wrapper.called = True
  548.         return out
  549.  
  550.     wrapper.called = False
  551.     wrapper.__doc__ = func.__doc__
  552.     return wrapper
  553.  
  554.  
  555. def dhook_wrap(func, *a, **k):
  556.     
  557.     def f(*a, **k):
  558.         dhook_s = sys.displayhook
  559.         sys.displayhook = sys.__displayhook__
  560.         
  561.         try:
  562.             out = func(*a, **k)
  563.         finally:
  564.             sys.displayhook = dhook_s
  565.  
  566.         return out
  567.  
  568.     f.__doc__ = func.__doc__
  569.     return f
  570.  
  571.  
  572. def doctest_reload():
  573.     import doctest
  574.     doctest.master = None
  575.     doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run)
  576.  
  577.  
  578. class HomeDirError(Error):
  579.     pass
  580.  
  581.  
  582. def get_home_dir():
  583.     isdir = os.path.isdir
  584.     env = os.environ
  585.     if hasattr(sys, 'frozen'):
  586.         if '\\library.zip\\' in IPython.__file__.lower():
  587.             (root, rest) = IPython.__file__.lower().split('library.zip')
  588.         else:
  589.             root = os.path.join(os.path.split(IPython.__file__)[0], '../../')
  590.         root = os.path.abspath(root).rstrip('\\')
  591.         if isdir(os.path.join(root, '_ipython')):
  592.             os.environ['IPYKITROOT'] = root
  593.         
  594.         return root
  595.     
  596.     try:
  597.         homedir = env['HOME']
  598.         if not isdir(homedir):
  599.             raise KeyError
  600.         isdir(homedir)
  601.         return homedir
  602.     except KeyError:
  603.         hasattr(sys, 'frozen')
  604.         hasattr(sys, 'frozen')
  605.         if os.name == 'posix':
  606.             raise HomeDirError, 'undefined $HOME, IPython can not proceed.'
  607.         os.name == 'posix'
  608.         if os.name == 'nt':
  609.             
  610.             try:
  611.                 homedir = os.path.join(env['HOMEDRIVE'], env['HOMEPATH'])
  612.                 if not isdir(homedir):
  613.                     homedir = os.path.join(env['USERPROFILE'])
  614.                     if not isdir(homedir):
  615.                         raise HomeDirError
  616.                     isdir(homedir)
  617.                 
  618.                 return homedir
  619.             except KeyError:
  620.                 
  621.                 try:
  622.                     import _winreg as wreg
  623.                     key = wreg.OpenKey(wreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders')
  624.                     homedir = wreg.QueryValueEx(key, 'Personal')[0]
  625.                     key.Close()
  626.                     if not isdir(homedir):
  627.                         e = 'Invalid "Personal" folder registry key typically "My Documents".\nValue: %s\nThis is not a valid directory on your system.' % homedir
  628.                         raise HomeDirError(e)
  629.                     isdir(homedir)
  630.                     return homedir
  631.                 except HomeDirError:
  632.                     raise 
  633.                 except:
  634.                     None<EXCEPTION MATCH>HomeDirError
  635.                     return 'C:\\'
  636.                 
  637.  
  638.                 None<EXCEPTION MATCH>HomeDirError
  639.             
  640.  
  641.         None<EXCEPTION MATCH>KeyError
  642.         if os.name == 'dos':
  643.             return 'C:\\'
  644.         raise HomeDirError, 'support for your operating system not implemented.'
  645.     except:
  646.         os.name == 'dos'
  647.  
  648.  
  649.  
  650. def get_ipython_dir():
  651.     if os.name == 'posix':
  652.         ipdir_def = '.ipython'
  653.     else:
  654.         ipdir_def = '_ipython'
  655.     home_dir = get_home_dir()
  656.     ipdir = os.path.abspath(os.environ.get('IPYTHONDIR', os.path.join(home_dir, ipdir_def)))
  657.     return ipdir.decode(sys.getfilesystemencoding())
  658.  
  659.  
  660. def get_security_dir():
  661.     security_dir = os.path.join(get_ipython_dir(), 'security')
  662.     if not os.path.isdir(security_dir):
  663.         os.mkdir(security_dir, 448)
  664.     else:
  665.         os.chmod(security_dir, 448)
  666.     return security_dir
  667.  
  668.  
  669. def get_log_dir():
  670.     log_dir = os.path.join(get_ipython_dir(), 'log')
  671.     if not os.path.isdir(log_dir):
  672.         os.mkdir(log_dir, 511)
  673.     
  674.     return log_dir
  675.  
  676.  
  677. class LSString(str):
  678.     
  679.     def get_list(self):
  680.         
  681.         try:
  682.             return self._LSString__list
  683.         except AttributeError:
  684.             self._LSString__list = self.split('\n')
  685.             return self._LSString__list
  686.  
  687.  
  688.     l = list = property(get_list)
  689.     
  690.     def get_spstr(self):
  691.         
  692.         try:
  693.             return self._LSString__spstr
  694.         except AttributeError:
  695.             self._LSString__spstr = self.replace('\n', ' ')
  696.             return self._LSString__spstr
  697.  
  698.  
  699.     s = spstr = property(get_spstr)
  700.     
  701.     def get_nlstr(self):
  702.         return self
  703.  
  704.     n = nlstr = property(get_nlstr)
  705.     
  706.     def get_paths(self):
  707.         
  708.         try:
  709.             return self._LSString__paths
  710.         except AttributeError:
  711.             self._LSString__paths = _[1]
  712.             return self._LSString__paths
  713.             []
  714.  
  715.  
  716.     p = paths = property(get_paths)
  717.  
  718.  
  719. def print_lsstring(arg):
  720.     print 'LSString (.p, .n, .l, .s available). Value:'
  721.     print arg
  722.  
  723. print_lsstring = result_display.when_type(LSString)(print_lsstring)
  724.  
  725. class SList(list):
  726.     
  727.     def get_list(self):
  728.         return self
  729.  
  730.     l = list = property(get_list)
  731.     
  732.     def get_spstr(self):
  733.         
  734.         try:
  735.             return self._SList__spstr
  736.         except AttributeError:
  737.             self._SList__spstr = ' '.join(self)
  738.             return self._SList__spstr
  739.  
  740.  
  741.     s = spstr = property(get_spstr)
  742.     
  743.     def get_nlstr(self):
  744.         
  745.         try:
  746.             return self._SList__nlstr
  747.         except AttributeError:
  748.             self._SList__nlstr = '\n'.join(self)
  749.             return self._SList__nlstr
  750.  
  751.  
  752.     n = nlstr = property(get_nlstr)
  753.     
  754.     def get_paths(self):
  755.         
  756.         try:
  757.             return self._SList__paths
  758.         except AttributeError:
  759.             self._SList__paths = _[1]
  760.             return self._SList__paths
  761.             []
  762.  
  763.  
  764.     p = paths = property(get_paths)
  765.     
  766.     def grep(self, pattern, prune = False, field = None):
  767.         
  768.         def match_target(s):
  769.             if field is None:
  770.                 return s
  771.             parts = s.split()
  772.             
  773.             try:
  774.                 tgt = parts[field]
  775.                 return tgt
  776.             except IndexError:
  777.                 field is None
  778.                 field is None
  779.                 return ''
  780.  
  781.  
  782.         if isinstance(pattern, basestring):
  783.             
  784.             pred = lambda x: re.search(pattern, x, re.IGNORECASE)
  785.         else:
  786.             pred = pattern
  787.         if not prune:
  788.             return [](_[1])
  789.         return [](_[2])
  790.  
  791.     
  792.     def fields(self, *fields):
  793.         if len(fields) == 0:
  794.             return [ el.split() for el in self ]
  795.         res = SList()
  796.         for f in self:
  797.             pass
  798.         
  799.         return res
  800.  
  801.     
  802.     def sort(self, field = None, nums = False):
  803.         dsu.sort()
  804.         return []([ t[1] for t in dsu ])
  805.  
  806.  
  807.  
  808. def print_slist(arg):
  809.     print 'SList (.p, .n, .l, .s, .grep(), .fields(), sort() available):'
  810.     if hasattr(arg, 'hideonce') and arg.hideonce:
  811.         arg.hideonce = False
  812.         return None
  813.     nlprint(arg)
  814.  
  815. print_slist = result_display.when_type(SList)(print_slist)
  816.  
  817. def esc_quotes(strng):
  818.     return strng.replace('"', '\\"').replace("'", "\\'")
  819.  
  820.  
  821. def make_quoted_expr(s):
  822.     tail = ''
  823.     tailpadding = ''
  824.     raw = ''
  825.     if '\\' in s:
  826.         raw = 'r'
  827.         if s.endswith('\\'):
  828.             tail = '[:-1]'
  829.             tailpadding = '_'
  830.         
  831.     
  832.     if '"' not in s:
  833.         quote = '"'
  834.     elif "'" not in s:
  835.         quote = "'"
  836.     elif '"""' not in s and not s.endswith('"'):
  837.         quote = '"""'
  838.     elif "'''" not in s and not s.endswith("'"):
  839.         quote = "'''"
  840.     else:
  841.         return '"%s"' % esc_quotes(s)
  842.     res = (not s.endswith("'")) + quote + s + tailpadding + quote + tail
  843.     return res
  844.  
  845.  
  846. def raw_input_multi(header = '', ps1 = '==> ', ps2 = '..> ', terminate_str = '.'):
  847.     
  848.     try:
  849.         if header:
  850.             header += '\n'
  851.         
  852.         lines = [
  853.             raw_input(header + ps1)]
  854.     except EOFError:
  855.         return []
  856.  
  857.     terminate = [
  858.         terminate_str]
  859.     
  860.     try:
  861.         while lines[-1:] != terminate:
  862.             new_line = raw_input(ps1)
  863.             while new_line.endswith('\\'):
  864.                 new_line = new_line[:-1] + raw_input(ps2)
  865.             lines.append(new_line)
  866.         return lines[:-1]
  867.     except EOFError:
  868.         print 
  869.         return lines
  870.  
  871.  
  872.  
  873. def raw_input_ext(prompt = '', ps2 = '... '):
  874.     line = raw_input(prompt)
  875.     while line.endswith('\\'):
  876.         line = line[:-1] + raw_input(ps2)
  877.     return line
  878.  
  879.  
  880. def ask_yes_no(prompt, default = None):
  881.     answers = {
  882.         'y': True,
  883.         'n': False,
  884.         'yes': True,
  885.         'no': False }
  886.     ans = None
  887.     while ans not in answers.keys():
  888.         
  889.         try:
  890.             ans = raw_input(prompt + ' ').lower()
  891.             if not ans:
  892.                 ans = default
  893.         continue
  894.         except KeyboardInterrupt:
  895.             continue
  896.             except EOFError:
  897.                 if default in answers.keys():
  898.                     ans = default
  899.                     print 
  900.                 else:
  901.                     raise 
  902.                 default in answers.keys()
  903.             
  904.             None<EXCEPTION MATCH>EOFError
  905.         return answers[ans]
  906.  
  907.  
  908.  
  909. def marquee(txt = '', width = 78, mark = '*'):
  910.     if not txt:
  911.         return mark * width[:width]
  912.     nmark = (width - len(txt) - 2) / len(mark) / 2
  913.     if nmark < 0:
  914.         nmark = 0
  915.     
  916.     marks = mark * nmark
  917.     return '%s %s %s' % (marks, txt, marks)
  918.  
  919.  
  920. class EvalDict:
  921.     
  922.     def __getitem__(self, name):
  923.         frame = sys._getframe(1)
  924.         return eval(name, frame.f_globals, frame.f_locals)
  925.  
  926.  
  927. EvalString = EvalDict
  928.  
  929. def qw(words, flat = 0, sep = None, maxsplit = -1):
  930.     if type(words) in StringTypes:
  931.         return _[1]
  932.     if flat:
  933.         return flatten(map(qw, words, [
  934.             1] * len(words)))
  935.     return map(qw, words)
  936.  
  937.  
  938. def qwflat(words, sep = None, maxsplit = -1):
  939.     return qw(words, 1, sep, maxsplit)
  940.  
  941.  
  942. def qw_lol(indata):
  943.     if type(indata) in StringTypes:
  944.         return [
  945.             qw(indata)]
  946.     return qw(indata)
  947.  
  948.  
  949. def list_strings(arg):
  950.     if type(arg) in StringTypes:
  951.         return [
  952.             arg]
  953.     return arg
  954.  
  955.  
  956. def grep(pat, list, case = 1):
  957.     out = []
  958.     if case:
  959.         for term in list:
  960.             if term.find(pat) > -1:
  961.                 out.append(term)
  962.                 continue
  963.         
  964.     else:
  965.         lpat = pat.lower()
  966.         for term in list:
  967.             if term.lower().find(lpat) > -1:
  968.                 out.append(term)
  969.                 continue
  970.         
  971.     if len(out):
  972.         return out
  973.     return None
  974.  
  975.  
  976. def dgrep(pat, *opts):
  977.     return grep(pat, dir(__main__) + dir(__main__.__builtins__), *opts)
  978.  
  979.  
  980. def idgrep(pat):
  981.     return dgrep(pat, 0)
  982.  
  983.  
  984. def igrep(pat, list):
  985.     return grep(pat, list, case = 0)
  986.  
  987.  
  988. def indent(str, nspaces = 4, ntabs = 0):
  989.     if str is None:
  990.         return None
  991.     ind = '\t' * ntabs + ' ' * nspaces
  992.     outstr = '%s%s' % (ind, str.replace(os.linesep, os.linesep + ind))
  993.     if outstr.endswith(os.linesep + ind):
  994.         return outstr[:-len(ind)]
  995.     return outstr
  996.  
  997.  
  998. def native_line_ends(filename, backup = 1):
  999.     backup_suffixes = {
  1000.         'posix': '~',
  1001.         'dos': '.bak',
  1002.         'nt': '.bak',
  1003.         'mac': '.bak' }
  1004.     bak_filename = filename + backup_suffixes[os.name]
  1005.     original = open(filename).read()
  1006.     shutil.copy2(filename, bak_filename)
  1007.     
  1008.     try:
  1009.         new = open(filename, 'wb')
  1010.         new.write(os.linesep.join(original.splitlines()))
  1011.         new.write(os.linesep)
  1012.         new.close()
  1013.     except:
  1014.         os.rename(bak_filename, filename)
  1015.  
  1016.     if not backup:
  1017.         
  1018.         try:
  1019.             os.remove(bak_filename)
  1020.  
  1021.     
  1022.  
  1023.  
  1024. def get_pager_cmd(pager_cmd = None):
  1025.     if os.name == 'posix':
  1026.         default_pager_cmd = 'less -r'
  1027.     elif os.name in ('nt', 'dos'):
  1028.         default_pager_cmd = 'type'
  1029.     
  1030.     if pager_cmd is None:
  1031.         
  1032.         try:
  1033.             pager_cmd = os.environ['PAGER']
  1034.         pager_cmd = default_pager_cmd
  1035.  
  1036.     
  1037.     return pager_cmd
  1038.  
  1039.  
  1040. def get_pager_start(pager, start):
  1041.     if pager in ('less', 'more'):
  1042.         if start:
  1043.             start_string = '+' + str(start)
  1044.         else:
  1045.             start_string = ''
  1046.     else:
  1047.         start_string = ''
  1048.     return start_string
  1049.  
  1050. if os.name == 'nt' and os.environ.get('TERM', 'dumb') != 'emacs':
  1051.     import msvcrt
  1052.     
  1053.     def page_more():
  1054.         Term.cout.write('---Return to continue, q to quit--- ')
  1055.         ans = msvcrt.getch()
  1056.         if ans in ('q', 'Q'):
  1057.             result = False
  1058.         else:
  1059.             result = True
  1060.         Term.cout.write('\x08' * 37 + ' ' * 37 + '\x08' * 37)
  1061.         return result
  1062.  
  1063. else:
  1064.     
  1065.     def page_more():
  1066.         ans = raw_input('---Return to continue, q to quit--- ')
  1067.         if ans.lower().startswith('q'):
  1068.             return False
  1069.         return True
  1070.  
  1071. esc_re = re.compile('(\\x1b[^m]+m)')
  1072.  
  1073. def page_dumb(strng, start = 0, screen_lines = 25):
  1074.     out_ln = strng.splitlines()[start:]
  1075.     screens = chop(out_ln, screen_lines - 1)
  1076.     if len(screens) == 1:
  1077.         print >>Term.cout, os.linesep.join(screens[0])
  1078.     else:
  1079.         last_escape = ''
  1080.         for scr in screens[0:-1]:
  1081.             hunk = os.linesep.join(scr)
  1082.             print >>Term.cout, last_escape + hunk
  1083.             if not page_more():
  1084.                 return None
  1085.             esc_list = esc_re.findall(hunk)
  1086.             if len(esc_list) > 0:
  1087.                 last_escape = esc_list[-1]
  1088.                 continue
  1089.             page_more()
  1090.         
  1091.         print >>Term.cout, last_escape + os.linesep.join(screens[-1])
  1092.  
  1093.  
  1094. def page(strng, start = 0, screen_lines = 0, pager_cmd = None):
  1095.     start = max(0, start)
  1096.     ip = IPython.ipapi.get()
  1097.     if ip:
  1098.         
  1099.         try:
  1100.             ip.IP.hooks.show_in_pager(strng)
  1101.             return None
  1102.         except IPython.ipapi.TryNext:
  1103.             pass
  1104.         except:
  1105.             None<EXCEPTION MATCH>IPython.ipapi.TryNext
  1106.         
  1107.  
  1108.     None<EXCEPTION MATCH>IPython.ipapi.TryNext
  1109.     TERM = os.environ.get('TERM', 'dumb')
  1110.     if TERM in ('dumb', 'emacs') and os.name != 'nt':
  1111.         print strng
  1112.         return None
  1113.     str_lines = strng.split(os.linesep)[start:]
  1114.     str_toprint = os.linesep.join(str_lines)
  1115.     num_newlines = len(str_lines)
  1116.     len_str = len(str_toprint)
  1117.     numlines = max(num_newlines, int(len_str / 80) + 1)
  1118.     if os.name == 'nt':
  1119.         screen_lines_def = get_console_size(defaulty = 25)[1]
  1120.     else:
  1121.         screen_lines_def = 25
  1122.     if screen_lines <= 0:
  1123.         if TERM == 'xterm':
  1124.             use_curses = USE_CURSES
  1125.         else:
  1126.             use_curses = False
  1127.         if use_curses:
  1128.             term_flags = termios.tcgetattr(sys.stdout)
  1129.             scr = curses.initscr()
  1130.             (screen_lines_real, screen_cols) = scr.getmaxyx()
  1131.             curses.endwin()
  1132.             termios.tcsetattr(sys.stdout, termios.TCSANOW, term_flags)
  1133.             screen_lines += screen_lines_real
  1134.         else:
  1135.             screen_lines += screen_lines_def
  1136.     
  1137.     if numlines <= screen_lines:
  1138.         print >>Term.cout, str_toprint
  1139.     else:
  1140.         pager_cmd = get_pager_cmd(pager_cmd)
  1141.         pager_cmd += ' ' + get_pager_start(pager_cmd, start)
  1142.         if os.name == 'nt':
  1143.             if pager_cmd.startswith('type'):
  1144.                 retval = 1
  1145.             else:
  1146.                 tmpname = tempfile.mktemp('.txt')
  1147.                 tmpfile = file(tmpname, 'wt')
  1148.                 tmpfile.write(strng)
  1149.                 tmpfile.close()
  1150.                 cmd = '%s < %s' % (pager_cmd, tmpname)
  1151.                 if os.system(cmd):
  1152.                     retval = 1
  1153.                 else:
  1154.                     retval = None
  1155.                 os.remove(tmpname)
  1156.         else:
  1157.             
  1158.             try:
  1159.                 retval = None
  1160.                 pager = os.popen(pager_cmd, 'w')
  1161.                 pager.write(strng)
  1162.                 pager.close()
  1163.                 retval = pager.close()
  1164.             except IOError:
  1165.                 msg = None
  1166.                 if msg.args == (32, 'Broken pipe'):
  1167.                     retval = None
  1168.                 else:
  1169.                     retval = 1
  1170.             except OSError:
  1171.                 retval = 1
  1172.  
  1173.         if retval is not None:
  1174.             page_dumb(strng, screen_lines = screen_lines)
  1175.         
  1176.  
  1177.  
  1178. def page_file(fname, start = 0, pager_cmd = None):
  1179.     pager_cmd = get_pager_cmd(pager_cmd)
  1180.     pager_cmd += ' ' + get_pager_start(pager_cmd, start)
  1181.     
  1182.     try:
  1183.         if os.environ['TERM'] in ('emacs', 'dumb'):
  1184.             raise EnvironmentError
  1185.         os.environ['TERM'] in ('emacs', 'dumb')
  1186.         xsys(pager_cmd + ' ' + fname)
  1187.     except:
  1188.         
  1189.         try:
  1190.             if start > 0:
  1191.                 start -= 1
  1192.             
  1193.             page(open(fname).read(), start)
  1194.         print 'Unable to show file', `fname`
  1195.  
  1196.  
  1197.  
  1198.  
  1199. def snip_print(str, width = 75, print_full = 0, header = ''):
  1200.     if print_full == 1:
  1201.         page(header + str)
  1202.         return 0
  1203.     print header,
  1204.     if len(str) < width:
  1205.         print str
  1206.         snip = 0
  1207.     else:
  1208.         whalf = int((width - 5) / 2)
  1209.         print str[:whalf] + ' <...> ' + str[-whalf:]
  1210.         snip = 1
  1211.     if snip and print_full == 2:
  1212.         if raw_input(header + ' Snipped. View (y/n)? [N]').lower() == 'y':
  1213.             page(str)
  1214.         
  1215.     
  1216.     return snip
  1217.  
  1218.  
  1219. def belong(candidates, checklist):
  1220.     return [ x in checklist for x in candidates ]
  1221.  
  1222.  
  1223. def uniq_stable(elems):
  1224.     unique = []
  1225.     unique_dict = { }
  1226.     for nn in elems:
  1227.         if nn not in unique_dict:
  1228.             unique.append(nn)
  1229.             unique_dict[nn] = None
  1230.             continue
  1231.     
  1232.     return unique
  1233.  
  1234.  
  1235. class NLprinter:
  1236.     
  1237.     def __init__(self):
  1238.         self.depth = 0
  1239.  
  1240.     
  1241.     def __call__(self, lst, pos = '', **kw):
  1242.         kw.setdefault('indent', ' ')
  1243.         kw.setdefault('sep', ': ')
  1244.         kw.setdefault('start', 0)
  1245.         kw.setdefault('stop', len(lst))
  1246.         start = kw['start']
  1247.         del kw['start']
  1248.         stop = kw['stop']
  1249.         del kw['stop']
  1250.         if self.depth == 0 and 'header' in kw.keys():
  1251.             print kw['header']
  1252.         
  1253.         for idx in range(start, stop):
  1254.             elem = lst[idx]
  1255.             if type(elem) == type([]):
  1256.                 self.depth += 1
  1257.                 self.__call__(elem, itpl('$pos$idx,'), **kw)
  1258.                 self.depth -= 1
  1259.                 continue
  1260.             self
  1261.             printpl(kw['indent'] * self.depth + '$pos$idx$kw["sep"]$elem')
  1262.         
  1263.  
  1264.  
  1265. nlprint = NLprinter()
  1266.  
  1267. def all_belong(candidates, checklist):
  1268.     return [] - ([] in [ x in checklist for x in candidates ])
  1269.  
  1270.  
  1271. def sort_compare(lst1, lst2, inplace = 1):
  1272.     if not inplace:
  1273.         lst1 = lst1[:]
  1274.         lst2 = lst2[:]
  1275.     
  1276.     lst1.sort()
  1277.     lst2.sort()
  1278.     return lst1 == lst2
  1279.  
  1280.  
  1281. def list2dict(lst):
  1282.     dic = { }
  1283.     for k, v in lst:
  1284.         dic[k] = v
  1285.     
  1286.     return dic
  1287.  
  1288.  
  1289. def list2dict2(lst, default = ''):
  1290.     dic = { }
  1291.     for elem in lst:
  1292.         if type(elem) in (types.ListType, types.TupleType):
  1293.             size = len(elem)
  1294.             if size == 0:
  1295.                 pass
  1296.             elif size == 1:
  1297.                 dic[elem] = default
  1298.             else:
  1299.                 k = elem[0]
  1300.                 v = elem[1:]
  1301.                 if len(v) == 1:
  1302.                     v = v[0]
  1303.                 
  1304.                 dic[k] = v
  1305.         size == 0
  1306.         dic[elem] = default
  1307.     
  1308.     return dic
  1309.  
  1310.  
  1311. def flatten(seq):
  1312.     return [ x for subseq in seq for x in subseq ]
  1313.  
  1314.  
  1315. def get_slice(seq, start = 0, stop = None, step = 1):
  1316.     if stop == None:
  1317.         stop = len(seq)
  1318.     
  1319.     
  1320.     item = lambda i: seq[i]
  1321.     return map(item, xrange(start, stop, step))
  1322.  
  1323.  
  1324. def chop(seq, size):
  1325.     
  1326.     chunk = lambda i: seq[i:i + size]
  1327.     return map(chunk, xrange(0, len(seq), size))
  1328.  
  1329.  
  1330. def with_obj(object, **args):
  1331.     object.__dict__.update(args)
  1332.  
  1333.  
  1334. def setattr_list(obj, alist, nspace = None):
  1335.     if nspace is None:
  1336.         call_frame = sys._getframe().f_back
  1337.         nspace = call_frame.f_locals
  1338.     
  1339.     if type(alist) in StringTypes:
  1340.         alist = alist.split()
  1341.     
  1342.     for attr in alist:
  1343.         val = eval(attr, nspace)
  1344.         setattr(obj, attr, val)
  1345.     
  1346.  
  1347.  
  1348. def getattr_list(obj, alist, *args):
  1349.     if type(alist) in StringTypes:
  1350.         alist = alist.split()
  1351.     
  1352.     if args:
  1353.         if len(args) == 1:
  1354.             default = args[0]
  1355.             return (None, map)((lambda attr: getattr(obj, attr, default)), alist)
  1356.         raise ValueError, 'getattr_list() takes only one optional argument'
  1357.     args
  1358.     return (map,)((lambda attr: getattr(obj, attr)), alist)
  1359.  
  1360.  
  1361. def map_method(method, object_list, *argseq, **kw):
  1362.     out_list = []
  1363.     idx = 0
  1364.     for object in object_list:
  1365.         
  1366.         try:
  1367.             handler = getattr(object, method)
  1368.         except AttributeError:
  1369.             out_list.append(None)
  1370.  
  1371.         if argseq:
  1372.             args = (map,)((lambda lst: lst[idx]), argseq)
  1373.             out_list.append(handler(args, **kw))
  1374.         else:
  1375.             out_list.append(handler(**kw))
  1376.         idx += 1
  1377.     
  1378.     return out_list
  1379.  
  1380.  
  1381. def get_class_members(cls):
  1382.     ret = dir(cls)
  1383.     if hasattr(cls, '__bases__'):
  1384.         for base in cls.__bases__:
  1385.             ret.extend(get_class_members(base))
  1386.         
  1387.     
  1388.     return ret
  1389.  
  1390.  
  1391. def dir2(obj):
  1392.     words = dir(obj)
  1393.     if hasattr(obj, '__class__'):
  1394.         words.append('__class__')
  1395.         words.extend(get_class_members(obj.__class__))
  1396.     
  1397.     may_have_dupes = False
  1398.     if hasattr(obj, 'trait_names'):
  1399.         
  1400.         try:
  1401.             words.extend(obj.trait_names())
  1402.             may_have_dupes = True
  1403.         except TypeError:
  1404.             pass
  1405.         except:
  1406.             None<EXCEPTION MATCH>TypeError
  1407.         
  1408.  
  1409.     None<EXCEPTION MATCH>TypeError
  1410.     if hasattr(obj, '_getAttributeNames'):
  1411.         
  1412.         try:
  1413.             words.extend(obj._getAttributeNames())
  1414.             may_have_dupes = True
  1415.         except TypeError:
  1416.             pass
  1417.         except:
  1418.             None<EXCEPTION MATCH>TypeError
  1419.         
  1420.  
  1421.     None<EXCEPTION MATCH>TypeError
  1422.     if may_have_dupes:
  1423.         words = list(set(words))
  1424.         words.sort()
  1425.     
  1426.     return _[1]
  1427.  
  1428.  
  1429. def import_fail_info(mod_name, fns = None):
  1430.     if fns == None:
  1431.         warn('Loading of %s failed.\n' % (mod_name,))
  1432.     else:
  1433.         warn('Loading of %s from %s failed.\n' % (fns, mod_name))
  1434.  
  1435.  
  1436. class NotGiven:
  1437.     pass
  1438.  
  1439.  
  1440. def popkey(dct, key, default = NotGiven):
  1441.     
  1442.     try:
  1443.         val = dct[key]
  1444.     except KeyError:
  1445.         if default is NotGiven:
  1446.             raise 
  1447.         default is NotGiven
  1448.         return default
  1449.  
  1450.     del dct[key]
  1451.     return val
  1452.  
  1453.  
  1454. def wrap_deprecated(func, suggest = '<nothing>'):
  1455.     
  1456.     def newFunc(*args, **kwargs):
  1457.         warnings.warn('Call to deprecated function %s, use %s instead' % (func.__name__, suggest), category = DeprecationWarning, stacklevel = 2)
  1458.         return func(*args, **kwargs)
  1459.  
  1460.     return newFunc
  1461.  
  1462.  
  1463. def _num_cpus_unix():
  1464.     return os.sysconf('SC_NPROCESSORS_ONLN')
  1465.  
  1466.  
  1467. def _num_cpus_darwin():
  1468.     p = subprocess.Popen([
  1469.         'sysctl',
  1470.         '-n',
  1471.         'hw.ncpu'], stdout = subprocess.PIPE)
  1472.     return p.stdout.read()
  1473.  
  1474.  
  1475. def _num_cpus_windows():
  1476.     return os.environ.get('NUMBER_OF_PROCESSORS')
  1477.  
  1478.  
  1479. def num_cpus():
  1480.     ncpufuncs = {
  1481.         'Linux': _num_cpus_unix,
  1482.         'Darwin': _num_cpus_darwin,
  1483.         'Windows': _num_cpus_windows,
  1484.         'Microsoft': _num_cpus_windows }
  1485.     ncpufunc = ncpufuncs.get(platform.system(), _num_cpus_unix)
  1486.     
  1487.     try:
  1488.         ncpus = max(1, int(ncpufunc()))
  1489.     except:
  1490.         ncpus = 1
  1491.  
  1492.     return ncpus
  1493.  
  1494.