##// END OF EJS Templates
Apply Ville's patch, closes #87
fperez -
Show More
@@ -1,285 +1,363 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 Pdb debugger class.
4 4
5 5 Modified from the standard pdb.Pdb class to avoid including readline, so that
6 6 the command line completion of other programs which include this isn't
7 7 damaged.
8 8
9 9 In the future, this class will be expanded with improvements over the standard
10 10 pdb.
11 11
12 12 The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
13 13 changes. Licensing should therefore be under the standard Python terms. For
14 14 details on the PSF (Python Software Foundation) standard license, see:
15 15
16 16 http://www.python.org/2.2.3/license.html
17 17
18 $Id: Debugger.py 1324 2006-05-24 20:25:11Z fperez $"""
18 $Id: Debugger.py 1786 2006-09-27 05:47:28Z fperez $"""
19 19
20 20 #*****************************************************************************
21 21 #
22 22 # Since this file is essentially a modified copy of the pdb module which is
23 23 # part of the standard Python distribution, I assume that the proper procedure
24 24 # is to maintain its copyright as belonging to the Python Software Foundation
25 25 # (in addition to my own, for all new code).
26 26 #
27 27 # Copyright (C) 2001 Python Software Foundation, www.python.org
28 28 # Copyright (C) 2005-2006 Fernando Perez. <fperez@colorado.edu>
29 29 #
30 30 # Distributed under the terms of the BSD License. The full license is in
31 31 # the file COPYING, distributed as part of this software.
32 32 #
33 33 #*****************************************************************************
34 34
35 35 from IPython import Release
36 36 __author__ = '%s <%s>' % Release.authors['Fernando']
37 37 __license__ = 'Python'
38 38
39 39 import bdb
40 40 import cmd
41 41 import linecache
42 42 import os
43 43 import pdb
44 44 import sys
45 45
46 46 from IPython import PyColorize, ColorANSI
47 47 from IPython.genutils import Term
48 48 from IPython.excolors import ExceptionColors
49 49
50 50 def _file_lines(fname):
51 51 """Return the contents of a named file as a list of lines.
52 52
53 53 This function never raises an IOError exception: if the file can't be
54 54 read, it simply returns an empty list."""
55 55
56 56 try:
57 57 outfile = open(fname)
58 58 except IOError:
59 59 return []
60 60 else:
61 61 out = outfile.readlines()
62 62 outfile.close()
63 63 return out
64 64
65 65 class Pdb(pdb.Pdb):
66 66 """Modified Pdb class, does not load readline."""
67 67
68 68 # Ugly hack: we can't call the parent constructor, because it binds
69 69 # readline and breaks tab-completion. This means we have to COPY the
70 70 # constructor here, and that requires tracking various python versions.
71 71
72 if sys.version[:3] == '2.5':
73 def __init__(self,color_scheme='NoColor',completekey=None,
74 stdin=None, stdout=None):
75 bdb.Bdb.__init__(self)
76
77 # IPython change
78 # don't load readline
79 cmd.Cmd.__init__(self,completekey,stdin,stdout)
80 #cmd.Cmd.__init__(self, completekey, stdin, stdout)
81 # /IPython change
82
83 if stdout:
84 self.use_rawinput = 0
85 self.prompt = '(Pdb) '
86 self.aliases = {}
87 self.mainpyfile = ''
88 self._wait_for_mainpyfile = 0
89 # Try to load readline if it exists
90 try:
91 import readline
92 except ImportError:
93 pass
94
95 # Read $HOME/.pdbrc and ./.pdbrc
96 self.rcLines = []
97 if 'HOME' in os.environ:
98 envHome = os.environ['HOME']
99 try:
100 rcFile = open(os.path.join(envHome, ".pdbrc"))
101 except IOError:
102 pass
103 else:
104 for line in rcFile.readlines():
105 self.rcLines.append(line)
106 rcFile.close()
107 try:
108 rcFile = open(".pdbrc")
109 except IOError:
110 pass
111 else:
112 for line in rcFile.readlines():
113 self.rcLines.append(line)
114 rcFile.close()
115
116 self.commands = {} # associates a command list to breakpoint numbers
117 self.commands_doprompt = {} # for each bp num, tells if the prompt must be disp. after execing the cmd list
118 self.commands_silent = {} # for each bp num, tells if the stack trace must be disp. after execing the cmd list
119 self.commands_defining = False # True while in the process of defining a command list
120 self.commands_bnum = None # The breakpoint number for which we are defining a list
121
122
123 # IPython changes...
124
125 self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
126 self.aliases = {}
127
128 # Create color table: we copy the default one from the traceback
129 # module and add a few attributes needed for debugging
130 self.color_scheme_table = ExceptionColors.copy()
131
132 # shorthands
133 C = ColorANSI.TermColors
134 cst = self.color_scheme_table
135
136 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
137 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
138
139 cst['Linux'].colors.breakpoint_enabled = C.LightRed
140 cst['Linux'].colors.breakpoint_disabled = C.Red
141
142 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
143 cst['LightBG'].colors.breakpoint_disabled = C.Red
144
145 self.set_colors(color_scheme)
146
147
148 else:
149
72 150 def __init__(self,color_scheme='NoColor'):
73 151 bdb.Bdb.__init__(self)
74 152 cmd.Cmd.__init__(self,completekey=None) # don't load readline
75 153 self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
76 154 self.aliases = {}
77 155
78 156 # These two lines are part of the py2.4 constructor, let's put them
79 157 # unconditionally here as they won't cause any problems in 2.3.
80 158 self.mainpyfile = ''
81 159 self._wait_for_mainpyfile = 0
82 160
83 161 # Read $HOME/.pdbrc and ./.pdbrc
84 162 try:
85 163 self.rcLines = _file_lines(os.path.join(os.environ['HOME'],
86 164 ".pdbrc"))
87 165 except KeyError:
88 166 self.rcLines = []
89 167 self.rcLines.extend(_file_lines(".pdbrc"))
90 168
91 169 # Create color table: we copy the default one from the traceback
92 170 # module and add a few attributes needed for debugging
93 171 self.color_scheme_table = ExceptionColors.copy()
94 172
95 173 # shorthands
96 174 C = ColorANSI.TermColors
97 175 cst = self.color_scheme_table
98 176
99 177 cst['NoColor'].colors.breakpoint_enabled = C.NoColor
100 178 cst['NoColor'].colors.breakpoint_disabled = C.NoColor
101 179
102 180 cst['Linux'].colors.breakpoint_enabled = C.LightRed
103 181 cst['Linux'].colors.breakpoint_disabled = C.Red
104 182
105 183 cst['LightBG'].colors.breakpoint_enabled = C.LightRed
106 184 cst['LightBG'].colors.breakpoint_disabled = C.Red
107 185
108 186 self.set_colors(color_scheme)
109 187
110 188 def set_colors(self, scheme):
111 189 """Shorthand access to the color table scheme selector method."""
112 190 self.color_scheme_table.set_active_scheme(scheme)
113 191
114 192 def interaction(self, frame, traceback):
115 193 __IPYTHON__.set_completer_frame(frame)
116 194 pdb.Pdb.interaction(self, frame, traceback)
117 195
118 196 def do_up(self, arg):
119 197 pdb.Pdb.do_up(self, arg)
120 198 __IPYTHON__.set_completer_frame(self.curframe)
121 199 do_u = do_up
122 200
123 201 def do_down(self, arg):
124 202 pdb.Pdb.do_down(self, arg)
125 203 __IPYTHON__.set_completer_frame(self.curframe)
126 204 do_d = do_down
127 205
128 206 def postloop(self):
129 207 __IPYTHON__.set_completer_frame(None)
130 208
131 209 def print_stack_trace(self):
132 210 try:
133 211 for frame_lineno in self.stack:
134 212 self.print_stack_entry(frame_lineno, context = 5)
135 213 except KeyboardInterrupt:
136 214 pass
137 215
138 216 def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
139 217 context = 3):
140 218 frame, lineno = frame_lineno
141 219 print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
142 220
143 221 def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
144 222 import linecache, repr
145 223
146 224 ret = []
147 225
148 226 Colors = self.color_scheme_table.active_colors
149 227 ColorsNormal = Colors.Normal
150 228 tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
151 229 tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
152 230 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
153 231 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
154 232 ColorsNormal)
155 233
156 234 frame, lineno = frame_lineno
157 235
158 236 return_value = ''
159 237 if '__return__' in frame.f_locals:
160 238 rv = frame.f_locals['__return__']
161 239 #return_value += '->'
162 240 return_value += repr.repr(rv) + '\n'
163 241 ret.append(return_value)
164 242
165 243 #s = filename + '(' + `lineno` + ')'
166 244 filename = self.canonic(frame.f_code.co_filename)
167 245 link = tpl_link % filename
168 246
169 247 if frame.f_code.co_name:
170 248 func = frame.f_code.co_name
171 249 else:
172 250 func = "<lambda>"
173 251
174 252 call = ''
175 253 if func != '?':
176 254 if '__args__' in frame.f_locals:
177 255 args = repr.repr(frame.f_locals['__args__'])
178 256 else:
179 257 args = '()'
180 258 call = tpl_call % (func, args)
181 259
182 260 # The level info should be generated in the same format pdb uses, to
183 261 # avoid breaking the pdbtrack functionality of python-mode in *emacs.
184 262 ret.append('> %s(%s)%s\n' % (link,lineno,call))
185 263
186 264 start = lineno - 1 - context//2
187 265 lines = linecache.getlines(filename)
188 266 start = max(start, 0)
189 267 start = min(start, len(lines) - context)
190 268 lines = lines[start : start + context]
191 269
192 270 for i,line in enumerate(lines):
193 271 show_arrow = (start + 1 + i == lineno)
194 272 ret.append(self.__format_line(tpl_line_em, filename,
195 273 start + 1 + i, line,
196 274 arrow = show_arrow) )
197 275
198 276 return ''.join(ret)
199 277
200 278 def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
201 279 bp_mark = ""
202 280 bp_mark_color = ""
203 281
204 282 bp = None
205 283 if lineno in self.get_file_breaks(filename):
206 284 bps = self.get_breaks(filename, lineno)
207 285 bp = bps[-1]
208 286
209 287 if bp:
210 288 Colors = self.color_scheme_table.active_colors
211 289 bp_mark = str(bp.number)
212 290 bp_mark_color = Colors.breakpoint_enabled
213 291 if not bp.enabled:
214 292 bp_mark_color = Colors.breakpoint_disabled
215 293
216 294 numbers_width = 7
217 295 if arrow:
218 296 # This is the line with the error
219 297 pad = numbers_width - len(str(lineno)) - len(bp_mark)
220 298 if pad >= 3:
221 299 marker = '-'*(pad-3) + '-> '
222 300 elif pad == 2:
223 301 marker = '> '
224 302 elif pad == 1:
225 303 marker = '>'
226 304 else:
227 305 marker = ''
228 306 num = '%s%s' % (marker, str(lineno))
229 307 line = tpl_line % (bp_mark_color + bp_mark, num, line)
230 308 else:
231 309 num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
232 310 line = tpl_line % (bp_mark_color + bp_mark, num, line)
233 311
234 312 return line
235 313
236 314 def do_list(self, arg):
237 315 self.lastcmd = 'list'
238 316 last = None
239 317 if arg:
240 318 try:
241 319 x = eval(arg, {}, {})
242 320 if type(x) == type(()):
243 321 first, last = x
244 322 first = int(first)
245 323 last = int(last)
246 324 if last < first:
247 325 # Assume it's a count
248 326 last = first + last
249 327 else:
250 328 first = max(1, int(x) - 5)
251 329 except:
252 330 print '*** Error in argument:', `arg`
253 331 return
254 332 elif self.lineno is None:
255 333 first = max(1, self.curframe.f_lineno - 5)
256 334 else:
257 335 first = self.lineno + 1
258 336 if last is None:
259 337 last = first + 10
260 338 filename = self.curframe.f_code.co_filename
261 339 try:
262 340 Colors = self.color_scheme_table.active_colors
263 341 ColorsNormal = Colors.Normal
264 342 tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
265 343 tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
266 344 src = []
267 345 for lineno in range(first, last+1):
268 346 line = linecache.getline(filename, lineno)
269 347 if not line:
270 348 break
271 349
272 350 if lineno == self.curframe.f_lineno:
273 351 line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
274 352 else:
275 353 line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
276 354
277 355 src.append(line)
278 356 self.lineno = lineno
279 357
280 358 print >>Term.cout, ''.join(src)
281 359
282 360 except KeyboardInterrupt:
283 361 pass
284 362
285 363 do_l = do_list
@@ -1,2342 +1,2356 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 IPython -- An enhanced Interactive Python
4 4
5 5 Requires Python 2.3 or newer.
6 6
7 7 This file contains all the classes and helper functions specific to IPython.
8 8
9 $Id: iplib.py 1785 2006-09-26 21:08:22Z vivainio $
9 $Id: iplib.py 1786 2006-09-27 05:47:28Z fperez $
10 10 """
11 11
12 12 #*****************************************************************************
13 13 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
14 14 # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
15 15 #
16 16 # Distributed under the terms of the BSD License. The full license is in
17 17 # the file COPYING, distributed as part of this software.
18 18 #
19 19 # Note: this code originally subclassed code.InteractiveConsole from the
20 20 # Python standard library. Over time, all of that class has been copied
21 21 # verbatim here for modifications which could not be accomplished by
22 22 # subclassing. At this point, there are no dependencies at all on the code
23 23 # module anymore (it is not even imported). The Python License (sec. 2)
24 24 # allows for this, but it's always nice to acknowledge credit where credit is
25 25 # due.
26 26 #*****************************************************************************
27 27
28 28 #****************************************************************************
29 29 # Modules and globals
30 30
31 31 from IPython import Release
32 32 __author__ = '%s <%s>\n%s <%s>' % \
33 33 ( Release.authors['Janko'] + Release.authors['Fernando'] )
34 34 __license__ = Release.license
35 35 __version__ = Release.version
36 36
37 37 # Python standard modules
38 38 import __main__
39 39 import __builtin__
40 40 import StringIO
41 41 import bdb
42 42 import cPickle as pickle
43 43 import codeop
44 44 import exceptions
45 45 import glob
46 46 import inspect
47 47 import keyword
48 48 import new
49 49 import os
50 50 import pdb
51 51 import pydoc
52 52 import re
53 53 import shutil
54 54 import string
55 55 import sys
56 56 import tempfile
57 57 import traceback
58 58 import types
59 59 import pickleshare
60 60
61 61 from pprint import pprint, pformat
62 62
63 63 # IPython's own modules
64 64 import IPython
65 65 from IPython import OInspect,PyColorize,ultraTB
66 66 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
67 67 from IPython.FakeModule import FakeModule
68 68 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
69 69 from IPython.Logger import Logger
70 70 from IPython.Magic import Magic
71 71 from IPython.Prompts import CachedOutput
72 72 from IPython.ipstruct import Struct
73 73 from IPython.background_jobs import BackgroundJobManager
74 74 from IPython.usage import cmd_line_usage,interactive_usage
75 75 from IPython.genutils import *
76 76 import IPython.ipapi
77 77
78 78 # Globals
79 79
80 80 # store the builtin raw_input globally, and use this always, in case user code
81 81 # overwrites it (like wx.py.PyShell does)
82 82 raw_input_original = raw_input
83 83
84 84 # compiled regexps for autoindent management
85 85 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
86 86
87 87
88 88 #****************************************************************************
89 89 # Some utility function definitions
90 90
91 91 ini_spaces_re = re.compile(r'^(\s+)')
92 92
93 93 def num_ini_spaces(strng):
94 94 """Return the number of initial spaces in a string"""
95 95
96 96 ini_spaces = ini_spaces_re.match(strng)
97 97 if ini_spaces:
98 98 return ini_spaces.end()
99 99 else:
100 100 return 0
101 101
102 102 def softspace(file, newvalue):
103 103 """Copied from code.py, to remove the dependency"""
104 104
105 105 oldvalue = 0
106 106 try:
107 107 oldvalue = file.softspace
108 108 except AttributeError:
109 109 pass
110 110 try:
111 111 file.softspace = newvalue
112 112 except (AttributeError, TypeError):
113 113 # "attribute-less object" or "read-only attributes"
114 114 pass
115 115 return oldvalue
116 116
117 117
118 118 #****************************************************************************
119 119 # Local use exceptions
120 120 class SpaceInInput(exceptions.Exception): pass
121 121
122 122
123 123 #****************************************************************************
124 124 # Local use classes
125 125 class Bunch: pass
126 126
127 127 class Undefined: pass
128 128
129 129 class InputList(list):
130 130 """Class to store user input.
131 131
132 132 It's basically a list, but slices return a string instead of a list, thus
133 133 allowing things like (assuming 'In' is an instance):
134 134
135 135 exec In[4:7]
136 136
137 137 or
138 138
139 139 exec In[5:9] + In[14] + In[21:25]"""
140 140
141 141 def __getslice__(self,i,j):
142 142 return ''.join(list.__getslice__(self,i,j))
143 143
144 144 class SyntaxTB(ultraTB.ListTB):
145 145 """Extension which holds some state: the last exception value"""
146 146
147 147 def __init__(self,color_scheme = 'NoColor'):
148 148 ultraTB.ListTB.__init__(self,color_scheme)
149 149 self.last_syntax_error = None
150 150
151 151 def __call__(self, etype, value, elist):
152 152 self.last_syntax_error = value
153 153 ultraTB.ListTB.__call__(self,etype,value,elist)
154 154
155 155 def clear_err_state(self):
156 156 """Return the current error state and clear it"""
157 157 e = self.last_syntax_error
158 158 self.last_syntax_error = None
159 159 return e
160 160
161 161 #****************************************************************************
162 162 # Main IPython class
163 163
164 164 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
165 165 # until a full rewrite is made. I've cleaned all cross-class uses of
166 166 # attributes and methods, but too much user code out there relies on the
167 167 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
168 168 #
169 169 # But at least now, all the pieces have been separated and we could, in
170 170 # principle, stop using the mixin. This will ease the transition to the
171 171 # chainsaw branch.
172 172
173 173 # For reference, the following is the list of 'self.foo' uses in the Magic
174 174 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
175 175 # class, to prevent clashes.
176 176
177 177 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
178 178 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
179 179 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
180 180 # 'self.value']
181 181
182 182 class InteractiveShell(object,Magic):
183 183 """An enhanced console for Python."""
184 184
185 185 # class attribute to indicate whether the class supports threads or not.
186 186 # Subclasses with thread support should override this as needed.
187 187 isthreaded = False
188 188
189 189 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
190 190 user_ns = None,user_global_ns=None,banner2='',
191 191 custom_exceptions=((),None),embedded=False):
192 192
193 193 # log system
194 194 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
195 195
196 196 # some minimal strict typechecks. For some core data structures, I
197 197 # want actual basic python types, not just anything that looks like
198 198 # one. This is especially true for namespaces.
199 199 for ns in (user_ns,user_global_ns):
200 200 if ns is not None and type(ns) != types.DictType:
201 201 raise TypeError,'namespace must be a dictionary'
202 202
203 203 # Job manager (for jobs run as background threads)
204 204 self.jobs = BackgroundJobManager()
205 205
206 206 # Store the actual shell's name
207 207 self.name = name
208 208
209 209 # We need to know whether the instance is meant for embedding, since
210 210 # global/local namespaces need to be handled differently in that case
211 211 self.embedded = embedded
212 212
213 213 # command compiler
214 214 self.compile = codeop.CommandCompiler()
215 215
216 216 # User input buffer
217 217 self.buffer = []
218 218
219 219 # Default name given in compilation of code
220 220 self.filename = '<ipython console>'
221 221
222 222 # Make an empty namespace, which extension writers can rely on both
223 223 # existing and NEVER being used by ipython itself. This gives them a
224 224 # convenient location for storing additional information and state
225 225 # their extensions may require, without fear of collisions with other
226 226 # ipython names that may develop later.
227 227 self.meta = Struct()
228 228
229 229 # Create the namespace where the user will operate. user_ns is
230 230 # normally the only one used, and it is passed to the exec calls as
231 231 # the locals argument. But we do carry a user_global_ns namespace
232 232 # given as the exec 'globals' argument, This is useful in embedding
233 233 # situations where the ipython shell opens in a context where the
234 234 # distinction between locals and globals is meaningful.
235 235
236 236 # FIXME. For some strange reason, __builtins__ is showing up at user
237 237 # level as a dict instead of a module. This is a manual fix, but I
238 238 # should really track down where the problem is coming from. Alex
239 239 # Schmolck reported this problem first.
240 240
241 241 # A useful post by Alex Martelli on this topic:
242 242 # Re: inconsistent value from __builtins__
243 243 # Von: Alex Martelli <aleaxit@yahoo.com>
244 244 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
245 245 # Gruppen: comp.lang.python
246 246
247 247 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
248 248 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
249 249 # > <type 'dict'>
250 250 # > >>> print type(__builtins__)
251 251 # > <type 'module'>
252 252 # > Is this difference in return value intentional?
253 253
254 254 # Well, it's documented that '__builtins__' can be either a dictionary
255 255 # or a module, and it's been that way for a long time. Whether it's
256 256 # intentional (or sensible), I don't know. In any case, the idea is
257 257 # that if you need to access the built-in namespace directly, you
258 258 # should start with "import __builtin__" (note, no 's') which will
259 259 # definitely give you a module. Yeah, it's somewhat confusing:-(.
260 260
261 261 # These routines return properly built dicts as needed by the rest of
262 262 # the code, and can also be used by extension writers to generate
263 263 # properly initialized namespaces.
264 264 user_ns = IPython.ipapi.make_user_ns(user_ns)
265 265 user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)
266 266
267 267 # Assign namespaces
268 268 # This is the namespace where all normal user variables live
269 269 self.user_ns = user_ns
270 270 # Embedded instances require a separate namespace for globals.
271 271 # Normally this one is unused by non-embedded instances.
272 272 self.user_global_ns = user_global_ns
273 273 # A namespace to keep track of internal data structures to prevent
274 274 # them from cluttering user-visible stuff. Will be updated later
275 275 self.internal_ns = {}
276 276
277 277 # Namespace of system aliases. Each entry in the alias
278 278 # table must be a 2-tuple of the form (N,name), where N is the number
279 279 # of positional arguments of the alias.
280 280 self.alias_table = {}
281 281
282 282 # A table holding all the namespaces IPython deals with, so that
283 283 # introspection facilities can search easily.
284 284 self.ns_table = {'user':user_ns,
285 285 'user_global':user_global_ns,
286 286 'alias':self.alias_table,
287 287 'internal':self.internal_ns,
288 288 'builtin':__builtin__.__dict__
289 289 }
290 290
291 291 # The user namespace MUST have a pointer to the shell itself.
292 292 self.user_ns[name] = self
293 293
294 294 # We need to insert into sys.modules something that looks like a
295 295 # module but which accesses the IPython namespace, for shelve and
296 296 # pickle to work interactively. Normally they rely on getting
297 297 # everything out of __main__, but for embedding purposes each IPython
298 298 # instance has its own private namespace, so we can't go shoving
299 299 # everything into __main__.
300 300
301 301 # note, however, that we should only do this for non-embedded
302 302 # ipythons, which really mimic the __main__.__dict__ with their own
303 303 # namespace. Embedded instances, on the other hand, should not do
304 304 # this because they need to manage the user local/global namespaces
305 305 # only, but they live within a 'normal' __main__ (meaning, they
306 306 # shouldn't overtake the execution environment of the script they're
307 307 # embedded in).
308 308
309 309 if not embedded:
310 310 try:
311 311 main_name = self.user_ns['__name__']
312 312 except KeyError:
313 313 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
314 314 else:
315 315 #print "pickle hack in place" # dbg
316 316 #print 'main_name:',main_name # dbg
317 317 sys.modules[main_name] = FakeModule(self.user_ns)
318 318
319 319 # List of input with multi-line handling.
320 320 # Fill its zero entry, user counter starts at 1
321 321 self.input_hist = InputList(['\n'])
322 322 # This one will hold the 'raw' input history, without any
323 323 # pre-processing. This will allow users to retrieve the input just as
324 324 # it was exactly typed in by the user, with %hist -r.
325 325 self.input_hist_raw = InputList(['\n'])
326 326
327 327 # list of visited directories
328 328 try:
329 329 self.dir_hist = [os.getcwd()]
330 330 except IOError, e:
331 331 self.dir_hist = []
332 332
333 333 # dict of output history
334 334 self.output_hist = {}
335 335
336 336 # dict of things NOT to alias (keywords, builtins and some magics)
337 337 no_alias = {}
338 338 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
339 339 for key in keyword.kwlist + no_alias_magics:
340 340 no_alias[key] = 1
341 341 no_alias.update(__builtin__.__dict__)
342 342 self.no_alias = no_alias
343 343
344 344 # make global variables for user access to these
345 345 self.user_ns['_ih'] = self.input_hist
346 346 self.user_ns['_oh'] = self.output_hist
347 347 self.user_ns['_dh'] = self.dir_hist
348 348
349 349 # user aliases to input and output histories
350 350 self.user_ns['In'] = self.input_hist
351 351 self.user_ns['Out'] = self.output_hist
352 352
353 353 # Object variable to store code object waiting execution. This is
354 354 # used mainly by the multithreaded shells, but it can come in handy in
355 355 # other situations. No need to use a Queue here, since it's a single
356 356 # item which gets cleared once run.
357 357 self.code_to_run = None
358 358
359 359 # escapes for automatic behavior on the command line
360 360 self.ESC_SHELL = '!'
361 361 self.ESC_HELP = '?'
362 362 self.ESC_MAGIC = '%'
363 363 self.ESC_QUOTE = ','
364 364 self.ESC_QUOTE2 = ';'
365 365 self.ESC_PAREN = '/'
366 366
367 367 # And their associated handlers
368 368 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
369 369 self.ESC_QUOTE : self.handle_auto,
370 370 self.ESC_QUOTE2 : self.handle_auto,
371 371 self.ESC_MAGIC : self.handle_magic,
372 372 self.ESC_HELP : self.handle_help,
373 373 self.ESC_SHELL : self.handle_shell_escape,
374 374 }
375 375
376 376 # class initializations
377 377 Magic.__init__(self,self)
378 378
379 379 # Python source parser/formatter for syntax highlighting
380 380 pyformat = PyColorize.Parser().format
381 381 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
382 382
383 383 # hooks holds pointers used for user-side customizations
384 384 self.hooks = Struct()
385 385
386 386 # Set all default hooks, defined in the IPython.hooks module.
387 387 hooks = IPython.hooks
388 388 for hook_name in hooks.__all__:
389 389 # default hooks have priority 100, i.e. low; user hooks should have 0-100 priority
390 390 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
391 391 #print "bound hook",hook_name
392 392
393 393 # Flag to mark unconditional exit
394 394 self.exit_now = False
395 395
396 396 self.usage_min = """\
397 397 An enhanced console for Python.
398 398 Some of its features are:
399 399 - Readline support if the readline library is present.
400 400 - Tab completion in the local namespace.
401 401 - Logging of input, see command-line options.
402 402 - System shell escape via ! , eg !ls.
403 403 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
404 404 - Keeps track of locally defined variables via %who, %whos.
405 405 - Show object information with a ? eg ?x or x? (use ?? for more info).
406 406 """
407 407 if usage: self.usage = usage
408 408 else: self.usage = self.usage_min
409 409
410 410 # Storage
411 411 self.rc = rc # This will hold all configuration information
412 412 self.pager = 'less'
413 413 # temporary files used for various purposes. Deleted at exit.
414 414 self.tempfiles = []
415 415
416 416 # Keep track of readline usage (later set by init_readline)
417 417 self.has_readline = False
418 418
419 419 # template for logfile headers. It gets resolved at runtime by the
420 420 # logstart method.
421 421 self.loghead_tpl = \
422 422 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
423 423 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
424 424 #log# opts = %s
425 425 #log# args = %s
426 426 #log# It is safe to make manual edits below here.
427 427 #log#-----------------------------------------------------------------------
428 428 """
429 429 # for pushd/popd management
430 430 try:
431 431 self.home_dir = get_home_dir()
432 432 except HomeDirError,msg:
433 433 fatal(msg)
434 434
435 435 self.dir_stack = [os.getcwd().replace(self.home_dir,'~')]
436 436
437 437 # Functions to call the underlying shell.
438 438
439 439 # utility to expand user variables via Itpl
440 440 self.var_expand = lambda cmd: str(ItplNS(cmd.replace('#','\#'),
441 441 self.user_ns))
442 442 # The first is similar to os.system, but it doesn't return a value,
443 443 # and it allows interpolation of variables in the user's namespace.
444 444 self.system = lambda cmd: shell(self.var_expand(cmd),
445 445 header='IPython system call: ',
446 446 verbose=self.rc.system_verbose)
447 447 # These are for getoutput and getoutputerror:
448 448 self.getoutput = lambda cmd: \
449 449 getoutput(self.var_expand(cmd),
450 450 header='IPython system call: ',
451 451 verbose=self.rc.system_verbose)
452 452 self.getoutputerror = lambda cmd: \
453 453 getoutputerror(self.var_expand(cmd),
454 454 header='IPython system call: ',
455 455 verbose=self.rc.system_verbose)
456 456
457 457 # RegExp for splitting line contents into pre-char//first
458 458 # word-method//rest. For clarity, each group in on one line.
459 459
460 460 # WARNING: update the regexp if the above escapes are changed, as they
461 461 # are hardwired in.
462 462
463 463 # Don't get carried away with trying to make the autocalling catch too
464 464 # much: it's better to be conservative rather than to trigger hidden
465 465 # evals() somewhere and end up causing side effects.
466 466
467 467 self.line_split = re.compile(r'^([\s*,;/])'
468 468 r'([\?\w\.]+\w*\s*)'
469 469 r'(\(?.*$)')
470 470
471 471 # Original re, keep around for a while in case changes break something
472 472 #self.line_split = re.compile(r'(^[\s*!\?%,/]?)'
473 473 # r'(\s*[\?\w\.]+\w*\s*)'
474 474 # r'(\(?.*$)')
475 475
476 476 # RegExp to identify potential function names
477 477 self.re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
478 478
479 479 # RegExp to exclude strings with this start from autocalling. In
480 480 # particular, all binary operators should be excluded, so that if foo
481 481 # is callable, foo OP bar doesn't become foo(OP bar), which is
482 482 # invalid. The characters '!=()' don't need to be checked for, as the
483 483 # _prefilter routine explicitely does so, to catch direct calls and
484 484 # rebindings of existing names.
485 485
486 486 # Warning: the '-' HAS TO BE AT THE END of the first group, otherwise
487 487 # it affects the rest of the group in square brackets.
488 488 self.re_exclude_auto = re.compile(r'^[<>,&^\|\*/\+-]'
489 489 '|^is |^not |^in |^and |^or ')
490 490
491 491 # try to catch also methods for stuff in lists/tuples/dicts: off
492 492 # (experimental). For this to work, the line_split regexp would need
493 493 # to be modified so it wouldn't break things at '['. That line is
494 494 # nasty enough that I shouldn't change it until I can test it _well_.
495 495 #self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
496 496
497 497 # keep track of where we started running (mainly for crash post-mortem)
498 498 self.starting_dir = os.getcwd()
499 499
500 500 # Various switches which can be set
501 501 self.CACHELENGTH = 5000 # this is cheap, it's just text
502 502 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
503 503 self.banner2 = banner2
504 504
505 505 # TraceBack handlers:
506 506
507 507 # Syntax error handler.
508 508 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
509 509
510 510 # The interactive one is initialized with an offset, meaning we always
511 511 # want to remove the topmost item in the traceback, which is our own
512 512 # internal code. Valid modes: ['Plain','Context','Verbose']
513 513 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
514 514 color_scheme='NoColor',
515 515 tb_offset = 1)
516 516
517 517 # IPython itself shouldn't crash. This will produce a detailed
518 518 # post-mortem if it does. But we only install the crash handler for
519 519 # non-threaded shells, the threaded ones use a normal verbose reporter
520 520 # and lose the crash handler. This is because exceptions in the main
521 521 # thread (such as in GUI code) propagate directly to sys.excepthook,
522 522 # and there's no point in printing crash dumps for every user exception.
523 523 if self.isthreaded:
524 524 sys.excepthook = ultraTB.FormattedTB()
525 525 else:
526 526 from IPython import CrashHandler
527 527 sys.excepthook = CrashHandler.CrashHandler(self)
528 528
529 529 # The instance will store a pointer to this, so that runtime code
530 530 # (such as magics) can access it. This is because during the
531 531 # read-eval loop, it gets temporarily overwritten (to deal with GUI
532 532 # frameworks).
533 533 self.sys_excepthook = sys.excepthook
534 534
535 535 # and add any custom exception handlers the user may have specified
536 536 self.set_custom_exc(*custom_exceptions)
537 537
538 538 # indentation management
539 539 self.autoindent = False
540 540 self.indent_current_nsp = 0
541 541
542 542 # Make some aliases automatically
543 543 # Prepare list of shell aliases to auto-define
544 544 if os.name == 'posix':
545 545 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
546 546 'mv mv -i','rm rm -i','cp cp -i',
547 547 'cat cat','less less','clear clear',
548 548 # a better ls
549 549 'ls ls -F',
550 550 # long ls
551 551 'll ls -lF')
552 552 # Extra ls aliases with color, which need special treatment on BSD
553 553 # variants
554 554 ls_extra = ( # color ls
555 555 'lc ls -F -o --color',
556 556 # ls normal files only
557 557 'lf ls -F -o --color %l | grep ^-',
558 558 # ls symbolic links
559 559 'lk ls -F -o --color %l | grep ^l',
560 560 # directories or links to directories,
561 561 'ldir ls -F -o --color %l | grep /$',
562 562 # things which are executable
563 563 'lx ls -F -o --color %l | grep ^-..x',
564 564 )
565 565 # The BSDs don't ship GNU ls, so they don't understand the
566 566 # --color switch out of the box
567 567 if 'bsd' in sys.platform:
568 568 ls_extra = ( # ls normal files only
569 569 'lf ls -lF | grep ^-',
570 570 # ls symbolic links
571 571 'lk ls -lF | grep ^l',
572 572 # directories or links to directories,
573 573 'ldir ls -lF | grep /$',
574 574 # things which are executable
575 575 'lx ls -lF | grep ^-..x',
576 576 )
577 577 auto_alias = auto_alias + ls_extra
578 578 elif os.name in ['nt','dos']:
579 579 auto_alias = ('dir dir /on', 'ls dir /on',
580 580 'ddir dir /ad /on', 'ldir dir /ad /on',
581 581 'mkdir mkdir','rmdir rmdir','echo echo',
582 582 'ren ren','cls cls','copy copy')
583 583 else:
584 584 auto_alias = ()
585 585 self.auto_alias = [s.split(None,1) for s in auto_alias]
586 586 # Call the actual (public) initializer
587 587 self.init_auto_alias()
588 588
589 589 # Produce a public API instance
590 590 self.api = IPython.ipapi.IPApi(self)
591 591
592 592 # track which builtins we add, so we can clean up later
593 593 self.builtins_added = {}
594 594 # This method will add the necessary builtins for operation, but
595 595 # tracking what it did via the builtins_added dict.
596 596 self.add_builtins()
597 597
598 598 # end __init__
599 599
600 600 def pre_config_initialization(self):
601 601 """Pre-configuration init method
602 602
603 603 This is called before the configuration files are processed to
604 604 prepare the services the config files might need.
605 605
606 606 self.rc already has reasonable default values at this point.
607 607 """
608 608 rc = self.rc
609 609
610 610 self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
611 611
612 612 def post_config_initialization(self):
613 613 """Post configuration init method
614 614
615 615 This is called after the configuration files have been processed to
616 616 'finalize' the initialization."""
617 617
618 618 rc = self.rc
619 619
620 620 # Object inspector
621 621 self.inspector = OInspect.Inspector(OInspect.InspectColors,
622 622 PyColorize.ANSICodeColors,
623 623 'NoColor',
624 624 rc.object_info_string_level)
625 625
626 626 # Load readline proper
627 627 if rc.readline:
628 628 self.init_readline()
629 629
630 630 # local shortcut, this is used a LOT
631 631 self.log = self.logger.log
632 632
633 633 # Initialize cache, set in/out prompts and printing system
634 634 self.outputcache = CachedOutput(self,
635 635 rc.cache_size,
636 636 rc.pprint,
637 637 input_sep = rc.separate_in,
638 638 output_sep = rc.separate_out,
639 639 output_sep2 = rc.separate_out2,
640 640 ps1 = rc.prompt_in1,
641 641 ps2 = rc.prompt_in2,
642 642 ps_out = rc.prompt_out,
643 643 pad_left = rc.prompts_pad_left)
644 644
645 645 # user may have over-ridden the default print hook:
646 646 try:
647 647 self.outputcache.__class__.display = self.hooks.display
648 648 except AttributeError:
649 649 pass
650 650
651 651 # I don't like assigning globally to sys, because it means when embedding
652 652 # instances, each embedded instance overrides the previous choice. But
653 653 # sys.displayhook seems to be called internally by exec, so I don't see a
654 654 # way around it.
655 655 sys.displayhook = self.outputcache
656 656
657 657 # Set user colors (don't do it in the constructor above so that it
658 658 # doesn't crash if colors option is invalid)
659 659 self.magic_colors(rc.colors)
660 660
661 661 # Set calling of pdb on exceptions
662 662 self.call_pdb = rc.pdb
663 663
664 664 # Load user aliases
665 665 for alias in rc.alias:
666 666 self.magic_alias(alias)
667 667 self.hooks.late_startup_hook()
668 668
669 669 batchrun = False
670 670 for batchfile in [path(arg) for arg in self.rc.args
671 671 if arg.lower().endswith('.ipy')]:
672 672 if not batchfile.isfile():
673 673 print "No such batch file:", batchfile
674 674 continue
675 675 self.api.runlines(batchfile.text())
676 676 batchrun = True
677 677 if batchrun:
678 678 self.exit_now = True
679 679
680 680 def add_builtins(self):
681 681 """Store ipython references into the builtin namespace.
682 682
683 683 Some parts of ipython operate via builtins injected here, which hold a
684 684 reference to IPython itself."""
685 685
686 686 # TODO: deprecate all except _ip; 'jobs' should be installed
687 687 # by an extension and the rest are under _ip, ipalias is redundant
688 688 builtins_new = dict(__IPYTHON__ = self,
689 689 ip_set_hook = self.set_hook,
690 690 jobs = self.jobs,
691 691 ipmagic = self.ipmagic,
692 692 ipalias = self.ipalias,
693 693 ipsystem = self.ipsystem,
694 694 _ip = self.api
695 695 )
696 696 for biname,bival in builtins_new.items():
697 697 try:
698 698 # store the orignal value so we can restore it
699 699 self.builtins_added[biname] = __builtin__.__dict__[biname]
700 700 except KeyError:
701 701 # or mark that it wasn't defined, and we'll just delete it at
702 702 # cleanup
703 703 self.builtins_added[biname] = Undefined
704 704 __builtin__.__dict__[biname] = bival
705 705
706 706 # Keep in the builtins a flag for when IPython is active. We set it
707 707 # with setdefault so that multiple nested IPythons don't clobber one
708 708 # another. Each will increase its value by one upon being activated,
709 709 # which also gives us a way to determine the nesting level.
710 710 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
711 711
712 712 def clean_builtins(self):
713 713 """Remove any builtins which might have been added by add_builtins, or
714 714 restore overwritten ones to their previous values."""
715 715 for biname,bival in self.builtins_added.items():
716 716 if bival is Undefined:
717 717 del __builtin__.__dict__[biname]
718 718 else:
719 719 __builtin__.__dict__[biname] = bival
720 720 self.builtins_added.clear()
721 721
722 722 def set_hook(self,name,hook, priority = 50):
723 723 """set_hook(name,hook) -> sets an internal IPython hook.
724 724
725 725 IPython exposes some of its internal API as user-modifiable hooks. By
726 726 adding your function to one of these hooks, you can modify IPython's
727 727 behavior to call at runtime your own routines."""
728 728
729 729 # At some point in the future, this should validate the hook before it
730 730 # accepts it. Probably at least check that the hook takes the number
731 731 # of args it's supposed to.
732 732 dp = getattr(self.hooks, name, None)
733 733 if name not in IPython.hooks.__all__:
734 734 print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
735 735 if not dp:
736 736 dp = IPython.hooks.CommandChainDispatcher()
737 737
738 738 f = new.instancemethod(hook,self,self.__class__)
739 739 try:
740 740 dp.add(f,priority)
741 741 except AttributeError:
742 742 # it was not commandchain, plain old func - replace
743 743 dp = f
744 744
745 745 setattr(self.hooks,name, dp)
746 746
747 747
748 748 #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
749 749
750 750 def set_custom_exc(self,exc_tuple,handler):
751 751 """set_custom_exc(exc_tuple,handler)
752 752
753 753 Set a custom exception handler, which will be called if any of the
754 754 exceptions in exc_tuple occur in the mainloop (specifically, in the
755 755 runcode() method.
756 756
757 757 Inputs:
758 758
759 759 - exc_tuple: a *tuple* of valid exceptions to call the defined
760 760 handler for. It is very important that you use a tuple, and NOT A
761 761 LIST here, because of the way Python's except statement works. If
762 762 you only want to trap a single exception, use a singleton tuple:
763 763
764 764 exc_tuple == (MyCustomException,)
765 765
766 766 - handler: this must be defined as a function with the following
767 767 basic interface: def my_handler(self,etype,value,tb).
768 768
769 769 This will be made into an instance method (via new.instancemethod)
770 770 of IPython itself, and it will be called if any of the exceptions
771 771 listed in the exc_tuple are caught. If the handler is None, an
772 772 internal basic one is used, which just prints basic info.
773 773
774 774 WARNING: by putting in your own exception handler into IPython's main
775 775 execution loop, you run a very good chance of nasty crashes. This
776 776 facility should only be used if you really know what you are doing."""
777 777
778 778 assert type(exc_tuple)==type(()) , \
779 779 "The custom exceptions must be given AS A TUPLE."
780 780
781 781 def dummy_handler(self,etype,value,tb):
782 782 print '*** Simple custom exception handler ***'
783 783 print 'Exception type :',etype
784 784 print 'Exception value:',value
785 785 print 'Traceback :',tb
786 786 print 'Source code :','\n'.join(self.buffer)
787 787
788 788 if handler is None: handler = dummy_handler
789 789
790 790 self.CustomTB = new.instancemethod(handler,self,self.__class__)
791 791 self.custom_exceptions = exc_tuple
792 792
793 793 def set_custom_completer(self,completer,pos=0):
794 794 """set_custom_completer(completer,pos=0)
795 795
796 796 Adds a new custom completer function.
797 797
798 798 The position argument (defaults to 0) is the index in the completers
799 799 list where you want the completer to be inserted."""
800 800
801 801 newcomp = new.instancemethod(completer,self.Completer,
802 802 self.Completer.__class__)
803 803 self.Completer.matchers.insert(pos,newcomp)
804 804
805 805 def _get_call_pdb(self):
806 806 return self._call_pdb
807 807
808 808 def _set_call_pdb(self,val):
809 809
810 810 if val not in (0,1,False,True):
811 811 raise ValueError,'new call_pdb value must be boolean'
812 812
813 813 # store value in instance
814 814 self._call_pdb = val
815 815
816 816 # notify the actual exception handlers
817 817 self.InteractiveTB.call_pdb = val
818 818 if self.isthreaded:
819 819 try:
820 820 self.sys_excepthook.call_pdb = val
821 821 except:
822 822 warn('Failed to activate pdb for threaded exception handler')
823 823
824 824 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
825 825 'Control auto-activation of pdb at exceptions')
826 826
827 827
828 828 # These special functions get installed in the builtin namespace, to
829 829 # provide programmatic (pure python) access to magics, aliases and system
830 830 # calls. This is important for logging, user scripting, and more.
831 831
832 832 # We are basically exposing, via normal python functions, the three
833 833 # mechanisms in which ipython offers special call modes (magics for
834 834 # internal control, aliases for direct system access via pre-selected
835 835 # names, and !cmd for calling arbitrary system commands).
836 836
837 837 def ipmagic(self,arg_s):
838 838 """Call a magic function by name.
839 839
840 840 Input: a string containing the name of the magic function to call and any
841 841 additional arguments to be passed to the magic.
842 842
843 843 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
844 844 prompt:
845 845
846 846 In[1]: %name -opt foo bar
847 847
848 848 To call a magic without arguments, simply use ipmagic('name').
849 849
850 850 This provides a proper Python function to call IPython's magics in any
851 851 valid Python code you can type at the interpreter, including loops and
852 852 compound statements. It is added by IPython to the Python builtin
853 853 namespace upon initialization."""
854 854
855 855 args = arg_s.split(' ',1)
856 856 magic_name = args[0]
857 857 magic_name = magic_name.lstrip(self.ESC_MAGIC)
858 858
859 859 try:
860 860 magic_args = args[1]
861 861 except IndexError:
862 862 magic_args = ''
863 863 fn = getattr(self,'magic_'+magic_name,None)
864 864 if fn is None:
865 865 error("Magic function `%s` not found." % magic_name)
866 866 else:
867 867 magic_args = self.var_expand(magic_args)
868 868 return fn(magic_args)
869 869
870 870 def ipalias(self,arg_s):
871 871 """Call an alias by name.
872 872
873 873 Input: a string containing the name of the alias to call and any
874 874 additional arguments to be passed to the magic.
875 875
876 876 ipalias('name -opt foo bar') is equivalent to typing at the ipython
877 877 prompt:
878 878
879 879 In[1]: name -opt foo bar
880 880
881 881 To call an alias without arguments, simply use ipalias('name').
882 882
883 883 This provides a proper Python function to call IPython's aliases in any
884 884 valid Python code you can type at the interpreter, including loops and
885 885 compound statements. It is added by IPython to the Python builtin
886 886 namespace upon initialization."""
887 887
888 888 args = arg_s.split(' ',1)
889 889 alias_name = args[0]
890 890 try:
891 891 alias_args = args[1]
892 892 except IndexError:
893 893 alias_args = ''
894 894 if alias_name in self.alias_table:
895 895 self.call_alias(alias_name,alias_args)
896 896 else:
897 897 error("Alias `%s` not found." % alias_name)
898 898
899 899 def ipsystem(self,arg_s):
900 900 """Make a system call, using IPython."""
901 901
902 902 self.system(arg_s)
903 903
904 904 def complete(self,text):
905 905 """Return a sorted list of all possible completions on text.
906 906
907 907 Inputs:
908 908
909 909 - text: a string of text to be completed on.
910 910
911 911 This is a wrapper around the completion mechanism, similar to what
912 912 readline does at the command line when the TAB key is hit. By
913 913 exposing it as a method, it can be used by other non-readline
914 914 environments (such as GUIs) for text completion.
915 915
916 916 Simple usage example:
917 917
918 918 In [1]: x = 'hello'
919 919
920 920 In [2]: __IP.complete('x.l')
921 921 Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
922 922
923 923 complete = self.Completer.complete
924 924 state = 0
925 925 # use a dict so we get unique keys, since ipyhton's multiple
926 926 # completers can return duplicates.
927 927 comps = {}
928 928 while True:
929 929 newcomp = complete(text,state)
930 930 if newcomp is None:
931 931 break
932 932 comps[newcomp] = 1
933 933 state += 1
934 934 outcomps = comps.keys()
935 935 outcomps.sort()
936 936 return outcomps
937 937
938 938 def set_completer_frame(self, frame=None):
939 939 if frame:
940 940 self.Completer.namespace = frame.f_locals
941 941 self.Completer.global_namespace = frame.f_globals
942 942 else:
943 943 self.Completer.namespace = self.user_ns
944 944 self.Completer.global_namespace = self.user_global_ns
945 945
946 946 def init_auto_alias(self):
947 947 """Define some aliases automatically.
948 948
949 949 These are ALL parameter-less aliases"""
950 950
951 951 for alias,cmd in self.auto_alias:
952 952 self.alias_table[alias] = (0,cmd)
953 953
954 954 def alias_table_validate(self,verbose=0):
955 955 """Update information about the alias table.
956 956
957 957 In particular, make sure no Python keywords/builtins are in it."""
958 958
959 959 no_alias = self.no_alias
960 960 for k in self.alias_table.keys():
961 961 if k in no_alias:
962 962 del self.alias_table[k]
963 963 if verbose:
964 964 print ("Deleting alias <%s>, it's a Python "
965 965 "keyword or builtin." % k)
966 966
967 967 def set_autoindent(self,value=None):
968 968 """Set the autoindent flag, checking for readline support.
969 969
970 970 If called with no arguments, it acts as a toggle."""
971 971
972 972 if not self.has_readline:
973 973 if os.name == 'posix':
974 974 warn("The auto-indent feature requires the readline library")
975 975 self.autoindent = 0
976 976 return
977 977 if value is None:
978 978 self.autoindent = not self.autoindent
979 979 else:
980 980 self.autoindent = value
981 981
982 982 def rc_set_toggle(self,rc_field,value=None):
983 983 """Set or toggle a field in IPython's rc config. structure.
984 984
985 985 If called with no arguments, it acts as a toggle.
986 986
987 987 If called with a non-existent field, the resulting AttributeError
988 988 exception will propagate out."""
989 989
990 990 rc_val = getattr(self.rc,rc_field)
991 991 if value is None:
992 992 value = not rc_val
993 993 setattr(self.rc,rc_field,value)
994 994
995 995 def user_setup(self,ipythondir,rc_suffix,mode='install'):
996 996 """Install the user configuration directory.
997 997
998 998 Can be called when running for the first time or to upgrade the user's
999 999 .ipython/ directory with the mode parameter. Valid modes are 'install'
1000 1000 and 'upgrade'."""
1001 1001
1002 1002 def wait():
1003 1003 try:
1004 1004 raw_input("Please press <RETURN> to start IPython.")
1005 1005 except EOFError:
1006 1006 print >> Term.cout
1007 1007 print '*'*70
1008 1008
1009 1009 cwd = os.getcwd() # remember where we started
1010 1010 glb = glob.glob
1011 1011 print '*'*70
1012 1012 if mode == 'install':
1013 1013 print \
1014 1014 """Welcome to IPython. I will try to create a personal configuration directory
1015 1015 where you can customize many aspects of IPython's functionality in:\n"""
1016 1016 else:
1017 1017 print 'I am going to upgrade your configuration in:'
1018 1018
1019 1019 print ipythondir
1020 1020
1021 1021 rcdirend = os.path.join('IPython','UserConfig')
1022 1022 cfg = lambda d: os.path.join(d,rcdirend)
1023 1023 try:
1024 1024 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
1025 1025 except IOError:
1026 1026 warning = """
1027 1027 Installation error. IPython's directory was not found.
1028 1028
1029 1029 Check the following:
1030 1030
1031 1031 The ipython/IPython directory should be in a directory belonging to your
1032 1032 PYTHONPATH environment variable (that is, it should be in a directory
1033 1033 belonging to sys.path). You can copy it explicitly there or just link to it.
1034 1034
1035 1035 IPython will proceed with builtin defaults.
1036 1036 """
1037 1037 warn(warning)
1038 1038 wait()
1039 1039 return
1040 1040
1041 1041 if mode == 'install':
1042 1042 try:
1043 1043 shutil.copytree(rcdir,ipythondir)
1044 1044 os.chdir(ipythondir)
1045 1045 rc_files = glb("ipythonrc*")
1046 1046 for rc_file in rc_files:
1047 1047 os.rename(rc_file,rc_file+rc_suffix)
1048 1048 except:
1049 1049 warning = """
1050 1050
1051 1051 There was a problem with the installation:
1052 1052 %s
1053 1053 Try to correct it or contact the developers if you think it's a bug.
1054 1054 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
1055 1055 warn(warning)
1056 1056 wait()
1057 1057 return
1058 1058
1059 1059 elif mode == 'upgrade':
1060 1060 try:
1061 1061 os.chdir(ipythondir)
1062 1062 except:
1063 1063 print """
1064 1064 Can not upgrade: changing to directory %s failed. Details:
1065 1065 %s
1066 1066 """ % (ipythondir,sys.exc_info()[1])
1067 1067 wait()
1068 1068 return
1069 1069 else:
1070 1070 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
1071 1071 for new_full_path in sources:
1072 1072 new_filename = os.path.basename(new_full_path)
1073 1073 if new_filename.startswith('ipythonrc'):
1074 1074 new_filename = new_filename + rc_suffix
1075 1075 # The config directory should only contain files, skip any
1076 1076 # directories which may be there (like CVS)
1077 1077 if os.path.isdir(new_full_path):
1078 1078 continue
1079 1079 if os.path.exists(new_filename):
1080 1080 old_file = new_filename+'.old'
1081 1081 if os.path.exists(old_file):
1082 1082 os.remove(old_file)
1083 1083 os.rename(new_filename,old_file)
1084 1084 shutil.copy(new_full_path,new_filename)
1085 1085 else:
1086 1086 raise ValueError,'unrecognized mode for install:',`mode`
1087 1087
1088 1088 # Fix line-endings to those native to each platform in the config
1089 1089 # directory.
1090 1090 try:
1091 1091 os.chdir(ipythondir)
1092 1092 except:
1093 1093 print """
1094 1094 Problem: changing to directory %s failed.
1095 1095 Details:
1096 1096 %s
1097 1097
1098 1098 Some configuration files may have incorrect line endings. This should not
1099 1099 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])
1100 1100 wait()
1101 1101 else:
1102 1102 for fname in glb('ipythonrc*'):
1103 1103 try:
1104 1104 native_line_ends(fname,backup=0)
1105 1105 except IOError:
1106 1106 pass
1107 1107
1108 1108 if mode == 'install':
1109 1109 print """
1110 1110 Successful installation!
1111 1111
1112 1112 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
1113 1113 IPython manual (there are both HTML and PDF versions supplied with the
1114 1114 distribution) to make sure that your system environment is properly configured
1115 1115 to take advantage of IPython's features.
1116 1116
1117 1117 Important note: the configuration system has changed! The old system is
1118 1118 still in place, but its setting may be partly overridden by the settings in
1119 1119 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file
1120 1120 if some of the new settings bother you.
1121 1121
1122 1122 """
1123 1123 else:
1124 1124 print """
1125 1125 Successful upgrade!
1126 1126
1127 1127 All files in your directory:
1128 1128 %(ipythondir)s
1129 1129 which would have been overwritten by the upgrade were backed up with a .old
1130 1130 extension. If you had made particular customizations in those files you may
1131 1131 want to merge them back into the new files.""" % locals()
1132 1132 wait()
1133 1133 os.chdir(cwd)
1134 1134 # end user_setup()
1135 1135
1136 1136 def atexit_operations(self):
1137 1137 """This will be executed at the time of exit.
1138 1138
1139 1139 Saving of persistent data should be performed here. """
1140 1140
1141 1141 #print '*** IPython exit cleanup ***' # dbg
1142 1142 # input history
1143 1143 self.savehist()
1144 1144
1145 1145 # Cleanup all tempfiles left around
1146 1146 for tfile in self.tempfiles:
1147 1147 try:
1148 1148 os.unlink(tfile)
1149 1149 except OSError:
1150 1150 pass
1151 1151
1152 1152 # save the "persistent data" catch-all dictionary
1153 1153 self.hooks.shutdown_hook()
1154 1154
1155 1155 def savehist(self):
1156 1156 """Save input history to a file (via readline library)."""
1157 1157 try:
1158 1158 self.readline.write_history_file(self.histfile)
1159 1159 except:
1160 1160 print 'Unable to save IPython command history to file: ' + \
1161 1161 `self.histfile`
1162 1162
1163 1163 def pre_readline(self):
1164 1164 """readline hook to be used at the start of each line.
1165 1165
1166 1166 Currently it handles auto-indent only."""
1167 1167
1168 1168 #debugx('self.indent_current_nsp','pre_readline:')
1169 1169 self.readline.insert_text(self.indent_current_str())
1170 1170
1171 1171 def init_readline(self):
1172 1172 """Command history completion/saving/reloading."""
1173 1173
1174 1174 import IPython.rlineimpl as readline
1175 1175 if not readline.have_readline:
1176 1176 self.has_readline = 0
1177 1177 self.readline = None
1178 1178 # no point in bugging windows users with this every time:
1179 1179 warn('Readline services not available on this platform.')
1180 1180 else:
1181 1181 sys.modules['readline'] = readline
1182 1182 import atexit
1183 1183 from IPython.completer import IPCompleter
1184 1184 self.Completer = IPCompleter(self,
1185 1185 self.user_ns,
1186 1186 self.user_global_ns,
1187 1187 self.rc.readline_omit__names,
1188 1188 self.alias_table)
1189 1189
1190 1190 # Platform-specific configuration
1191 1191 if os.name == 'nt':
1192 1192 self.readline_startup_hook = readline.set_pre_input_hook
1193 1193 else:
1194 1194 self.readline_startup_hook = readline.set_startup_hook
1195 1195
1196 1196 # Load user's initrc file (readline config)
1197 1197 inputrc_name = os.environ.get('INPUTRC')
1198 1198 if inputrc_name is None:
1199 1199 home_dir = get_home_dir()
1200 1200 if home_dir is not None:
1201 1201 inputrc_name = os.path.join(home_dir,'.inputrc')
1202 1202 if os.path.isfile(inputrc_name):
1203 1203 try:
1204 1204 readline.read_init_file(inputrc_name)
1205 1205 except:
1206 1206 warn('Problems reading readline initialization file <%s>'
1207 1207 % inputrc_name)
1208 1208
1209 1209 self.has_readline = 1
1210 1210 self.readline = readline
1211 1211 # save this in sys so embedded copies can restore it properly
1212 1212 sys.ipcompleter = self.Completer.complete
1213 1213 readline.set_completer(self.Completer.complete)
1214 1214
1215 1215 # Configure readline according to user's prefs
1216 1216 for rlcommand in self.rc.readline_parse_and_bind:
1217 1217 readline.parse_and_bind(rlcommand)
1218 1218
1219 1219 # remove some chars from the delimiters list
1220 1220 delims = readline.get_completer_delims()
1221 1221 delims = delims.translate(string._idmap,
1222 1222 self.rc.readline_remove_delims)
1223 1223 readline.set_completer_delims(delims)
1224 1224 # otherwise we end up with a monster history after a while:
1225 1225 readline.set_history_length(1000)
1226 1226 try:
1227 1227 #print '*** Reading readline history' # dbg
1228 1228 readline.read_history_file(self.histfile)
1229 1229 except IOError:
1230 1230 pass # It doesn't exist yet.
1231 1231
1232 1232 atexit.register(self.atexit_operations)
1233 1233 del atexit
1234 1234
1235 1235 # Configure auto-indent for all platforms
1236 1236 self.set_autoindent(self.rc.autoindent)
1237 1237
1238 1238 def ask_yes_no(self,prompt,default=True):
1239 1239 if self.rc.quiet:
1240 1240 return True
1241 1241 return ask_yes_no(prompt,default)
1242 1242
1243 1243 def _should_recompile(self,e):
1244 1244 """Utility routine for edit_syntax_error"""
1245 1245
1246 1246 if e.filename in ('<ipython console>','<input>','<string>',
1247 1247 '<console>','<BackgroundJob compilation>',
1248 1248 None):
1249 1249
1250 1250 return False
1251 1251 try:
1252 1252 if (self.rc.autoedit_syntax and
1253 1253 not self.ask_yes_no('Return to editor to correct syntax error? '
1254 1254 '[Y/n] ','y')):
1255 1255 return False
1256 1256 except EOFError:
1257 1257 return False
1258 1258
1259 1259 def int0(x):
1260 1260 try:
1261 1261 return int(x)
1262 1262 except TypeError:
1263 1263 return 0
1264 1264 # always pass integer line and offset values to editor hook
1265 1265 self.hooks.fix_error_editor(e.filename,
1266 1266 int0(e.lineno),int0(e.offset),e.msg)
1267 1267 return True
1268 1268
1269 1269 def edit_syntax_error(self):
1270 1270 """The bottom half of the syntax error handler called in the main loop.
1271 1271
1272 1272 Loop until syntax error is fixed or user cancels.
1273 1273 """
1274 1274
1275 1275 while self.SyntaxTB.last_syntax_error:
1276 1276 # copy and clear last_syntax_error
1277 1277 err = self.SyntaxTB.clear_err_state()
1278 1278 if not self._should_recompile(err):
1279 1279 return
1280 1280 try:
1281 1281 # may set last_syntax_error again if a SyntaxError is raised
1282 1282 self.safe_execfile(err.filename,self.user_ns)
1283 1283 except:
1284 1284 self.showtraceback()
1285 1285 else:
1286 1286 try:
1287 1287 f = file(err.filename)
1288 1288 try:
1289 1289 sys.displayhook(f.read())
1290 1290 finally:
1291 1291 f.close()
1292 1292 except:
1293 1293 self.showtraceback()
1294 1294
1295 1295 def showsyntaxerror(self, filename=None):
1296 1296 """Display the syntax error that just occurred.
1297 1297
1298 1298 This doesn't display a stack trace because there isn't one.
1299 1299
1300 1300 If a filename is given, it is stuffed in the exception instead
1301 1301 of what was there before (because Python's parser always uses
1302 1302 "<string>" when reading from a string).
1303 1303 """
1304 1304 etype, value, last_traceback = sys.exc_info()
1305 1305
1306 1306 # See note about these variables in showtraceback() below
1307 1307 sys.last_type = etype
1308 1308 sys.last_value = value
1309 1309 sys.last_traceback = last_traceback
1310 1310
1311 1311 if filename and etype is SyntaxError:
1312 1312 # Work hard to stuff the correct filename in the exception
1313 1313 try:
1314 1314 msg, (dummy_filename, lineno, offset, line) = value
1315 1315 except:
1316 1316 # Not the format we expect; leave it alone
1317 1317 pass
1318 1318 else:
1319 1319 # Stuff in the right filename
1320 1320 try:
1321 1321 # Assume SyntaxError is a class exception
1322 1322 value = SyntaxError(msg, (filename, lineno, offset, line))
1323 1323 except:
1324 1324 # If that failed, assume SyntaxError is a string
1325 1325 value = msg, (filename, lineno, offset, line)
1326 1326 self.SyntaxTB(etype,value,[])
1327 1327
1328 1328 def debugger(self):
1329 1329 """Call the pdb debugger."""
1330 1330
1331 1331 if not self.rc.pdb:
1332 1332 return
1333 1333 pdb.pm()
1334 1334
1335 1335 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1336 1336 """Display the exception that just occurred.
1337 1337
1338 1338 If nothing is known about the exception, this is the method which
1339 1339 should be used throughout the code for presenting user tracebacks,
1340 1340 rather than directly invoking the InteractiveTB object.
1341 1341
1342 1342 A specific showsyntaxerror() also exists, but this method can take
1343 1343 care of calling it if needed, so unless you are explicitly catching a
1344 1344 SyntaxError exception, don't try to analyze the stack manually and
1345 1345 simply call this method."""
1346 1346
1347 1347 # Though this won't be called by syntax errors in the input line,
1348 1348 # there may be SyntaxError cases whith imported code.
1349 1349 if exc_tuple is None:
1350 1350 etype, value, tb = sys.exc_info()
1351 1351 else:
1352 1352 etype, value, tb = exc_tuple
1353 1353 if etype is SyntaxError:
1354 1354 self.showsyntaxerror(filename)
1355 1355 else:
1356 1356 # WARNING: these variables are somewhat deprecated and not
1357 1357 # necessarily safe to use in a threaded environment, but tools
1358 1358 # like pdb depend on their existence, so let's set them. If we
1359 1359 # find problems in the field, we'll need to revisit their use.
1360 1360 sys.last_type = etype
1361 1361 sys.last_value = value
1362 1362 sys.last_traceback = tb
1363 1363
1364 1364 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1365 1365 if self.InteractiveTB.call_pdb and self.has_readline:
1366 1366 # pdb mucks up readline, fix it back
1367 1367 self.readline.set_completer(self.Completer.complete)
1368 1368
1369 1369 def mainloop(self,banner=None):
1370 1370 """Creates the local namespace and starts the mainloop.
1371 1371
1372 1372 If an optional banner argument is given, it will override the
1373 1373 internally created default banner."""
1374 1374
1375 1375 if self.rc.c: # Emulate Python's -c option
1376 1376 self.exec_init_cmd()
1377 1377 if banner is None:
1378 1378 if not self.rc.banner:
1379 1379 banner = ''
1380 1380 # banner is string? Use it directly!
1381 1381 elif isinstance(self.rc.banner,basestring):
1382 1382 banner = self.rc.banner
1383 1383 else:
1384 1384 banner = self.BANNER+self.banner2
1385 1385
1386 1386 self.interact(banner)
1387 1387
1388 1388 def exec_init_cmd(self):
1389 1389 """Execute a command given at the command line.
1390 1390
1391 1391 This emulates Python's -c option."""
1392 1392
1393 1393 #sys.argv = ['-c']
1394 1394 self.push(self.rc.c)
1395 1395
1396 1396 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1397 1397 """Embeds IPython into a running python program.
1398 1398
1399 1399 Input:
1400 1400
1401 1401 - header: An optional header message can be specified.
1402 1402
1403 1403 - local_ns, global_ns: working namespaces. If given as None, the
1404 1404 IPython-initialized one is updated with __main__.__dict__, so that
1405 1405 program variables become visible but user-specific configuration
1406 1406 remains possible.
1407 1407
1408 1408 - stack_depth: specifies how many levels in the stack to go to
1409 1409 looking for namespaces (when local_ns and global_ns are None). This
1410 1410 allows an intermediate caller to make sure that this function gets
1411 1411 the namespace from the intended level in the stack. By default (0)
1412 1412 it will get its locals and globals from the immediate caller.
1413 1413
1414 1414 Warning: it's possible to use this in a program which is being run by
1415 1415 IPython itself (via %run), but some funny things will happen (a few
1416 1416 globals get overwritten). In the future this will be cleaned up, as
1417 1417 there is no fundamental reason why it can't work perfectly."""
1418 1418
1419 1419 # Get locals and globals from caller
1420 1420 if local_ns is None or global_ns is None:
1421 1421 call_frame = sys._getframe(stack_depth).f_back
1422 1422
1423 1423 if local_ns is None:
1424 1424 local_ns = call_frame.f_locals
1425 1425 if global_ns is None:
1426 1426 global_ns = call_frame.f_globals
1427 1427
1428 1428 # Update namespaces and fire up interpreter
1429 1429
1430 1430 # The global one is easy, we can just throw it in
1431 1431 self.user_global_ns = global_ns
1432 1432
1433 1433 # but the user/local one is tricky: ipython needs it to store internal
1434 1434 # data, but we also need the locals. We'll copy locals in the user
1435 1435 # one, but will track what got copied so we can delete them at exit.
1436 1436 # This is so that a later embedded call doesn't see locals from a
1437 1437 # previous call (which most likely existed in a separate scope).
1438 1438 local_varnames = local_ns.keys()
1439 1439 self.user_ns.update(local_ns)
1440 1440
1441 1441 # Patch for global embedding to make sure that things don't overwrite
1442 1442 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1443 1443 # FIXME. Test this a bit more carefully (the if.. is new)
1444 1444 if local_ns is None and global_ns is None:
1445 1445 self.user_global_ns.update(__main__.__dict__)
1446 1446
1447 1447 # make sure the tab-completer has the correct frame information, so it
1448 1448 # actually completes using the frame's locals/globals
1449 1449 self.set_completer_frame()
1450 1450
1451 1451 # before activating the interactive mode, we need to make sure that
1452 1452 # all names in the builtin namespace needed by ipython point to
1453 1453 # ourselves, and not to other instances.
1454 1454 self.add_builtins()
1455 1455
1456 1456 self.interact(header)
1457 1457
1458 1458 # now, purge out the user namespace from anything we might have added
1459 1459 # from the caller's local namespace
1460 1460 delvar = self.user_ns.pop
1461 1461 for var in local_varnames:
1462 1462 delvar(var,None)
1463 1463 # and clean builtins we may have overridden
1464 1464 self.clean_builtins()
1465 1465
1466 1466 def interact(self, banner=None):
1467 1467 """Closely emulate the interactive Python console.
1468 1468
1469 1469 The optional banner argument specify the banner to print
1470 1470 before the first interaction; by default it prints a banner
1471 1471 similar to the one printed by the real Python interpreter,
1472 1472 followed by the current class name in parentheses (so as not
1473 1473 to confuse this with the real interpreter -- since it's so
1474 1474 close!).
1475 1475
1476 1476 """
1477 1477
1478 1478 if self.exit_now:
1479 1479 # batch run -> do not interact
1480 1480 return
1481 1481 cprt = 'Type "copyright", "credits" or "license" for more information.'
1482 1482 if banner is None:
1483 1483 self.write("Python %s on %s\n%s\n(%s)\n" %
1484 1484 (sys.version, sys.platform, cprt,
1485 1485 self.__class__.__name__))
1486 1486 else:
1487 1487 self.write(banner)
1488 1488
1489 1489 more = 0
1490 1490
1491 1491 # Mark activity in the builtins
1492 1492 __builtin__.__dict__['__IPYTHON__active'] += 1
1493 1493
1494 1494 # exit_now is set by a call to %Exit or %Quit
1495 1495 while not self.exit_now:
1496 1496 if more:
1497 1497 prompt = self.hooks.generate_prompt(True)
1498 1498 if self.autoindent:
1499 1499 self.readline_startup_hook(self.pre_readline)
1500 1500 else:
1501 1501 prompt = self.hooks.generate_prompt(False)
1502 1502 try:
1503 1503 line = self.raw_input(prompt,more)
1504 1504 if self.autoindent:
1505 1505 self.readline_startup_hook(None)
1506 1506 except KeyboardInterrupt:
1507 1507 self.write('\nKeyboardInterrupt\n')
1508 1508 self.resetbuffer()
1509 1509 # keep cache in sync with the prompt counter:
1510 1510 self.outputcache.prompt_count -= 1
1511 1511
1512 1512 if self.autoindent:
1513 1513 self.indent_current_nsp = 0
1514 1514 more = 0
1515 1515 except EOFError:
1516 1516 if self.autoindent:
1517 1517 self.readline_startup_hook(None)
1518 1518 self.write('\n')
1519 1519 self.exit()
1520 1520 except bdb.BdbQuit:
1521 1521 warn('The Python debugger has exited with a BdbQuit exception.\n'
1522 1522 'Because of how pdb handles the stack, it is impossible\n'
1523 1523 'for IPython to properly format this particular exception.\n'
1524 1524 'IPython will resume normal operation.')
1525 1525 except:
1526 1526 # exceptions here are VERY RARE, but they can be triggered
1527 1527 # asynchronously by signal handlers, for example.
1528 1528 self.showtraceback()
1529 1529 else:
1530 1530 more = self.push(line)
1531 1531 if (self.SyntaxTB.last_syntax_error and
1532 1532 self.rc.autoedit_syntax):
1533 1533 self.edit_syntax_error()
1534 1534
1535 1535 # We are off again...
1536 1536 __builtin__.__dict__['__IPYTHON__active'] -= 1
1537 1537
1538 1538 def excepthook(self, etype, value, tb):
1539 1539 """One more defense for GUI apps that call sys.excepthook.
1540 1540
1541 1541 GUI frameworks like wxPython trap exceptions and call
1542 1542 sys.excepthook themselves. I guess this is a feature that
1543 1543 enables them to keep running after exceptions that would
1544 1544 otherwise kill their mainloop. This is a bother for IPython
1545 1545 which excepts to catch all of the program exceptions with a try:
1546 1546 except: statement.
1547 1547
1548 1548 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1549 1549 any app directly invokes sys.excepthook, it will look to the user like
1550 1550 IPython crashed. In order to work around this, we can disable the
1551 1551 CrashHandler and replace it with this excepthook instead, which prints a
1552 1552 regular traceback using our InteractiveTB. In this fashion, apps which
1553 1553 call sys.excepthook will generate a regular-looking exception from
1554 1554 IPython, and the CrashHandler will only be triggered by real IPython
1555 1555 crashes.
1556 1556
1557 1557 This hook should be used sparingly, only in places which are not likely
1558 1558 to be true IPython errors.
1559 1559 """
1560 1560 self.showtraceback((etype,value,tb),tb_offset=0)
1561 1561
1562 1562 def transform_alias(self, alias,rest=''):
1563 1563 """ Transform alias to system command string.
1564 1564 """
1565 1565 nargs,cmd = self.alias_table[alias]
1566 1566 if ' ' in cmd and os.path.isfile(cmd):
1567 1567 cmd = '"%s"' % cmd
1568 1568
1569 1569 # Expand the %l special to be the user's input line
1570 1570 if cmd.find('%l') >= 0:
1571 1571 cmd = cmd.replace('%l',rest)
1572 1572 rest = ''
1573 1573 if nargs==0:
1574 1574 # Simple, argument-less aliases
1575 1575 cmd = '%s %s' % (cmd,rest)
1576 1576 else:
1577 1577 # Handle aliases with positional arguments
1578 1578 args = rest.split(None,nargs)
1579 1579 if len(args)< nargs:
1580 1580 error('Alias <%s> requires %s arguments, %s given.' %
1581 1581 (alias,nargs,len(args)))
1582 1582 return None
1583 1583 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1584 1584 # Now call the macro, evaluating in the user's namespace
1585 1585 #print 'new command: <%r>' % cmd # dbg
1586 1586 return cmd
1587 1587
1588 1588 def call_alias(self,alias,rest=''):
1589 1589 """Call an alias given its name and the rest of the line.
1590 1590
1591 1591 This is only used to provide backwards compatibility for users of
1592 1592 ipalias(), use of which is not recommended for anymore."""
1593 1593
1594 1594 # Now call the macro, evaluating in the user's namespace
1595 1595 cmd = self.transform_alias(alias, rest)
1596 1596 try:
1597 1597 self.system(cmd)
1598 1598 except:
1599 1599 self.showtraceback()
1600 1600
1601 1601 def indent_current_str(self):
1602 1602 """return the current level of indentation as a string"""
1603 1603 return self.indent_current_nsp * ' '
1604 1604
1605 1605 def autoindent_update(self,line):
1606 1606 """Keep track of the indent level."""
1607 1607
1608 1608 #debugx('line')
1609 1609 #debugx('self.indent_current_nsp')
1610 1610 if self.autoindent:
1611 1611 if line:
1612 1612 inisp = num_ini_spaces(line)
1613 1613 if inisp < self.indent_current_nsp:
1614 1614 self.indent_current_nsp = inisp
1615 1615
1616 1616 if line[-1] == ':':
1617 1617 self.indent_current_nsp += 4
1618 1618 elif dedent_re.match(line):
1619 1619 self.indent_current_nsp -= 4
1620 1620 else:
1621 1621 self.indent_current_nsp = 0
1622 1622
1623 1623 def runlines(self,lines):
1624 1624 """Run a string of one or more lines of source.
1625 1625
1626 1626 This method is capable of running a string containing multiple source
1627 1627 lines, as if they had been entered at the IPython prompt. Since it
1628 1628 exposes IPython's processing machinery, the given strings can contain
1629 1629 magic calls (%magic), special shell access (!cmd), etc."""
1630 1630
1631 1631 # We must start with a clean buffer, in case this is run from an
1632 1632 # interactive IPython session (via a magic, for example).
1633 1633 self.resetbuffer()
1634 1634 lines = lines.split('\n')
1635 1635 more = 0
1636 1636 for line in lines:
1637 1637 # skip blank lines so we don't mess up the prompt counter, but do
1638 1638 # NOT skip even a blank line if we are in a code block (more is
1639 1639 # true)
1640 1640 if line or more:
1641 1641 more = self.push(self.prefilter(line,more))
1642 1642 # IPython's runsource returns None if there was an error
1643 1643 # compiling the code. This allows us to stop processing right
1644 1644 # away, so the user gets the error message at the right place.
1645 1645 if more is None:
1646 1646 break
1647 1647 # final newline in case the input didn't have it, so that the code
1648 1648 # actually does get executed
1649 1649 if more:
1650 1650 self.push('\n')
1651 1651
1652 1652 def runsource(self, source, filename='<input>', symbol='single'):
1653 1653 """Compile and run some source in the interpreter.
1654 1654
1655 1655 Arguments are as for compile_command().
1656 1656
1657 1657 One several things can happen:
1658 1658
1659 1659 1) The input is incorrect; compile_command() raised an
1660 1660 exception (SyntaxError or OverflowError). A syntax traceback
1661 1661 will be printed by calling the showsyntaxerror() method.
1662 1662
1663 1663 2) The input is incomplete, and more input is required;
1664 1664 compile_command() returned None. Nothing happens.
1665 1665
1666 1666 3) The input is complete; compile_command() returned a code
1667 1667 object. The code is executed by calling self.runcode() (which
1668 1668 also handles run-time exceptions, except for SystemExit).
1669 1669
1670 1670 The return value is:
1671 1671
1672 1672 - True in case 2
1673 1673
1674 1674 - False in the other cases, unless an exception is raised, where
1675 1675 None is returned instead. This can be used by external callers to
1676 1676 know whether to continue feeding input or not.
1677 1677
1678 1678 The return value can be used to decide whether to use sys.ps1 or
1679 1679 sys.ps2 to prompt the next line."""
1680 1680
1681 1681 try:
1682 1682 code = self.compile(source,filename,symbol)
1683 1683 except (OverflowError, SyntaxError, ValueError):
1684 1684 # Case 1
1685 1685 self.showsyntaxerror(filename)
1686 1686 return None
1687 1687
1688 1688 if code is None:
1689 1689 # Case 2
1690 1690 return True
1691 1691
1692 1692 # Case 3
1693 1693 # We store the code object so that threaded shells and
1694 1694 # custom exception handlers can access all this info if needed.
1695 1695 # The source corresponding to this can be obtained from the
1696 1696 # buffer attribute as '\n'.join(self.buffer).
1697 1697 self.code_to_run = code
1698 1698 # now actually execute the code object
1699 1699 if self.runcode(code) == 0:
1700 1700 return False
1701 1701 else:
1702 1702 return None
1703 1703
1704 1704 def runcode(self,code_obj):
1705 1705 """Execute a code object.
1706 1706
1707 1707 When an exception occurs, self.showtraceback() is called to display a
1708 1708 traceback.
1709 1709
1710 1710 Return value: a flag indicating whether the code to be run completed
1711 1711 successfully:
1712 1712
1713 1713 - 0: successful execution.
1714 1714 - 1: an error occurred.
1715 1715 """
1716 1716
1717 1717 # Set our own excepthook in case the user code tries to call it
1718 1718 # directly, so that the IPython crash handler doesn't get triggered
1719 1719 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
1720 1720
1721 1721 # we save the original sys.excepthook in the instance, in case config
1722 1722 # code (such as magics) needs access to it.
1723 1723 self.sys_excepthook = old_excepthook
1724 1724 outflag = 1 # happens in more places, so it's easier as default
1725 1725 try:
1726 1726 try:
1727 1727 # Embedded instances require separate global/local namespaces
1728 1728 # so they can see both the surrounding (local) namespace and
1729 1729 # the module-level globals when called inside another function.
1730 1730 if self.embedded:
1731 1731 exec code_obj in self.user_global_ns, self.user_ns
1732 1732 # Normal (non-embedded) instances should only have a single
1733 1733 # namespace for user code execution, otherwise functions won't
1734 1734 # see interactive top-level globals.
1735 1735 else:
1736 1736 exec code_obj in self.user_ns
1737 1737 finally:
1738 1738 # Reset our crash handler in place
1739 1739 sys.excepthook = old_excepthook
1740 1740 except SystemExit:
1741 1741 self.resetbuffer()
1742 1742 self.showtraceback()
1743 1743 warn("Type %exit or %quit to exit IPython "
1744 1744 "(%Exit or %Quit do so unconditionally).",level=1)
1745 1745 except self.custom_exceptions:
1746 1746 etype,value,tb = sys.exc_info()
1747 1747 self.CustomTB(etype,value,tb)
1748 1748 except:
1749 1749 self.showtraceback()
1750 1750 else:
1751 1751 outflag = 0
1752 1752 if softspace(sys.stdout, 0):
1753 1753 print
1754 1754 # Flush out code object which has been run (and source)
1755 1755 self.code_to_run = None
1756 1756 return outflag
1757 1757
1758 1758 def push(self, line):
1759 1759 """Push a line to the interpreter.
1760 1760
1761 1761 The line should not have a trailing newline; it may have
1762 1762 internal newlines. The line is appended to a buffer and the
1763 1763 interpreter's runsource() method is called with the
1764 1764 concatenated contents of the buffer as source. If this
1765 1765 indicates that the command was executed or invalid, the buffer
1766 1766 is reset; otherwise, the command is incomplete, and the buffer
1767 1767 is left as it was after the line was appended. The return
1768 1768 value is 1 if more input is required, 0 if the line was dealt
1769 1769 with in some way (this is the same as runsource()).
1770 1770 """
1771 1771
1772 1772 # autoindent management should be done here, and not in the
1773 1773 # interactive loop, since that one is only seen by keyboard input. We
1774 1774 # need this done correctly even for code run via runlines (which uses
1775 1775 # push).
1776 1776
1777 1777 #print 'push line: <%s>' % line # dbg
1778 1778 for subline in line.splitlines():
1779 1779 self.autoindent_update(subline)
1780 1780 self.buffer.append(line)
1781 1781 more = self.runsource('\n'.join(self.buffer), self.filename)
1782 1782 if not more:
1783 1783 self.resetbuffer()
1784 1784 return more
1785 1785
1786 1786 def resetbuffer(self):
1787 1787 """Reset the input buffer."""
1788 1788 self.buffer[:] = []
1789 1789
1790 1790 def raw_input(self,prompt='',continue_prompt=False):
1791 1791 """Write a prompt and read a line.
1792 1792
1793 1793 The returned line does not include the trailing newline.
1794 1794 When the user enters the EOF key sequence, EOFError is raised.
1795 1795
1796 1796 Optional inputs:
1797 1797
1798 1798 - prompt(''): a string to be printed to prompt the user.
1799 1799
1800 1800 - continue_prompt(False): whether this line is the first one or a
1801 1801 continuation in a sequence of inputs.
1802 1802 """
1803 1803
1804 1804 try:
1805 1805 line = raw_input_original(prompt)
1806 1806 except ValueError:
1807 1807 # python 2.5 closes stdin on exit -> ValueError
1808 1808 # xxx should we delete 'exit' and 'quit' from builtin?
1809 1809 self.exit_now = True
1810 1810 return ''
1811 1811
1812 1812
1813 1813 # Try to be reasonably smart about not re-indenting pasted input more
1814 1814 # than necessary. We do this by trimming out the auto-indent initial
1815 1815 # spaces, if the user's actual input started itself with whitespace.
1816 1816 #debugx('self.buffer[-1]')
1817 1817
1818 1818 if self.autoindent:
1819 1819 if num_ini_spaces(line) > self.indent_current_nsp:
1820 1820 line = line[self.indent_current_nsp:]
1821 1821 self.indent_current_nsp = 0
1822 1822
1823 1823 # store the unfiltered input before the user has any chance to modify
1824 1824 # it.
1825 1825 if line.strip():
1826 1826 if continue_prompt:
1827 1827 self.input_hist_raw[-1] += '%s\n' % line
1828 1828 if self.has_readline: # and some config option is set?
1829 1829 try:
1830 1830 histlen = self.readline.get_current_history_length()
1831 1831 newhist = self.input_hist_raw[-1].rstrip()
1832 1832 self.readline.remove_history_item(histlen-1)
1833 1833 self.readline.replace_history_item(histlen-2,newhist)
1834 1834 except AttributeError:
1835 1835 pass # re{move,place}_history_item are new in 2.4.
1836 1836 else:
1837 1837 self.input_hist_raw.append('%s\n' % line)
1838 1838
1839 1839 try:
1840 1840 lineout = self.prefilter(line,continue_prompt)
1841 1841 except:
1842 1842 # blanket except, in case a user-defined prefilter crashes, so it
1843 1843 # can't take all of ipython with it.
1844 1844 self.showtraceback()
1845 1845 return ''
1846 1846 else:
1847 1847 return lineout
1848 1848
1849 1849 def split_user_input(self,line):
1850 1850 """Split user input into pre-char, function part and rest."""
1851 1851
1852 1852 lsplit = self.line_split.match(line)
1853 1853 if lsplit is None: # no regexp match returns None
1854 1854 try:
1855 1855 iFun,theRest = line.split(None,1)
1856 1856 except ValueError:
1857 1857 iFun,theRest = line,''
1858 1858 pre = re.match('^(\s*)(.*)',line).groups()[0]
1859 1859 else:
1860 1860 pre,iFun,theRest = lsplit.groups()
1861 1861
1862 1862 #print 'line:<%s>' % line # dbg
1863 1863 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun.strip(),theRest) # dbg
1864 1864 return pre,iFun.strip(),theRest
1865 1865
1866 1866 def _prefilter(self, line, continue_prompt):
1867 1867 """Calls different preprocessors, depending on the form of line."""
1868 1868
1869 1869 # All handlers *must* return a value, even if it's blank ('').
1870 1870
1871 1871 # Lines are NOT logged here. Handlers should process the line as
1872 1872 # needed, update the cache AND log it (so that the input cache array
1873 1873 # stays synced).
1874 1874
1875 1875 # This function is _very_ delicate, and since it's also the one which
1876 1876 # determines IPython's response to user input, it must be as efficient
1877 1877 # as possible. For this reason it has _many_ returns in it, trying
1878 1878 # always to exit as quickly as it can figure out what it needs to do.
1879 1879
1880 1880 # This function is the main responsible for maintaining IPython's
1881 1881 # behavior respectful of Python's semantics. So be _very_ careful if
1882 1882 # making changes to anything here.
1883 1883
1884 1884 #.....................................................................
1885 1885 # Code begins
1886 1886
1887 1887 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
1888 1888
1889 1889 # save the line away in case we crash, so the post-mortem handler can
1890 1890 # record it
1891 1891 self._last_input_line = line
1892 1892
1893 1893 #print '***line: <%s>' % line # dbg
1894 1894
1895 1895 # the input history needs to track even empty lines
1896 1896 stripped = line.strip()
1897 1897
1898 1898 if not stripped:
1899 1899 if not continue_prompt:
1900 1900 self.outputcache.prompt_count -= 1
1901 1901 return self.handle_normal(line,continue_prompt)
1902 1902 #return self.handle_normal('',continue_prompt)
1903 1903
1904 1904 # print '***cont',continue_prompt # dbg
1905 1905 # special handlers are only allowed for single line statements
1906 1906 if continue_prompt and not self.rc.multi_line_specials:
1907 1907 return self.handle_normal(line,continue_prompt)
1908 1908
1909 1909
1910 1910 # For the rest, we need the structure of the input
1911 1911 pre,iFun,theRest = self.split_user_input(line)
1912 1912
1913 1913 # See whether any pre-existing handler can take care of it
1914 1914
1915 1915 rewritten = self.hooks.input_prefilter(stripped)
1916 1916 if rewritten != stripped: # ok, some prefilter did something
1917 1917 rewritten = pre + rewritten # add indentation
1918 1918 return self.handle_normal(rewritten)
1919 1919
1920 1920 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
1921 1921
1922 1922 # First check for explicit escapes in the last/first character
1923 1923 handler = None
1924 1924 if line[-1] == self.ESC_HELP:
1925 1925 handler = self.esc_handlers.get(line[-1]) # the ? can be at the end
1926 1926 if handler is None:
1927 1927 # look at the first character of iFun, NOT of line, so we skip
1928 1928 # leading whitespace in multiline input
1929 1929 handler = self.esc_handlers.get(iFun[0:1])
1930 1930 if handler is not None:
1931 1931 return handler(line,continue_prompt,pre,iFun,theRest)
1932 1932 # Emacs ipython-mode tags certain input lines
1933 1933 if line.endswith('# PYTHON-MODE'):
1934 1934 return self.handle_emacs(line,continue_prompt)
1935 1935
1936 1936 # Next, check if we can automatically execute this thing
1937 1937
1938 1938 # Allow ! in multi-line statements if multi_line_specials is on:
1939 1939 if continue_prompt and self.rc.multi_line_specials and \
1940 1940 iFun.startswith(self.ESC_SHELL):
1941 1941 return self.handle_shell_escape(line,continue_prompt,
1942 1942 pre=pre,iFun=iFun,
1943 1943 theRest=theRest)
1944 1944
1945 1945 # Let's try to find if the input line is a magic fn
1946 1946 oinfo = None
1947 1947 if hasattr(self,'magic_'+iFun):
1948 1948 # WARNING: _ofind uses getattr(), so it can consume generators and
1949 1949 # cause other side effects.
1950 1950 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1951 1951 if oinfo['ismagic']:
1952 1952 # Be careful not to call magics when a variable assignment is
1953 1953 # being made (ls='hi', for example)
1954 1954 if self.rc.automagic and \
1955 1955 (len(theRest)==0 or theRest[0] not in '!=()<>,') and \
1956 1956 (self.rc.multi_line_specials or not continue_prompt):
1957 1957 return self.handle_magic(line,continue_prompt,
1958 1958 pre,iFun,theRest)
1959 1959 else:
1960 1960 return self.handle_normal(line,continue_prompt)
1961 1961
1962 1962 # If the rest of the line begins with an (in)equality, assginment or
1963 1963 # function call, we should not call _ofind but simply execute it.
1964 1964 # This avoids spurious geattr() accesses on objects upon assignment.
1965 1965 #
1966 1966 # It also allows users to assign to either alias or magic names true
1967 1967 # python variables (the magic/alias systems always take second seat to
1968 1968 # true python code).
1969 1969 if theRest and theRest[0] in '!=()':
1970 1970 return self.handle_normal(line,continue_prompt)
1971 1971
1972 1972 if oinfo is None:
1973 1973 # let's try to ensure that _oinfo is ONLY called when autocall is
1974 1974 # on. Since it has inevitable potential side effects, at least
1975 1975 # having autocall off should be a guarantee to the user that no
1976 1976 # weird things will happen.
1977 1977
1978 1978 if self.rc.autocall:
1979 1979 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
1980 1980 else:
1981 1981 # in this case, all that's left is either an alias or
1982 1982 # processing the line normally.
1983 1983 if iFun in self.alias_table:
1984 1984 # if autocall is off, by not running _ofind we won't know
1985 1985 # whether the given name may also exist in one of the
1986 1986 # user's namespace. At this point, it's best to do a
1987 1987 # quick check just to be sure that we don't let aliases
1988 1988 # shadow variables.
1989 1989 head = iFun.split('.',1)[0]
1990 1990 if head in self.user_ns or head in self.internal_ns \
1991 1991 or head in __builtin__.__dict__:
1992 1992 return self.handle_normal(line,continue_prompt)
1993 1993 else:
1994 1994 return self.handle_alias(line,continue_prompt,
1995 1995 pre,iFun,theRest)
1996 1996
1997 1997 else:
1998 1998 return self.handle_normal(line,continue_prompt)
1999 1999
2000 2000 if not oinfo['found']:
2001 2001 return self.handle_normal(line,continue_prompt)
2002 2002 else:
2003 2003 #print 'pre<%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2004 2004 if oinfo['isalias']:
2005 2005 return self.handle_alias(line,continue_prompt,
2006 2006 pre,iFun,theRest)
2007 2007
2008 2008 if (self.rc.autocall
2009 2009 and
2010 2010 (
2011 2011 #only consider exclusion re if not "," or ";" autoquoting
2012 2012 (pre == self.ESC_QUOTE or pre == self.ESC_QUOTE2
2013 2013 or pre == self.ESC_PAREN) or
2014 2014 (not self.re_exclude_auto.match(theRest)))
2015 2015 and
2016 2016 self.re_fun_name.match(iFun) and
2017 2017 callable(oinfo['obj'])) :
2018 2018 #print 'going auto' # dbg
2019 2019 return self.handle_auto(line,continue_prompt,
2020 2020 pre,iFun,theRest,oinfo['obj'])
2021 2021 else:
2022 2022 #print 'was callable?', callable(oinfo['obj']) # dbg
2023 2023 return self.handle_normal(line,continue_prompt)
2024 2024
2025 2025 # If we get here, we have a normal Python line. Log and return.
2026 2026 return self.handle_normal(line,continue_prompt)
2027 2027
2028 2028 def _prefilter_dumb(self, line, continue_prompt):
2029 2029 """simple prefilter function, for debugging"""
2030 2030 return self.handle_normal(line,continue_prompt)
2031 2031
2032
2033 def multiline_prefilter(self, line, continue_prompt):
2034 """ Run _prefilter for each line of input
2035
2036 Covers cases where there are multiple lines in the user entry,
2037 which is the case when the user goes back to a multiline history
2038 entry and presses enter.
2039
2040 """
2041 out = []
2042 for l in line.rstrip('\n').split('\n'):
2043 out.append(self._prefilter(l, continue_prompt))
2044 return '\n'.join(out)
2045
2032 2046 # Set the default prefilter() function (this can be user-overridden)
2033 prefilter = _prefilter
2047 prefilter = multiline_prefilter
2034 2048
2035 2049 def handle_normal(self,line,continue_prompt=None,
2036 2050 pre=None,iFun=None,theRest=None):
2037 2051 """Handle normal input lines. Use as a template for handlers."""
2038 2052
2039 2053 # With autoindent on, we need some way to exit the input loop, and I
2040 2054 # don't want to force the user to have to backspace all the way to
2041 2055 # clear the line. The rule will be in this case, that either two
2042 2056 # lines of pure whitespace in a row, or a line of pure whitespace but
2043 2057 # of a size different to the indent level, will exit the input loop.
2044 2058
2045 2059 if (continue_prompt and self.autoindent and line.isspace() and
2046 2060 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2047 2061 (self.buffer[-1]).isspace() )):
2048 2062 line = ''
2049 2063
2050 2064 self.log(line,line,continue_prompt)
2051 2065 return line
2052 2066
2053 2067 def handle_alias(self,line,continue_prompt=None,
2054 2068 pre=None,iFun=None,theRest=None):
2055 2069 """Handle alias input lines. """
2056 2070
2057 2071 # pre is needed, because it carries the leading whitespace. Otherwise
2058 2072 # aliases won't work in indented sections.
2059 2073 transformed = self.transform_alias(iFun, theRest)
2060 2074 line_out = '%s_ip.system(%s)' % (pre, make_quoted_expr( transformed ))
2061 2075 self.log(line,line_out,continue_prompt)
2062 2076 #print 'line out:',line_out # dbg
2063 2077 return line_out
2064 2078
2065 2079 def handle_shell_escape(self, line, continue_prompt=None,
2066 2080 pre=None,iFun=None,theRest=None):
2067 2081 """Execute the line in a shell, empty return value"""
2068 2082
2069 2083 #print 'line in :', `line` # dbg
2070 2084 # Example of a special handler. Others follow a similar pattern.
2071 2085 if line.lstrip().startswith('!!'):
2072 2086 # rewrite iFun/theRest to properly hold the call to %sx and
2073 2087 # the actual command to be executed, so handle_magic can work
2074 2088 # correctly
2075 2089 theRest = '%s %s' % (iFun[2:],theRest)
2076 2090 iFun = 'sx'
2077 2091 return self.handle_magic('%ssx %s' % (self.ESC_MAGIC,
2078 2092 line.lstrip()[2:]),
2079 2093 continue_prompt,pre,iFun,theRest)
2080 2094 else:
2081 2095 cmd=line.lstrip().lstrip('!')
2082 2096 line_out = '%s_ip.system(%s)' % (pre,make_quoted_expr(cmd))
2083 2097 # update cache/log and return
2084 2098 self.log(line,line_out,continue_prompt)
2085 2099 return line_out
2086 2100
2087 2101 def handle_magic(self, line, continue_prompt=None,
2088 2102 pre=None,iFun=None,theRest=None):
2089 2103 """Execute magic functions."""
2090 2104
2091 2105
2092 2106 cmd = '%s_ip.magic(%s)' % (pre,make_quoted_expr(iFun + " " + theRest))
2093 2107 self.log(line,cmd,continue_prompt)
2094 2108 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2095 2109 return cmd
2096 2110
2097 2111 def handle_auto(self, line, continue_prompt=None,
2098 2112 pre=None,iFun=None,theRest=None,obj=None):
2099 2113 """Hande lines which can be auto-executed, quoting if requested."""
2100 2114
2101 2115 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2102 2116
2103 2117 # This should only be active for single-line input!
2104 2118 if continue_prompt:
2105 2119 self.log(line,line,continue_prompt)
2106 2120 return line
2107 2121
2108 2122 auto_rewrite = True
2109 2123
2110 2124 if pre == self.ESC_QUOTE:
2111 2125 # Auto-quote splitting on whitespace
2112 2126 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2113 2127 elif pre == self.ESC_QUOTE2:
2114 2128 # Auto-quote whole string
2115 2129 newcmd = '%s("%s")' % (iFun,theRest)
2116 2130 elif pre == self.ESC_PAREN:
2117 2131 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2118 2132 else:
2119 2133 # Auto-paren.
2120 2134 # We only apply it to argument-less calls if the autocall
2121 2135 # parameter is set to 2. We only need to check that autocall is <
2122 2136 # 2, since this function isn't called unless it's at least 1.
2123 2137 if not theRest and (self.rc.autocall < 2):
2124 2138 newcmd = '%s %s' % (iFun,theRest)
2125 2139 auto_rewrite = False
2126 2140 else:
2127 2141 if theRest.startswith('['):
2128 2142 if hasattr(obj,'__getitem__'):
2129 2143 # Don't autocall in this case: item access for an object
2130 2144 # which is BOTH callable and implements __getitem__.
2131 2145 newcmd = '%s %s' % (iFun,theRest)
2132 2146 auto_rewrite = False
2133 2147 else:
2134 2148 # if the object doesn't support [] access, go ahead and
2135 2149 # autocall
2136 2150 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2137 2151 elif theRest.endswith(';'):
2138 2152 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2139 2153 else:
2140 2154 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2141 2155
2142 2156 if auto_rewrite:
2143 2157 print >>Term.cout, self.outputcache.prompt1.auto_rewrite() + newcmd
2144 2158 # log what is now valid Python, not the actual user input (without the
2145 2159 # final newline)
2146 2160 self.log(line,newcmd,continue_prompt)
2147 2161 return newcmd
2148 2162
2149 2163 def handle_help(self, line, continue_prompt=None,
2150 2164 pre=None,iFun=None,theRest=None):
2151 2165 """Try to get some help for the object.
2152 2166
2153 2167 obj? or ?obj -> basic information.
2154 2168 obj?? or ??obj -> more details.
2155 2169 """
2156 2170
2157 2171 # We need to make sure that we don't process lines which would be
2158 2172 # otherwise valid python, such as "x=1 # what?"
2159 2173 try:
2160 2174 codeop.compile_command(line)
2161 2175 except SyntaxError:
2162 2176 # We should only handle as help stuff which is NOT valid syntax
2163 2177 if line[0]==self.ESC_HELP:
2164 2178 line = line[1:]
2165 2179 elif line[-1]==self.ESC_HELP:
2166 2180 line = line[:-1]
2167 2181 self.log(line,'#?'+line,continue_prompt)
2168 2182 if line:
2169 2183 self.magic_pinfo(line)
2170 2184 else:
2171 2185 page(self.usage,screen_lines=self.rc.screen_length)
2172 2186 return '' # Empty string is needed here!
2173 2187 except:
2174 2188 # Pass any other exceptions through to the normal handler
2175 2189 return self.handle_normal(line,continue_prompt)
2176 2190 else:
2177 2191 # If the code compiles ok, we should handle it normally
2178 2192 return self.handle_normal(line,continue_prompt)
2179 2193
2180 2194 def getapi(self):
2181 2195 """ Get an IPApi object for this shell instance
2182 2196
2183 2197 Getting an IPApi object is always preferable to accessing the shell
2184 2198 directly, but this holds true especially for extensions.
2185 2199
2186 2200 It should always be possible to implement an extension with IPApi
2187 2201 alone. If not, contact maintainer to request an addition.
2188 2202
2189 2203 """
2190 2204 return self.api
2191 2205
2192 2206 def handle_emacs(self,line,continue_prompt=None,
2193 2207 pre=None,iFun=None,theRest=None):
2194 2208 """Handle input lines marked by python-mode."""
2195 2209
2196 2210 # Currently, nothing is done. Later more functionality can be added
2197 2211 # here if needed.
2198 2212
2199 2213 # The input cache shouldn't be updated
2200 2214
2201 2215 return line
2202 2216
2203 2217 def mktempfile(self,data=None):
2204 2218 """Make a new tempfile and return its filename.
2205 2219
2206 2220 This makes a call to tempfile.mktemp, but it registers the created
2207 2221 filename internally so ipython cleans it up at exit time.
2208 2222
2209 2223 Optional inputs:
2210 2224
2211 2225 - data(None): if data is given, it gets written out to the temp file
2212 2226 immediately, and the file is closed again."""
2213 2227
2214 2228 filename = tempfile.mktemp('.py','ipython_edit_')
2215 2229 self.tempfiles.append(filename)
2216 2230
2217 2231 if data:
2218 2232 tmp_file = open(filename,'w')
2219 2233 tmp_file.write(data)
2220 2234 tmp_file.close()
2221 2235 return filename
2222 2236
2223 2237 def write(self,data):
2224 2238 """Write a string to the default output"""
2225 2239 Term.cout.write(data)
2226 2240
2227 2241 def write_err(self,data):
2228 2242 """Write a string to the default error output"""
2229 2243 Term.cerr.write(data)
2230 2244
2231 2245 def exit(self):
2232 2246 """Handle interactive exit.
2233 2247
2234 2248 This method sets the exit_now attribute."""
2235 2249
2236 2250 if self.rc.confirm_exit:
2237 2251 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2238 2252 self.exit_now = True
2239 2253 else:
2240 2254 self.exit_now = True
2241 2255 return self.exit_now
2242 2256
2243 2257 def safe_execfile(self,fname,*where,**kw):
2244 2258 fname = os.path.expanduser(fname)
2245 2259
2246 2260 # find things also in current directory
2247 2261 dname = os.path.dirname(fname)
2248 2262 if not sys.path.count(dname):
2249 2263 sys.path.append(dname)
2250 2264
2251 2265 try:
2252 2266 xfile = open(fname)
2253 2267 except:
2254 2268 print >> Term.cerr, \
2255 2269 'Could not open file <%s> for safe execution.' % fname
2256 2270 return None
2257 2271
2258 2272 kw.setdefault('islog',0)
2259 2273 kw.setdefault('quiet',1)
2260 2274 kw.setdefault('exit_ignore',0)
2261 2275 first = xfile.readline()
2262 2276 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2263 2277 xfile.close()
2264 2278 # line by line execution
2265 2279 if first.startswith(loghead) or kw['islog']:
2266 2280 print 'Loading log file <%s> one line at a time...' % fname
2267 2281 if kw['quiet']:
2268 2282 stdout_save = sys.stdout
2269 2283 sys.stdout = StringIO.StringIO()
2270 2284 try:
2271 2285 globs,locs = where[0:2]
2272 2286 except:
2273 2287 try:
2274 2288 globs = locs = where[0]
2275 2289 except:
2276 2290 globs = locs = globals()
2277 2291 badblocks = []
2278 2292
2279 2293 # we also need to identify indented blocks of code when replaying
2280 2294 # logs and put them together before passing them to an exec
2281 2295 # statement. This takes a bit of regexp and look-ahead work in the
2282 2296 # file. It's easiest if we swallow the whole thing in memory
2283 2297 # first, and manually walk through the lines list moving the
2284 2298 # counter ourselves.
2285 2299 indent_re = re.compile('\s+\S')
2286 2300 xfile = open(fname)
2287 2301 filelines = xfile.readlines()
2288 2302 xfile.close()
2289 2303 nlines = len(filelines)
2290 2304 lnum = 0
2291 2305 while lnum < nlines:
2292 2306 line = filelines[lnum]
2293 2307 lnum += 1
2294 2308 # don't re-insert logger status info into cache
2295 2309 if line.startswith('#log#'):
2296 2310 continue
2297 2311 else:
2298 2312 # build a block of code (maybe a single line) for execution
2299 2313 block = line
2300 2314 try:
2301 2315 next = filelines[lnum] # lnum has already incremented
2302 2316 except:
2303 2317 next = None
2304 2318 while next and indent_re.match(next):
2305 2319 block += next
2306 2320 lnum += 1
2307 2321 try:
2308 2322 next = filelines[lnum]
2309 2323 except:
2310 2324 next = None
2311 2325 # now execute the block of one or more lines
2312 2326 try:
2313 2327 exec block in globs,locs
2314 2328 except SystemExit:
2315 2329 pass
2316 2330 except:
2317 2331 badblocks.append(block.rstrip())
2318 2332 if kw['quiet']: # restore stdout
2319 2333 sys.stdout.close()
2320 2334 sys.stdout = stdout_save
2321 2335 print 'Finished replaying log file <%s>' % fname
2322 2336 if badblocks:
2323 2337 print >> sys.stderr, ('\nThe following lines/blocks in file '
2324 2338 '<%s> reported errors:' % fname)
2325 2339
2326 2340 for badline in badblocks:
2327 2341 print >> sys.stderr, badline
2328 2342 else: # regular file execution
2329 2343 try:
2330 2344 execfile(fname,*where)
2331 2345 except SyntaxError:
2332 2346 self.showsyntaxerror()
2333 2347 warn('Failure executing file: <%s>' % fname)
2334 2348 except SystemExit,status:
2335 2349 if not kw['exit_ignore']:
2336 2350 self.showtraceback()
2337 2351 warn('Failure executing file: <%s>' % fname)
2338 2352 except:
2339 2353 self.showtraceback()
2340 2354 warn('Failure executing file: <%s>' % fname)
2341 2355
2342 2356 #************************* end of file <iplib.py> *****************************
@@ -1,294 +1,319 b''
1 1 #!/usr/bin/env python
2 2 """Module for interactively running scripts.
3 3
4 4 This module implements classes for interactively running scripts written for
5 5 any system with a prompt which can be matched by a regexp suitable for
6 6 pexpect. It can be used to run as if they had been typed up interactively, an
7 7 arbitrary series of commands for the target system.
8 8
9 9 The module includes classes ready for IPython (with the default prompts),
10 10 plain Python and SAGE, but making a new one is trivial. To see how to use it,
11 11 simply run the module as a script:
12 12
13 13 ./irunner.py --help
14 14
15 15
16 16 This is an extension of Ken Schutte <kschutte-AT-csail.mit.edu>'s script
17 17 contributed on the ipython-user list:
18 18
19 19 http://scipy.net/pipermail/ipython-user/2006-May/001705.html
20 20
21 21
22 22 NOTES:
23 23
24 24 - This module requires pexpect, available in most linux distros, or which can
25 25 be downloaded from
26 26
27 27 http://pexpect.sourceforge.net
28 28
29 29 - Because pexpect only works under Unix or Windows-Cygwin, this has the same
30 30 limitations. This means that it will NOT work under native windows Python.
31 31 """
32 32
33 33 # Stdlib imports
34 34 import optparse
35 import os
35 36 import sys
36 37
37 38 # Third-party modules.
38 39 import pexpect
39 40
40 41 # Global usage strings, to avoid indentation issues when typing it below.
41 42 USAGE = """
42 43 Interactive script runner, type: %s
43 44
44 45 runner [opts] script_name
45 46 """
46 47
47 48 # The generic runner class
48 49 class InteractiveRunner(object):
49 50 """Class to run a sequence of commands through an interactive program."""
50 51
51 52 def __init__(self,program,prompts,args=None):
52 53 """Construct a runner.
53 54
54 55 Inputs:
55 56
56 57 - program: command to execute the given program.
57 58
58 59 - prompts: a list of patterns to match as valid prompts, in the
59 60 format used by pexpect. This basically means that it can be either
60 61 a string (to be compiled as a regular expression) or a list of such
61 62 (it must be a true list, as pexpect does type checks).
62 63
63 64 If more than one prompt is given, the first is treated as the main
64 65 program prompt and the others as 'continuation' prompts, like
65 66 python's. This means that blank lines in the input source are
66 67 ommitted when the first prompt is matched, but are NOT ommitted when
67 68 the continuation one matches, since this is how python signals the
68 69 end of multiline input interactively.
69 70
70 71 Optional inputs:
71 72
72 73 - args(None): optional list of strings to pass as arguments to the
73 74 child program.
74 75
75 76 Public members not parameterized in the constructor:
76 77
77 78 - delaybeforesend(0): Newer versions of pexpect have a delay before
78 79 sending each new input. For our purposes here, it's typically best
79 80 to just set this to zero, but if you encounter reliability problems
80 81 or want an interactive run to pause briefly at each prompt, just
81 82 increase this value (it is measured in seconds). Note that this
82 83 variable is not honored at all by older versions of pexpect.
83 84 """
84 85
85 86 self.program = program
86 87 self.prompts = prompts
87 88 if args is None: args = []
88 89 self.args = args
89 90 # Other public members which we don't make as parameters, but which
90 91 # users may occasionally want to tweak
91 92 self.delaybeforesend = 0
92 93
93 94 def run_file(self,fname,interact=False):
94 95 """Run the given file interactively.
95 96
96 97 Inputs:
97 98
98 99 -fname: name of the file to execute.
99 100
100 101 See the run_source docstring for the meaning of the optional
101 102 arguments."""
102 103
103 104 fobj = open(fname,'r')
104 105 try:
105 106 self.run_source(fobj,interact)
106 107 finally:
107 108 fobj.close()
108 109
109 110 def run_source(self,source,interact=False):
110 111 """Run the given source code interactively.
111 112
112 113 Inputs:
113 114
114 115 - source: a string of code to be executed, or an open file object we
115 116 can iterate over.
116 117
117 118 Optional inputs:
118 119
119 120 - interact(False): if true, start to interact with the running
120 121 program at the end of the script. Otherwise, just exit.
121 122 """
122 123
123 124 # if the source is a string, chop it up in lines so we can iterate
124 125 # over it just as if it were an open file.
125 126 if not isinstance(source,file):
126 127 source = source.splitlines(True)
127 128
128 129 # grab the true write method of stdout, in case anything later
129 130 # reassigns sys.stdout, so that we really are writing to the true
130 # stdout and not to something else.
131 write = sys.stdout.write
131 # stdout and not to something else. We also normalize all strings we
132 # write to use the native OS line separators.
133 linesep = os.linesep
134 stdwrite = sys.stdout.write
135 write = lambda s: stdwrite(s.replace('\r\n',linesep))
132 136
133 137 c = pexpect.spawn(self.program,self.args,timeout=None)
134 138 c.delaybeforesend = self.delaybeforesend
135 139
136 140 prompts = c.compile_pattern_list(self.prompts)
137 141
138 142 prompt_idx = c.expect_list(prompts)
139 143 # Flag whether the script ends normally or not, to know whether we can
140 144 # do anything further with the underlying process.
141 145 end_normal = True
142 146 for cmd in source:
143 147 # skip blank lines for all matches to the 'main' prompt, while the
144 148 # secondary prompts do not
145 if prompt_idx==0 and cmd.isspace():
149 if prompt_idx==0 and \
150 (cmd.isspace() or cmd.lstrip().startswith('#')):
151 print cmd,
146 152 continue
147 153
148 154 write(c.after)
149 155 c.send(cmd)
150 156 try:
151 157 prompt_idx = c.expect_list(prompts)
152 158 except pexpect.EOF:
153 159 # this will happen if the child dies unexpectedly
154 160 write(c.before)
155 161 end_normal = False
156 162 break
157 163 write(c.before)
158 164
159 if isinstance(source,file):
160 source.close()
161
162 165 if end_normal:
163 166 if interact:
164 167 c.send('\n')
165 168 print '<< Starting interactive mode >>',
166 169 try:
167 170 c.interact()
168 171 except OSError:
169 172 # This is what fires when the child stops. Simply print a
170 173 # newline so the system prompt is aligned. The extra
171 174 # space is there to make sure it gets printed, otherwise
172 175 # OS buffering sometimes just suppresses it.
173 176 write(' \n')
174 177 sys.stdout.flush()
175 178 else:
176 179 c.close()
177 180 else:
178 181 if interact:
179 182 e="Further interaction is not possible: child process is dead."
180 183 print >> sys.stderr, e
181 184
182 185 def main(self,argv=None):
183 186 """Run as a command-line script."""
184 187
185 188 parser = optparse.OptionParser(usage=USAGE % self.__class__.__name__)
186 189 newopt = parser.add_option
187 190 newopt('-i','--interact',action='store_true',default=False,
188 191 help='Interact with the program after the script is run.')
189 192
190 193 opts,args = parser.parse_args(argv)
191 194
192 195 if len(args) != 1:
193 196 print >> sys.stderr,"You must supply exactly one file to run."
194 197 sys.exit(1)
195 198
196 199 self.run_file(args[0],opts.interact)
197 200
198 201
199 202 # Specific runners for particular programs
200 203 class IPythonRunner(InteractiveRunner):
201 204 """Interactive IPython runner.
202 205
203 206 This initalizes IPython in 'nocolor' mode for simplicity. This lets us
204 207 avoid having to write a regexp that matches ANSI sequences, though pexpect
205 208 does support them. If anyone contributes patches for ANSI color support,
206 209 they will be welcome.
207 210
208 211 It also sets the prompts manually, since the prompt regexps for
209 212 pexpect need to be matched to the actual prompts, so user-customized
210 213 prompts would break this.
211 214 """
212 215
213 216 def __init__(self,program = 'ipython',args=None):
214 217 """New runner, optionally passing the ipython command to use."""
215 218
216 219 args0 = ['-colors','NoColor',
217 220 '-pi1','In [\\#]: ',
218 221 '-pi2',' .\\D.: ']
219 222 if args is None: args = args0
220 223 else: args = args0 + args
221 224 prompts = [r'In \[\d+\]: ',r' \.*: ']
222 225 InteractiveRunner.__init__(self,program,prompts,args)
223 226
224 227
225 228 class PythonRunner(InteractiveRunner):
226 229 """Interactive Python runner."""
227 230
228 231 def __init__(self,program='python',args=None):
229 232 """New runner, optionally passing the python command to use."""
230 233
231 234 prompts = [r'>>> ',r'\.\.\. ']
232 235 InteractiveRunner.__init__(self,program,prompts,args)
233 236
234 237
238 class DocTestRunner(PythonRunner):
239 """A python runner customized for doctest usage."""
240
241 def run_source(self,source,interact=False):
242 """Run the given source code interactively.
243
244 See the parent docstring for details.
245 """
246
247 # if the source is a string, chop it up in lines so we can iterate
248 # over it just as if it were an open file.
249 if not isinstance(source,file):
250 source = source.splitlines(True)
251
252
253 for line in source:
254 pass
255 # finish by calling the parent run_source method
256 super(DocTestRunner,self).run_source(dsource,interact)
257
258
259
235 260 class SAGERunner(InteractiveRunner):
236 261 """Interactive SAGE runner.
237 262
238 263 WARNING: this runner only works if you manually configure your SAGE copy
239 264 to use 'colors NoColor' in the ipythonrc config file, since currently the
240 265 prompt matching regexp does not identify color sequences."""
241 266
242 267 def __init__(self,program='sage',args=None):
243 268 """New runner, optionally passing the sage command to use."""
244 269
245 270 prompts = ['sage: ',r'\s*\.\.\. ']
246 271 InteractiveRunner.__init__(self,program,prompts,args)
247 272
248 273 # Global usage string, to avoid indentation issues if typed in a function def.
249 274 MAIN_USAGE = """
250 275 %prog [options] file_to_run
251 276
252 277 This is an interface to the various interactive runners available in this
253 278 module. If you want to pass specific options to one of the runners, you need
254 279 to first terminate the main options with a '--', and then provide the runner's
255 280 options. For example:
256 281
257 282 irunner.py --python -- --help
258 283
259 284 will pass --help to the python runner. Similarly,
260 285
261 286 irunner.py --ipython -- --interact script.ipy
262 287
263 288 will run the script.ipy file under the IPython runner, and then will start to
264 289 interact with IPython at the end of the script (instead of exiting).
265 290
266 291 The already implemented runners are listed below; adding one for a new program
267 292 is a trivial task, see the source for examples.
268 293
269 294 WARNING: the SAGE runner only works if you manually configure your SAGE copy
270 295 to use 'colors NoColor' in the ipythonrc config file, since currently the
271 296 prompt matching regexp does not identify color sequences.
272 297 """
273 298
274 299 def main():
275 300 """Run as a command-line script."""
276 301
277 302 parser = optparse.OptionParser(usage=MAIN_USAGE)
278 303 newopt = parser.add_option
279 304 parser.set_defaults(mode='ipython')
280 305 newopt('--ipython',action='store_const',dest='mode',const='ipython',
281 306 help='IPython interactive runner (default).')
282 307 newopt('--python',action='store_const',dest='mode',const='python',
283 308 help='Python interactive runner.')
284 309 newopt('--sage',action='store_const',dest='mode',const='sage',
285 310 help='SAGE interactive runner.')
286 311
287 312 opts,args = parser.parse_args()
288 313 runners = dict(ipython=IPythonRunner,
289 314 python=PythonRunner,
290 315 sage=SAGERunner)
291 316 runners[opts.mode]().main(args)
292 317
293 318 if __name__ == '__main__':
294 319 main()
@@ -1,883 +1,883 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 ultraTB.py -- Spice up your tracebacks!
4 4
5 5 * ColorTB
6 6 I've always found it a bit hard to visually parse tracebacks in Python. The
7 7 ColorTB class is a solution to that problem. It colors the different parts of a
8 8 traceback in a manner similar to what you would expect from a syntax-highlighting
9 9 text editor.
10 10
11 11 Installation instructions for ColorTB:
12 12 import sys,ultraTB
13 13 sys.excepthook = ultraTB.ColorTB()
14 14
15 15 * VerboseTB
16 16 I've also included a port of Ka-Ping Yee's "cgitb.py" that produces all kinds
17 17 of useful info when a traceback occurs. Ping originally had it spit out HTML
18 18 and intended it for CGI programmers, but why should they have all the fun? I
19 19 altered it to spit out colored text to the terminal. It's a bit overwhelming,
20 20 but kind of neat, and maybe useful for long-running programs that you believe
21 21 are bug-free. If a crash *does* occur in that type of program you want details.
22 22 Give it a shot--you'll love it or you'll hate it.
23 23
24 24 Note:
25 25
26 26 The Verbose mode prints the variables currently visible where the exception
27 27 happened (shortening their strings if too long). This can potentially be
28 28 very slow, if you happen to have a huge data structure whose string
29 29 representation is complex to compute. Your computer may appear to freeze for
30 30 a while with cpu usage at 100%. If this occurs, you can cancel the traceback
31 31 with Ctrl-C (maybe hitting it more than once).
32 32
33 33 If you encounter this kind of situation often, you may want to use the
34 34 Verbose_novars mode instead of the regular Verbose, which avoids formatting
35 35 variables (but otherwise includes the information and context given by
36 36 Verbose).
37 37
38 38
39 39 Installation instructions for ColorTB:
40 40 import sys,ultraTB
41 41 sys.excepthook = ultraTB.VerboseTB()
42 42
43 43 Note: Much of the code in this module was lifted verbatim from the standard
44 44 library module 'traceback.py' and Ka-Ping Yee's 'cgitb.py'.
45 45
46 46 * Color schemes
47 47 The colors are defined in the class TBTools through the use of the
48 48 ColorSchemeTable class. Currently the following exist:
49 49
50 50 - NoColor: allows all of this module to be used in any terminal (the color
51 51 escapes are just dummy blank strings).
52 52
53 53 - Linux: is meant to look good in a terminal like the Linux console (black
54 54 or very dark background).
55 55
56 56 - LightBG: similar to Linux but swaps dark/light colors to be more readable
57 57 in light background terminals.
58 58
59 59 You can implement other color schemes easily, the syntax is fairly
60 60 self-explanatory. Please send back new schemes you develop to the author for
61 61 possible inclusion in future releases.
62 62
63 $Id: ultraTB.py 1154 2006-02-11 23:20:05Z fperez $"""
63 $Id: ultraTB.py 1786 2006-09-27 05:47:28Z fperez $"""
64 64
65 65 #*****************************************************************************
66 66 # Copyright (C) 2001 Nathaniel Gray <n8gray@caltech.edu>
67 67 # Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
68 68 #
69 69 # Distributed under the terms of the BSD License. The full license is in
70 70 # the file COPYING, distributed as part of this software.
71 71 #*****************************************************************************
72 72
73 73 from IPython import Release
74 74 __author__ = '%s <%s>\n%s <%s>' % (Release.authors['Nathan']+
75 75 Release.authors['Fernando'])
76 76 __license__ = Release.license
77 77
78 78 # Required modules
79 79 import inspect
80 80 import keyword
81 81 import linecache
82 82 import os
83 83 import pydoc
84 84 import string
85 85 import sys
86 86 import time
87 87 import tokenize
88 88 import traceback
89 89 import types
90 90
91 91 # IPython's own modules
92 92 # Modified pdb which doesn't damage IPython's readline handling
93 93 from IPython import Debugger
94 94 from IPython.ipstruct import Struct
95 95 from IPython.excolors import ExceptionColors
96 96 from IPython.genutils import Term,uniq_stable,error,info
97 97
98 98 # Globals
99 99 # amount of space to put line numbers before verbose tracebacks
100 100 INDENT_SIZE = 8
101 101
102 102 #---------------------------------------------------------------------------
103 103 # Code begins
104 104
105 105 # Utility functions
106 106 def inspect_error():
107 107 """Print a message about internal inspect errors.
108 108
109 109 These are unfortunately quite common."""
110 110
111 111 error('Internal Python error in the inspect module.\n'
112 112 'Below is the traceback from this internal error.\n')
113 113
114 114 def _fixed_getinnerframes(etb, context=1,tb_offset=0):
115 115 import linecache
116 116 LNUM_POS, LINES_POS, INDEX_POS = 2, 4, 5
117 117
118 118 records = inspect.getinnerframes(etb, context)
119 119
120 120 # If the error is at the console, don't build any context, since it would
121 121 # otherwise produce 5 blank lines printed out (there is no file at the
122 122 # console)
123 123 rec_check = records[tb_offset:]
124 124 try:
125 125 rname = rec_check[0][1]
126 126 if rname == '<ipython console>' or rname.endswith('<string>'):
127 127 return rec_check
128 128 except IndexError:
129 129 pass
130 130
131 131 aux = traceback.extract_tb(etb)
132 132 assert len(records) == len(aux)
133 133 for i, (file, lnum, _, _) in zip(range(len(records)), aux):
134 134 maybeStart = lnum-1 - context//2
135 135 start = max(maybeStart, 0)
136 136 end = start + context
137 137 lines = linecache.getlines(file)[start:end]
138 138 # pad with empty lines if necessary
139 139 if maybeStart < 0:
140 140 lines = (['\n'] * -maybeStart) + lines
141 141 if len(lines) < context:
142 142 lines += ['\n'] * (context - len(lines))
143 143 buf = list(records[i])
144 144 buf[LNUM_POS] = lnum
145 145 buf[INDEX_POS] = lnum - 1 - start
146 146 buf[LINES_POS] = lines
147 147 records[i] = tuple(buf)
148 148 return records[tb_offset:]
149 149
150 150 # Helper function -- largely belongs to VerboseTB, but we need the same
151 151 # functionality to produce a pseudo verbose TB for SyntaxErrors, so that they
152 152 # can be recognized properly by ipython.el's py-traceback-line-re
153 153 # (SyntaxErrors have to be treated specially because they have no traceback)
154 154 def _formatTracebackLines(lnum, index, lines, Colors, lvals=None):
155 155 numbers_width = INDENT_SIZE - 1
156 156 res = []
157 157 i = lnum - index
158 158 for line in lines:
159 159 if i == lnum:
160 160 # This is the line with the error
161 161 pad = numbers_width - len(str(i))
162 162 if pad >= 3:
163 163 marker = '-'*(pad-3) + '-> '
164 164 elif pad == 2:
165 165 marker = '> '
166 166 elif pad == 1:
167 167 marker = '>'
168 168 else:
169 169 marker = ''
170 170 num = marker + str(i)
171 171 line = '%s%s%s %s%s' %(Colors.linenoEm, num,
172 172 Colors.line, line, Colors.Normal)
173 173 else:
174 174 num = '%*s' % (numbers_width,i)
175 175 line = '%s%s%s %s' %(Colors.lineno, num,
176 176 Colors.Normal, line)
177 177
178 178 res.append(line)
179 179 if lvals and i == lnum:
180 180 res.append(lvals + '\n')
181 181 i = i + 1
182 182 return res
183 183
184 184 #---------------------------------------------------------------------------
185 185 # Module classes
186 186 class TBTools:
187 187 """Basic tools used by all traceback printer classes."""
188 188
189 189 def __init__(self,color_scheme = 'NoColor',call_pdb=False):
190 190 # Whether to call the interactive pdb debugger after printing
191 191 # tracebacks or not
192 192 self.call_pdb = call_pdb
193 193
194 194 # Create color table
195 195 self.color_scheme_table = ExceptionColors
196 196
197 197 self.set_colors(color_scheme)
198 198 self.old_scheme = color_scheme # save initial value for toggles
199 199
200 200 if call_pdb:
201 201 self.pdb = Debugger.Pdb(self.color_scheme_table.active_scheme_name)
202 202 else:
203 203 self.pdb = None
204 204
205 205 def set_colors(self,*args,**kw):
206 206 """Shorthand access to the color table scheme selector method."""
207 207
208 208 self.color_scheme_table.set_active_scheme(*args,**kw)
209 209 # for convenience, set Colors to the active scheme
210 210 self.Colors = self.color_scheme_table.active_colors
211 211
212 212 def color_toggle(self):
213 213 """Toggle between the currently active color scheme and NoColor."""
214 214
215 215 if self.color_scheme_table.active_scheme_name == 'NoColor':
216 216 self.color_scheme_table.set_active_scheme(self.old_scheme)
217 217 self.Colors = self.color_scheme_table.active_colors
218 218 else:
219 219 self.old_scheme = self.color_scheme_table.active_scheme_name
220 220 self.color_scheme_table.set_active_scheme('NoColor')
221 221 self.Colors = self.color_scheme_table.active_colors
222 222
223 223 #---------------------------------------------------------------------------
224 224 class ListTB(TBTools):
225 225 """Print traceback information from a traceback list, with optional color.
226 226
227 227 Calling: requires 3 arguments:
228 228 (etype, evalue, elist)
229 229 as would be obtained by:
230 230 etype, evalue, tb = sys.exc_info()
231 231 if tb:
232 232 elist = traceback.extract_tb(tb)
233 233 else:
234 234 elist = None
235 235
236 236 It can thus be used by programs which need to process the traceback before
237 237 printing (such as console replacements based on the code module from the
238 238 standard library).
239 239
240 240 Because they are meant to be called without a full traceback (only a
241 241 list), instances of this class can't call the interactive pdb debugger."""
242 242
243 243 def __init__(self,color_scheme = 'NoColor'):
244 244 TBTools.__init__(self,color_scheme = color_scheme,call_pdb=0)
245 245
246 246 def __call__(self, etype, value, elist):
247 247 print >> Term.cerr, self.text(etype,value,elist)
248 248
249 249 def text(self,etype, value, elist,context=5):
250 250 """Return a color formatted string with the traceback info."""
251 251
252 252 Colors = self.Colors
253 253 out_string = ['%s%s%s\n' % (Colors.topline,'-'*60,Colors.Normal)]
254 254 if elist:
255 255 out_string.append('Traceback %s(most recent call last)%s:' % \
256 256 (Colors.normalEm, Colors.Normal) + '\n')
257 257 out_string.extend(self._format_list(elist))
258 258 lines = self._format_exception_only(etype, value)
259 259 for line in lines[:-1]:
260 260 out_string.append(" "+line)
261 261 out_string.append(lines[-1])
262 262 return ''.join(out_string)
263 263
264 264 def _format_list(self, extracted_list):
265 265 """Format a list of traceback entry tuples for printing.
266 266
267 267 Given a list of tuples as returned by extract_tb() or
268 268 extract_stack(), return a list of strings ready for printing.
269 269 Each string in the resulting list corresponds to the item with the
270 270 same index in the argument list. Each string ends in a newline;
271 271 the strings may contain internal newlines as well, for those items
272 272 whose source text line is not None.
273 273
274 274 Lifted almost verbatim from traceback.py
275 275 """
276 276
277 277 Colors = self.Colors
278 278 list = []
279 279 for filename, lineno, name, line in extracted_list[:-1]:
280 280 item = ' File %s"%s"%s, line %s%d%s, in %s%s%s\n' % \
281 281 (Colors.filename, filename, Colors.Normal,
282 282 Colors.lineno, lineno, Colors.Normal,
283 283 Colors.name, name, Colors.Normal)
284 284 if line:
285 285 item = item + ' %s\n' % line.strip()
286 286 list.append(item)
287 287 # Emphasize the last entry
288 288 filename, lineno, name, line = extracted_list[-1]
289 289 item = '%s File %s"%s"%s, line %s%d%s, in %s%s%s%s\n' % \
290 290 (Colors.normalEm,
291 291 Colors.filenameEm, filename, Colors.normalEm,
292 292 Colors.linenoEm, lineno, Colors.normalEm,
293 293 Colors.nameEm, name, Colors.normalEm,
294 294 Colors.Normal)
295 295 if line:
296 296 item = item + '%s %s%s\n' % (Colors.line, line.strip(),
297 297 Colors.Normal)
298 298 list.append(item)
299 299 return list
300 300
301 301 def _format_exception_only(self, etype, value):
302 302 """Format the exception part of a traceback.
303 303
304 304 The arguments are the exception type and value such as given by
305 305 sys.exc_info()[:2]. The return value is a list of strings, each ending
306 306 in a newline. Normally, the list contains a single string; however,
307 307 for SyntaxError exceptions, it contains several lines that (when
308 308 printed) display detailed information about where the syntax error
309 309 occurred. The message indicating which exception occurred is the
310 310 always last string in the list.
311 311
312 312 Also lifted nearly verbatim from traceback.py
313 313 """
314 314
315 315 Colors = self.Colors
316 316 list = []
317 317 if type(etype) == types.ClassType:
318 318 stype = Colors.excName + etype.__name__ + Colors.Normal
319 319 else:
320 320 stype = etype # String exceptions don't get special coloring
321 321 if value is None:
322 322 list.append( str(stype) + '\n')
323 323 else:
324 324 if etype is SyntaxError:
325 325 try:
326 326 msg, (filename, lineno, offset, line) = value
327 327 except:
328 328 pass
329 329 else:
330 330 #print 'filename is',filename # dbg
331 331 if not filename: filename = "<string>"
332 332 list.append('%s File %s"%s"%s, line %s%d%s\n' % \
333 333 (Colors.normalEm,
334 334 Colors.filenameEm, filename, Colors.normalEm,
335 335 Colors.linenoEm, lineno, Colors.Normal ))
336 336 if line is not None:
337 337 i = 0
338 338 while i < len(line) and line[i].isspace():
339 339 i = i+1
340 340 list.append('%s %s%s\n' % (Colors.line,
341 341 line.strip(),
342 342 Colors.Normal))
343 343 if offset is not None:
344 344 s = ' '
345 345 for c in line[i:offset-1]:
346 346 if c.isspace():
347 347 s = s + c
348 348 else:
349 349 s = s + ' '
350 350 list.append('%s%s^%s\n' % (Colors.caret, s,
351 351 Colors.Normal) )
352 352 value = msg
353 353 s = self._some_str(value)
354 354 if s:
355 355 list.append('%s%s:%s %s\n' % (str(stype), Colors.excName,
356 356 Colors.Normal, s))
357 357 else:
358 358 list.append('%s\n' % str(stype))
359 359 return list
360 360
361 361 def _some_str(self, value):
362 362 # Lifted from traceback.py
363 363 try:
364 364 return str(value)
365 365 except:
366 366 return '<unprintable %s object>' % type(value).__name__
367 367
368 368 #----------------------------------------------------------------------------
369 369 class VerboseTB(TBTools):
370 370 """A port of Ka-Ping Yee's cgitb.py module that outputs color text instead
371 371 of HTML. Requires inspect and pydoc. Crazy, man.
372 372
373 373 Modified version which optionally strips the topmost entries from the
374 374 traceback, to be used with alternate interpreters (because their own code
375 375 would appear in the traceback)."""
376 376
377 377 def __init__(self,color_scheme = 'Linux',tb_offset=0,long_header=0,
378 378 call_pdb = 0, include_vars=1):
379 379 """Specify traceback offset, headers and color scheme.
380 380
381 381 Define how many frames to drop from the tracebacks. Calling it with
382 382 tb_offset=1 allows use of this handler in interpreters which will have
383 383 their own code at the top of the traceback (VerboseTB will first
384 384 remove that frame before printing the traceback info)."""
385 385 TBTools.__init__(self,color_scheme=color_scheme,call_pdb=call_pdb)
386 386 self.tb_offset = tb_offset
387 387 self.long_header = long_header
388 388 self.include_vars = include_vars
389 389
390 390 def text(self, etype, evalue, etb, context=5):
391 391 """Return a nice text document describing the traceback."""
392 392
393 393 # some locals
394 394 Colors = self.Colors # just a shorthand + quicker name lookup
395 395 ColorsNormal = Colors.Normal # used a lot
396 396 indent = ' '*INDENT_SIZE
397 397 exc = '%s%s%s' % (Colors.excName, str(etype), ColorsNormal)
398 398 em_normal = '%s\n%s%s' % (Colors.valEm, indent,ColorsNormal)
399 399 undefined = '%sundefined%s' % (Colors.em, ColorsNormal)
400 400
401 401 # some internal-use functions
402 402 def text_repr(value):
403 403 """Hopefully pretty robust repr equivalent."""
404 404 # this is pretty horrible but should always return *something*
405 405 try:
406 406 return pydoc.text.repr(value)
407 407 except KeyboardInterrupt:
408 408 raise
409 409 except:
410 410 try:
411 411 return repr(value)
412 412 except KeyboardInterrupt:
413 413 raise
414 414 except:
415 415 try:
416 416 # all still in an except block so we catch
417 417 # getattr raising
418 418 name = getattr(value, '__name__', None)
419 419 if name:
420 420 # ick, recursion
421 421 return text_repr(name)
422 422 klass = getattr(value, '__class__', None)
423 423 if klass:
424 424 return '%s instance' % text_repr(klass)
425 425 except KeyboardInterrupt:
426 426 raise
427 427 except:
428 428 return 'UNRECOVERABLE REPR FAILURE'
429 429 def eqrepr(value, repr=text_repr): return '=%s' % repr(value)
430 430 def nullrepr(value, repr=text_repr): return ''
431 431
432 432 # meat of the code begins
433 433 if type(etype) is types.ClassType:
434 434 etype = etype.__name__
435 435
436 436 if self.long_header:
437 437 # Header with the exception type, python version, and date
438 438 pyver = 'Python ' + string.split(sys.version)[0] + ': ' + sys.executable
439 439 date = time.ctime(time.time())
440 440
441 441 head = '%s%s%s\n%s%s%s\n%s' % (Colors.topline, '-'*75, ColorsNormal,
442 442 exc, ' '*(75-len(str(etype))-len(pyver)),
443 443 pyver, string.rjust(date, 75) )
444 444 head += "\nA problem occured executing Python code. Here is the sequence of function"\
445 445 "\ncalls leading up to the error, with the most recent (innermost) call last."
446 446 else:
447 447 # Simplified header
448 448 head = '%s%s%s\n%s%s' % (Colors.topline, '-'*75, ColorsNormal,exc,
449 449 string.rjust('Traceback (most recent call last)',
450 450 75 - len(str(etype)) ) )
451 451 frames = []
452 452 # Flush cache before calling inspect. This helps alleviate some of the
453 453 # problems with python 2.3's inspect.py.
454 454 linecache.checkcache()
455 455 # Drop topmost frames if requested
456 456 try:
457 457 # Try the default getinnerframes and Alex's: Alex's fixes some
458 458 # problems, but it generates empty tracebacks for console errors
459 459 # (5 blanks lines) where none should be returned.
460 460 #records = inspect.getinnerframes(etb, context)[self.tb_offset:]
461 461 #print 'python records:', records # dbg
462 462 records = _fixed_getinnerframes(etb, context,self.tb_offset)
463 463 #print 'alex records:', records # dbg
464 464 except:
465 465
466 466 # FIXME: I've been getting many crash reports from python 2.3
467 467 # users, traceable to inspect.py. If I can find a small test-case
468 468 # to reproduce this, I should either write a better workaround or
469 469 # file a bug report against inspect (if that's the real problem).
470 470 # So far, I haven't been able to find an isolated example to
471 471 # reproduce the problem.
472 472 inspect_error()
473 473 traceback.print_exc(file=Term.cerr)
474 474 info('\nUnfortunately, your original traceback can not be constructed.\n')
475 475 return ''
476 476
477 477 # build some color string templates outside these nested loops
478 478 tpl_link = '%s%%s%s' % (Colors.filenameEm,ColorsNormal)
479 479 tpl_call = 'in %s%%s%s%%s%s' % (Colors.vName, Colors.valEm,
480 480 ColorsNormal)
481 481 tpl_call_fail = 'in %s%%s%s(***failed resolving arguments***)%s' % \
482 482 (Colors.vName, Colors.valEm, ColorsNormal)
483 483 tpl_local_var = '%s%%s%s' % (Colors.vName, ColorsNormal)
484 484 tpl_global_var = '%sglobal%s %s%%s%s' % (Colors.em, ColorsNormal,
485 485 Colors.vName, ColorsNormal)
486 486 tpl_name_val = '%%s %s= %%s%s' % (Colors.valEm, ColorsNormal)
487 487 tpl_line = '%s%%s%s %%s' % (Colors.lineno, ColorsNormal)
488 488 tpl_line_em = '%s%%s%s %%s%s' % (Colors.linenoEm,Colors.line,
489 489 ColorsNormal)
490 490
491 491 # now, loop over all records printing context and info
492 492 abspath = os.path.abspath
493 493 for frame, file, lnum, func, lines, index in records:
494 494 #print '*** record:',file,lnum,func,lines,index # dbg
495 495 try:
496 496 file = file and abspath(file) or '?'
497 497 except OSError:
498 498 # if file is '<console>' or something not in the filesystem,
499 499 # the abspath call will throw an OSError. Just ignore it and
500 500 # keep the original file string.
501 501 pass
502 502 link = tpl_link % file
503 503 try:
504 504 args, varargs, varkw, locals = inspect.getargvalues(frame)
505 505 except:
506 506 # This can happen due to a bug in python2.3. We should be
507 507 # able to remove this try/except when 2.4 becomes a
508 508 # requirement. Bug details at http://python.org/sf/1005466
509 509 inspect_error()
510 510 traceback.print_exc(file=Term.cerr)
511 511 info("\nIPython's exception reporting continues...\n")
512 512
513 513 if func == '?':
514 514 call = ''
515 515 else:
516 516 # Decide whether to include variable details or not
517 517 var_repr = self.include_vars and eqrepr or nullrepr
518 518 try:
519 519 call = tpl_call % (func,inspect.formatargvalues(args,
520 520 varargs, varkw,
521 521 locals,formatvalue=var_repr))
522 522 except KeyError:
523 523 # Very odd crash from inspect.formatargvalues(). The
524 524 # scenario under which it appeared was a call to
525 525 # view(array,scale) in NumTut.view.view(), where scale had
526 526 # been defined as a scalar (it should be a tuple). Somehow
527 527 # inspect messes up resolving the argument list of view()
528 528 # and barfs out. At some point I should dig into this one
529 529 # and file a bug report about it.
530 530 inspect_error()
531 531 traceback.print_exc(file=Term.cerr)
532 532 info("\nIPython's exception reporting continues...\n")
533 533 call = tpl_call_fail % func
534 534
535 535 # Initialize a list of names on the current line, which the
536 536 # tokenizer below will populate.
537 537 names = []
538 538
539 539 def tokeneater(token_type, token, start, end, line):
540 540 """Stateful tokeneater which builds dotted names.
541 541
542 542 The list of names it appends to (from the enclosing scope) can
543 543 contain repeated composite names. This is unavoidable, since
544 544 there is no way to disambguate partial dotted structures until
545 545 the full list is known. The caller is responsible for pruning
546 546 the final list of duplicates before using it."""
547 547
548 548 # build composite names
549 549 if token == '.':
550 550 try:
551 551 names[-1] += '.'
552 552 # store state so the next token is added for x.y.z names
553 553 tokeneater.name_cont = True
554 554 return
555 555 except IndexError:
556 556 pass
557 557 if token_type == tokenize.NAME and token not in keyword.kwlist:
558 558 if tokeneater.name_cont:
559 559 # Dotted names
560 560 names[-1] += token
561 561 tokeneater.name_cont = False
562 562 else:
563 563 # Regular new names. We append everything, the caller
564 564 # will be responsible for pruning the list later. It's
565 565 # very tricky to try to prune as we go, b/c composite
566 566 # names can fool us. The pruning at the end is easy
567 567 # to do (or the caller can print a list with repeated
568 568 # names if so desired.
569 569 names.append(token)
570 570 elif token_type == tokenize.NEWLINE:
571 571 raise IndexError
572 572 # we need to store a bit of state in the tokenizer to build
573 573 # dotted names
574 574 tokeneater.name_cont = False
575 575
576 576 def linereader(file=file, lnum=[lnum], getline=linecache.getline):
577 577 line = getline(file, lnum[0])
578 578 lnum[0] += 1
579 579 return line
580 580
581 581 # Build the list of names on this line of code where the exception
582 582 # occurred.
583 583 try:
584 584 # This builds the names list in-place by capturing it from the
585 585 # enclosing scope.
586 586 tokenize.tokenize(linereader, tokeneater)
587 587 except IndexError:
588 588 # signals exit of tokenizer
589 589 pass
590 590 except tokenize.TokenError,msg:
591 591 _m = ("An unexpected error occurred while tokenizing input\n"
592 592 "The following traceback may be corrupted or invalid\n"
593 593 "The error message is: %s\n" % msg)
594 594 error(_m)
595 595
596 596 # prune names list of duplicates, but keep the right order
597 597 unique_names = uniq_stable(names)
598 598
599 599 # Start loop over vars
600 600 lvals = []
601 601 if self.include_vars:
602 602 for name_full in unique_names:
603 603 name_base = name_full.split('.',1)[0]
604 604 if name_base in frame.f_code.co_varnames:
605 605 if locals.has_key(name_base):
606 606 try:
607 607 value = repr(eval(name_full,locals))
608 608 except:
609 609 value = undefined
610 610 else:
611 611 value = undefined
612 612 name = tpl_local_var % name_full
613 613 else:
614 614 if frame.f_globals.has_key(name_base):
615 615 try:
616 616 value = repr(eval(name_full,frame.f_globals))
617 617 except:
618 618 value = undefined
619 619 else:
620 620 value = undefined
621 621 name = tpl_global_var % name_full
622 622 lvals.append(tpl_name_val % (name,value))
623 623 if lvals:
624 624 lvals = '%s%s' % (indent,em_normal.join(lvals))
625 625 else:
626 626 lvals = ''
627 627
628 628 level = '%s %s\n' % (link,call)
629 629
630 630 if index is None:
631 631 frames.append(level)
632 632 else:
633 633 frames.append('%s%s' % (level,''.join(
634 634 _formatTracebackLines(lnum,index,lines,self.Colors,lvals))))
635 635
636 636 # Get (safely) a string form of the exception info
637 637 try:
638 638 etype_str,evalue_str = map(str,(etype,evalue))
639 639 except:
640 640 # User exception is improperly defined.
641 641 etype,evalue = str,sys.exc_info()[:2]
642 642 etype_str,evalue_str = map(str,(etype,evalue))
643 643 # ... and format it
644 644 exception = ['%s%s%s: %s' % (Colors.excName, etype_str,
645 645 ColorsNormal, evalue_str)]
646 646 if type(evalue) is types.InstanceType:
647 647 try:
648 648 names = [w for w in dir(evalue) if isinstance(w, basestring)]
649 649 except:
650 650 # Every now and then, an object with funny inernals blows up
651 651 # when dir() is called on it. We do the best we can to report
652 652 # the problem and continue
653 653 _m = '%sException reporting error (object with broken dir())%s:'
654 654 exception.append(_m % (Colors.excName,ColorsNormal))
655 655 etype_str,evalue_str = map(str,sys.exc_info()[:2])
656 656 exception.append('%s%s%s: %s' % (Colors.excName,etype_str,
657 657 ColorsNormal, evalue_str))
658 658 names = []
659 659 for name in names:
660 660 value = text_repr(getattr(evalue, name))
661 661 exception.append('\n%s%s = %s' % (indent, name, value))
662 662 # return all our info assembled as a single string
663 663 return '%s\n\n%s\n%s' % (head,'\n'.join(frames),''.join(exception[0]) )
664 664
665 665 def debugger(self):
666 666 """Call up the pdb debugger if desired, always clean up the tb reference.
667 667
668 668 If the call_pdb flag is set, the pdb interactive debugger is
669 669 invoked. In all cases, the self.tb reference to the current traceback
670 670 is deleted to prevent lingering references which hamper memory
671 671 management.
672 672
673 673 Note that each call to pdb() does an 'import readline', so if your app
674 674 requires a special setup for the readline completers, you'll have to
675 675 fix that by hand after invoking the exception handler."""
676 676
677 677 if self.call_pdb:
678 678 if self.pdb is None:
679 679 self.pdb = Debugger.Pdb(
680 680 self.color_scheme_table.active_scheme_name)
681 681 # the system displayhook may have changed, restore the original
682 682 # for pdb
683 683 dhook = sys.displayhook
684 684 sys.displayhook = sys.__displayhook__
685 685 self.pdb.reset()
686 686 # Find the right frame so we don't pop up inside ipython itself
687 687 etb = self.tb
688 688 while self.tb.tb_next is not None:
689 689 self.tb = self.tb.tb_next
690 690 try:
691 691 if etb and etb.tb_next:
692 692 etb = etb.tb_next
693 693 self.pdb.botframe = etb.tb_frame
694 694 self.pdb.interaction(self.tb.tb_frame, self.tb)
695 except:
695 except 'ha': # dbg
696 696 print '*** ERROR ***'
697 697 print 'This version of pdb has a bug and crashed.'
698 698 print 'Returning to IPython...'
699 699 sys.displayhook = dhook
700 700 del self.tb
701 701
702 702 def handler(self, info=None):
703 703 (etype, evalue, etb) = info or sys.exc_info()
704 704 self.tb = etb
705 705 print >> Term.cerr, self.text(etype, evalue, etb)
706 706
707 707 # Changed so an instance can just be called as VerboseTB_inst() and print
708 708 # out the right info on its own.
709 709 def __call__(self, etype=None, evalue=None, etb=None):
710 710 """This hook can replace sys.excepthook (for Python 2.1 or higher)."""
711 711 if etb is None:
712 712 self.handler()
713 713 else:
714 714 self.handler((etype, evalue, etb))
715 715 self.debugger()
716 716
717 717 #----------------------------------------------------------------------------
718 718 class FormattedTB(VerboseTB,ListTB):
719 719 """Subclass ListTB but allow calling with a traceback.
720 720
721 721 It can thus be used as a sys.excepthook for Python > 2.1.
722 722
723 723 Also adds 'Context' and 'Verbose' modes, not available in ListTB.
724 724
725 725 Allows a tb_offset to be specified. This is useful for situations where
726 726 one needs to remove a number of topmost frames from the traceback (such as
727 727 occurs with python programs that themselves execute other python code,
728 728 like Python shells). """
729 729
730 730 def __init__(self, mode = 'Plain', color_scheme='Linux',
731 731 tb_offset = 0,long_header=0,call_pdb=0,include_vars=0):
732 732
733 733 # NEVER change the order of this list. Put new modes at the end:
734 734 self.valid_modes = ['Plain','Context','Verbose']
735 735 self.verbose_modes = self.valid_modes[1:3]
736 736
737 737 VerboseTB.__init__(self,color_scheme,tb_offset,long_header,
738 738 call_pdb=call_pdb,include_vars=include_vars)
739 739 self.set_mode(mode)
740 740
741 741 def _extract_tb(self,tb):
742 742 if tb:
743 743 return traceback.extract_tb(tb)
744 744 else:
745 745 return None
746 746
747 747 def text(self, etype, value, tb,context=5,mode=None):
748 748 """Return formatted traceback.
749 749
750 750 If the optional mode parameter is given, it overrides the current
751 751 mode."""
752 752
753 753 if mode is None:
754 754 mode = self.mode
755 755 if mode in self.verbose_modes:
756 756 # verbose modes need a full traceback
757 757 return VerboseTB.text(self,etype, value, tb,context=5)
758 758 else:
759 759 # We must check the source cache because otherwise we can print
760 760 # out-of-date source code.
761 761 linecache.checkcache()
762 762 # Now we can extract and format the exception
763 763 elist = self._extract_tb(tb)
764 764 if len(elist) > self.tb_offset:
765 765 del elist[:self.tb_offset]
766 766 return ListTB.text(self,etype,value,elist)
767 767
768 768 def set_mode(self,mode=None):
769 769 """Switch to the desired mode.
770 770
771 771 If mode is not specified, cycles through the available modes."""
772 772
773 773 if not mode:
774 774 new_idx = ( self.valid_modes.index(self.mode) + 1 ) % \
775 775 len(self.valid_modes)
776 776 self.mode = self.valid_modes[new_idx]
777 777 elif mode not in self.valid_modes:
778 778 raise ValueError, 'Unrecognized mode in FormattedTB: <'+mode+'>\n'\
779 779 'Valid modes: '+str(self.valid_modes)
780 780 else:
781 781 self.mode = mode
782 782 # include variable details only in 'Verbose' mode
783 783 self.include_vars = (self.mode == self.valid_modes[2])
784 784
785 785 # some convenient shorcuts
786 786 def plain(self):
787 787 self.set_mode(self.valid_modes[0])
788 788
789 789 def context(self):
790 790 self.set_mode(self.valid_modes[1])
791 791
792 792 def verbose(self):
793 793 self.set_mode(self.valid_modes[2])
794 794
795 795 #----------------------------------------------------------------------------
796 796 class AutoFormattedTB(FormattedTB):
797 797 """A traceback printer which can be called on the fly.
798 798
799 799 It will find out about exceptions by itself.
800 800
801 801 A brief example:
802 802
803 803 AutoTB = AutoFormattedTB(mode = 'Verbose',color_scheme='Linux')
804 804 try:
805 805 ...
806 806 except:
807 807 AutoTB() # or AutoTB(out=logfile) where logfile is an open file object
808 808 """
809 809 def __call__(self,etype=None,evalue=None,etb=None,
810 810 out=None,tb_offset=None):
811 811 """Print out a formatted exception traceback.
812 812
813 813 Optional arguments:
814 814 - out: an open file-like object to direct output to.
815 815
816 816 - tb_offset: the number of frames to skip over in the stack, on a
817 817 per-call basis (this overrides temporarily the instance's tb_offset
818 818 given at initialization time. """
819 819
820 820 if out is None:
821 821 out = Term.cerr
822 822 if tb_offset is not None:
823 823 tb_offset, self.tb_offset = self.tb_offset, tb_offset
824 824 print >> out, self.text(etype, evalue, etb)
825 825 self.tb_offset = tb_offset
826 826 else:
827 827 print >> out, self.text(etype, evalue, etb)
828 828 self.debugger()
829 829
830 830 def text(self,etype=None,value=None,tb=None,context=5,mode=None):
831 831 if etype is None:
832 832 etype,value,tb = sys.exc_info()
833 833 self.tb = tb
834 834 return FormattedTB.text(self,etype,value,tb,context=5,mode=mode)
835 835
836 836 #---------------------------------------------------------------------------
837 837 # A simple class to preserve Nathan's original functionality.
838 838 class ColorTB(FormattedTB):
839 839 """Shorthand to initialize a FormattedTB in Linux colors mode."""
840 840 def __init__(self,color_scheme='Linux',call_pdb=0):
841 841 FormattedTB.__init__(self,color_scheme=color_scheme,
842 842 call_pdb=call_pdb)
843 843
844 844 #----------------------------------------------------------------------------
845 845 # module testing (minimal)
846 846 if __name__ == "__main__":
847 847 def spam(c, (d, e)):
848 848 x = c + d
849 849 y = c * d
850 850 foo(x, y)
851 851
852 852 def foo(a, b, bar=1):
853 853 eggs(a, b + bar)
854 854
855 855 def eggs(f, g, z=globals()):
856 856 h = f + g
857 857 i = f - g
858 858 return h / i
859 859
860 860 print ''
861 861 print '*** Before ***'
862 862 try:
863 863 print spam(1, (2, 3))
864 864 except:
865 865 traceback.print_exc()
866 866 print ''
867 867
868 868 handler = ColorTB()
869 869 print '*** ColorTB ***'
870 870 try:
871 871 print spam(1, (2, 3))
872 872 except:
873 873 apply(handler, sys.exc_info() )
874 874 print ''
875 875
876 876 handler = VerboseTB()
877 877 print '*** VerboseTB ***'
878 878 try:
879 879 print spam(1, (2, 3))
880 880 except:
881 881 apply(handler, sys.exc_info() )
882 882 print ''
883 883
General Comments 0
You need to be logged in to leave comments. Login now