##// END OF EJS Templates
check history length before attempting to access old members. Closes #189
vivainio -
Show More
@@ -1,2599 +1,2600 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 2914 2007-12-31 12:53:16Z vivainio $
9 $Id: iplib.py 2915 2007-12-31 13:05:11Z vivainio $
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 pydoc
51 51 import re
52 52 import shutil
53 53 import string
54 54 import sys
55 55 import tempfile
56 56 import traceback
57 57 import types
58 58 from sets import Set
59 59 from pprint import pprint, pformat
60 60
61 61 # IPython's own modules
62 62 #import IPython
63 63 from IPython import Debugger,OInspect,PyColorize,ultraTB
64 64 from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names
65 65 from IPython.Extensions import pickleshare
66 66 from IPython.FakeModule import FakeModule
67 67 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
68 68 from IPython.Logger import Logger
69 69 from IPython.Magic import Magic
70 70 from IPython.Prompts import CachedOutput
71 71 from IPython.ipstruct import Struct
72 72 from IPython.background_jobs import BackgroundJobManager
73 73 from IPython.usage import cmd_line_usage,interactive_usage
74 74 from IPython.genutils import *
75 75 from IPython.strdispatch import StrDispatch
76 76 import IPython.ipapi
77 77 import IPython.history
78 78 import IPython.prefilter as prefilter
79 79 import IPython.shadowns
80 80 # Globals
81 81
82 82 # store the builtin raw_input globally, and use this always, in case user code
83 83 # overwrites it (like wx.py.PyShell does)
84 84 raw_input_original = raw_input
85 85
86 86 # compiled regexps for autoindent management
87 87 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
88 88
89 89
90 90 #****************************************************************************
91 91 # Some utility function definitions
92 92
93 93 ini_spaces_re = re.compile(r'^(\s+)')
94 94
95 95 def num_ini_spaces(strng):
96 96 """Return the number of initial spaces in a string"""
97 97
98 98 ini_spaces = ini_spaces_re.match(strng)
99 99 if ini_spaces:
100 100 return ini_spaces.end()
101 101 else:
102 102 return 0
103 103
104 104 def softspace(file, newvalue):
105 105 """Copied from code.py, to remove the dependency"""
106 106
107 107 oldvalue = 0
108 108 try:
109 109 oldvalue = file.softspace
110 110 except AttributeError:
111 111 pass
112 112 try:
113 113 file.softspace = newvalue
114 114 except (AttributeError, TypeError):
115 115 # "attribute-less object" or "read-only attributes"
116 116 pass
117 117 return oldvalue
118 118
119 119
120 120 #****************************************************************************
121 121 # Local use exceptions
122 122 class SpaceInInput(exceptions.Exception): pass
123 123
124 124
125 125 #****************************************************************************
126 126 # Local use classes
127 127 class Bunch: pass
128 128
129 129 class Undefined: pass
130 130
131 131 class Quitter(object):
132 132 """Simple class to handle exit, similar to Python 2.5's.
133 133
134 134 It handles exiting in an ipython-safe manner, which the one in Python 2.5
135 135 doesn't do (obviously, since it doesn't know about ipython)."""
136 136
137 137 def __init__(self,shell,name):
138 138 self.shell = shell
139 139 self.name = name
140 140
141 141 def __repr__(self):
142 142 return 'Type %s() to exit.' % self.name
143 143 __str__ = __repr__
144 144
145 145 def __call__(self):
146 146 self.shell.exit()
147 147
148 148 class InputList(list):
149 149 """Class to store user input.
150 150
151 151 It's basically a list, but slices return a string instead of a list, thus
152 152 allowing things like (assuming 'In' is an instance):
153 153
154 154 exec In[4:7]
155 155
156 156 or
157 157
158 158 exec In[5:9] + In[14] + In[21:25]"""
159 159
160 160 def __getslice__(self,i,j):
161 161 return ''.join(list.__getslice__(self,i,j))
162 162
163 163 class SyntaxTB(ultraTB.ListTB):
164 164 """Extension which holds some state: the last exception value"""
165 165
166 166 def __init__(self,color_scheme = 'NoColor'):
167 167 ultraTB.ListTB.__init__(self,color_scheme)
168 168 self.last_syntax_error = None
169 169
170 170 def __call__(self, etype, value, elist):
171 171 self.last_syntax_error = value
172 172 ultraTB.ListTB.__call__(self,etype,value,elist)
173 173
174 174 def clear_err_state(self):
175 175 """Return the current error state and clear it"""
176 176 e = self.last_syntax_error
177 177 self.last_syntax_error = None
178 178 return e
179 179
180 180 #****************************************************************************
181 181 # Main IPython class
182 182
183 183 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
184 184 # until a full rewrite is made. I've cleaned all cross-class uses of
185 185 # attributes and methods, but too much user code out there relies on the
186 186 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
187 187 #
188 188 # But at least now, all the pieces have been separated and we could, in
189 189 # principle, stop using the mixin. This will ease the transition to the
190 190 # chainsaw branch.
191 191
192 192 # For reference, the following is the list of 'self.foo' uses in the Magic
193 193 # class as of 2005-12-28. These are names we CAN'T use in the main ipython
194 194 # class, to prevent clashes.
195 195
196 196 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
197 197 # 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
198 198 # 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
199 199 # 'self.value']
200 200
201 201 class InteractiveShell(object,Magic):
202 202 """An enhanced console for Python."""
203 203
204 204 # class attribute to indicate whether the class supports threads or not.
205 205 # Subclasses with thread support should override this as needed.
206 206 isthreaded = False
207 207
208 208 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
209 209 user_ns = None,user_global_ns=None,banner2='',
210 210 custom_exceptions=((),None),embedded=False):
211 211
212 212 # log system
213 213 self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
214 214
215 215 # some minimal strict typechecks. For some core data structures, I
216 216 # want actual basic python types, not just anything that looks like
217 217 # one. This is especially true for namespaces.
218 218 for ns in (user_ns,user_global_ns):
219 219 if ns is not None and type(ns) != types.DictType:
220 220 raise TypeError,'namespace must be a dictionary'
221 221 # Job manager (for jobs run as background threads)
222 222 self.jobs = BackgroundJobManager()
223 223
224 224 # Store the actual shell's name
225 225 self.name = name
226 226
227 227 # We need to know whether the instance is meant for embedding, since
228 228 # global/local namespaces need to be handled differently in that case
229 229 self.embedded = embedded
230 230 if embedded:
231 231 # Control variable so users can, from within the embedded instance,
232 232 # permanently deactivate it.
233 233 self.embedded_active = True
234 234
235 235 # command compiler
236 236 self.compile = codeop.CommandCompiler()
237 237
238 238 # User input buffer
239 239 self.buffer = []
240 240
241 241 # Default name given in compilation of code
242 242 self.filename = '<ipython console>'
243 243
244 244 # Install our own quitter instead of the builtins. For python2.3-2.4,
245 245 # this brings in behavior like 2.5, and for 2.5 it's identical.
246 246 __builtin__.exit = Quitter(self,'exit')
247 247 __builtin__.quit = Quitter(self,'quit')
248 248
249 249 # Make an empty namespace, which extension writers can rely on both
250 250 # existing and NEVER being used by ipython itself. This gives them a
251 251 # convenient location for storing additional information and state
252 252 # their extensions may require, without fear of collisions with other
253 253 # ipython names that may develop later.
254 254 self.meta = Struct()
255 255
256 256 # Create the namespace where the user will operate. user_ns is
257 257 # normally the only one used, and it is passed to the exec calls as
258 258 # the locals argument. But we do carry a user_global_ns namespace
259 259 # given as the exec 'globals' argument, This is useful in embedding
260 260 # situations where the ipython shell opens in a context where the
261 261 # distinction between locals and globals is meaningful.
262 262
263 263 # FIXME. For some strange reason, __builtins__ is showing up at user
264 264 # level as a dict instead of a module. This is a manual fix, but I
265 265 # should really track down where the problem is coming from. Alex
266 266 # Schmolck reported this problem first.
267 267
268 268 # A useful post by Alex Martelli on this topic:
269 269 # Re: inconsistent value from __builtins__
270 270 # Von: Alex Martelli <aleaxit@yahoo.com>
271 271 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
272 272 # Gruppen: comp.lang.python
273 273
274 274 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
275 275 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
276 276 # > <type 'dict'>
277 277 # > >>> print type(__builtins__)
278 278 # > <type 'module'>
279 279 # > Is this difference in return value intentional?
280 280
281 281 # Well, it's documented that '__builtins__' can be either a dictionary
282 282 # or a module, and it's been that way for a long time. Whether it's
283 283 # intentional (or sensible), I don't know. In any case, the idea is
284 284 # that if you need to access the built-in namespace directly, you
285 285 # should start with "import __builtin__" (note, no 's') which will
286 286 # definitely give you a module. Yeah, it's somewhat confusing:-(.
287 287
288 288 # These routines return properly built dicts as needed by the rest of
289 289 # the code, and can also be used by extension writers to generate
290 290 # properly initialized namespaces.
291 291 user_ns = IPython.ipapi.make_user_ns(user_ns)
292 292 user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)
293 293
294 294 # Assign namespaces
295 295 # This is the namespace where all normal user variables live
296 296 self.user_ns = user_ns
297 297 # Embedded instances require a separate namespace for globals.
298 298 # Normally this one is unused by non-embedded instances.
299 299 self.user_global_ns = user_global_ns
300 300 # A namespace to keep track of internal data structures to prevent
301 301 # them from cluttering user-visible stuff. Will be updated later
302 302 self.internal_ns = {}
303 303
304 304 # Namespace of system aliases. Each entry in the alias
305 305 # table must be a 2-tuple of the form (N,name), where N is the number
306 306 # of positional arguments of the alias.
307 307 self.alias_table = {}
308 308
309 309 # A table holding all the namespaces IPython deals with, so that
310 310 # introspection facilities can search easily.
311 311 self.ns_table = {'user':user_ns,
312 312 'user_global':user_global_ns,
313 313 'alias':self.alias_table,
314 314 'internal':self.internal_ns,
315 315 'builtin':__builtin__.__dict__
316 316 }
317 317 # The user namespace MUST have a pointer to the shell itself.
318 318 self.user_ns[name] = self
319 319
320 320 # We need to insert into sys.modules something that looks like a
321 321 # module but which accesses the IPython namespace, for shelve and
322 322 # pickle to work interactively. Normally they rely on getting
323 323 # everything out of __main__, but for embedding purposes each IPython
324 324 # instance has its own private namespace, so we can't go shoving
325 325 # everything into __main__.
326 326
327 327 # note, however, that we should only do this for non-embedded
328 328 # ipythons, which really mimic the __main__.__dict__ with their own
329 329 # namespace. Embedded instances, on the other hand, should not do
330 330 # this because they need to manage the user local/global namespaces
331 331 # only, but they live within a 'normal' __main__ (meaning, they
332 332 # shouldn't overtake the execution environment of the script they're
333 333 # embedded in).
334 334
335 335 if not embedded:
336 336 try:
337 337 main_name = self.user_ns['__name__']
338 338 except KeyError:
339 339 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
340 340 else:
341 341 #print "pickle hack in place" # dbg
342 342 #print 'main_name:',main_name # dbg
343 343 sys.modules[main_name] = FakeModule(self.user_ns)
344 344
345 345 # Now that FakeModule produces a real module, we've run into a nasty
346 346 # problem: after script execution (via %run), the module where the user
347 347 # code ran is deleted. Now that this object is a true module (needed
348 348 # so docetst and other tools work correctly), the Python module
349 349 # teardown mechanism runs over it, and sets to None every variable
350 350 # present in that module. This means that later calls to functions
351 351 # defined in the script (which have become interactively visible after
352 352 # script exit) fail, because they hold references to objects that have
353 353 # become overwritten into None. The only solution I see right now is
354 354 # to protect every FakeModule used by %run by holding an internal
355 355 # reference to it. This private list will be used for that. The
356 356 # %reset command will flush it as well.
357 357 self._user_main_modules = []
358 358
359 359 # List of input with multi-line handling.
360 360 # Fill its zero entry, user counter starts at 1
361 361 self.input_hist = InputList(['\n'])
362 362 # This one will hold the 'raw' input history, without any
363 363 # pre-processing. This will allow users to retrieve the input just as
364 364 # it was exactly typed in by the user, with %hist -r.
365 365 self.input_hist_raw = InputList(['\n'])
366 366
367 367 # list of visited directories
368 368 try:
369 369 self.dir_hist = [os.getcwd()]
370 370 except OSError:
371 371 self.dir_hist = []
372 372
373 373 # dict of output history
374 374 self.output_hist = {}
375 375
376 376 # Get system encoding at startup time. Certain terminals (like Emacs
377 377 # under Win32 have it set to None, and we need to have a known valid
378 378 # encoding to use in the raw_input() method
379 379 self.stdin_encoding = sys.stdin.encoding or 'ascii'
380 380
381 381 # dict of things NOT to alias (keywords, builtins and some magics)
382 382 no_alias = {}
383 383 no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
384 384 for key in keyword.kwlist + no_alias_magics:
385 385 no_alias[key] = 1
386 386 no_alias.update(__builtin__.__dict__)
387 387 self.no_alias = no_alias
388 388
389 389 # make global variables for user access to these
390 390 self.user_ns['_ih'] = self.input_hist
391 391 self.user_ns['_oh'] = self.output_hist
392 392 self.user_ns['_dh'] = self.dir_hist
393 393
394 394 # user aliases to input and output histories
395 395 self.user_ns['In'] = self.input_hist
396 396 self.user_ns['Out'] = self.output_hist
397 397
398 398 self.user_ns['_sh'] = IPython.shadowns
399 399 # Object variable to store code object waiting execution. This is
400 400 # used mainly by the multithreaded shells, but it can come in handy in
401 401 # other situations. No need to use a Queue here, since it's a single
402 402 # item which gets cleared once run.
403 403 self.code_to_run = None
404 404
405 405 # escapes for automatic behavior on the command line
406 406 self.ESC_SHELL = '!'
407 407 self.ESC_SH_CAP = '!!'
408 408 self.ESC_HELP = '?'
409 409 self.ESC_MAGIC = '%'
410 410 self.ESC_QUOTE = ','
411 411 self.ESC_QUOTE2 = ';'
412 412 self.ESC_PAREN = '/'
413 413
414 414 # And their associated handlers
415 415 self.esc_handlers = {self.ESC_PAREN : self.handle_auto,
416 416 self.ESC_QUOTE : self.handle_auto,
417 417 self.ESC_QUOTE2 : self.handle_auto,
418 418 self.ESC_MAGIC : self.handle_magic,
419 419 self.ESC_HELP : self.handle_help,
420 420 self.ESC_SHELL : self.handle_shell_escape,
421 421 self.ESC_SH_CAP : self.handle_shell_escape,
422 422 }
423 423
424 424 # class initializations
425 425 Magic.__init__(self,self)
426 426
427 427 # Python source parser/formatter for syntax highlighting
428 428 pyformat = PyColorize.Parser().format
429 429 self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
430 430
431 431 # hooks holds pointers used for user-side customizations
432 432 self.hooks = Struct()
433 433
434 434 self.strdispatchers = {}
435 435
436 436 # Set all default hooks, defined in the IPython.hooks module.
437 437 hooks = IPython.hooks
438 438 for hook_name in hooks.__all__:
439 439 # default hooks have priority 100, i.e. low; user hooks should have
440 440 # 0-100 priority
441 441 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
442 442 #print "bound hook",hook_name
443 443
444 444 # Flag to mark unconditional exit
445 445 self.exit_now = False
446 446
447 447 self.usage_min = """\
448 448 An enhanced console for Python.
449 449 Some of its features are:
450 450 - Readline support if the readline library is present.
451 451 - Tab completion in the local namespace.
452 452 - Logging of input, see command-line options.
453 453 - System shell escape via ! , eg !ls.
454 454 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
455 455 - Keeps track of locally defined variables via %who, %whos.
456 456 - Show object information with a ? eg ?x or x? (use ?? for more info).
457 457 """
458 458 if usage: self.usage = usage
459 459 else: self.usage = self.usage_min
460 460
461 461 # Storage
462 462 self.rc = rc # This will hold all configuration information
463 463 self.pager = 'less'
464 464 # temporary files used for various purposes. Deleted at exit.
465 465 self.tempfiles = []
466 466
467 467 # Keep track of readline usage (later set by init_readline)
468 468 self.has_readline = False
469 469
470 470 # template for logfile headers. It gets resolved at runtime by the
471 471 # logstart method.
472 472 self.loghead_tpl = \
473 473 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
474 474 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
475 475 #log# opts = %s
476 476 #log# args = %s
477 477 #log# It is safe to make manual edits below here.
478 478 #log#-----------------------------------------------------------------------
479 479 """
480 480 # for pushd/popd management
481 481 try:
482 482 self.home_dir = get_home_dir()
483 483 except HomeDirError,msg:
484 484 fatal(msg)
485 485
486 486 self.dir_stack = []
487 487
488 488 # Functions to call the underlying shell.
489 489
490 490 # The first is similar to os.system, but it doesn't return a value,
491 491 # and it allows interpolation of variables in the user's namespace.
492 492 self.system = lambda cmd: \
493 493 shell(self.var_expand(cmd,depth=2),
494 494 header=self.rc.system_header,
495 495 verbose=self.rc.system_verbose)
496 496
497 497 # These are for getoutput and getoutputerror:
498 498 self.getoutput = lambda cmd: \
499 499 getoutput(self.var_expand(cmd,depth=2),
500 500 header=self.rc.system_header,
501 501 verbose=self.rc.system_verbose)
502 502
503 503 self.getoutputerror = lambda cmd: \
504 504 getoutputerror(self.var_expand(cmd,depth=2),
505 505 header=self.rc.system_header,
506 506 verbose=self.rc.system_verbose)
507 507
508 508
509 509 # keep track of where we started running (mainly for crash post-mortem)
510 510 self.starting_dir = os.getcwd()
511 511
512 512 # Various switches which can be set
513 513 self.CACHELENGTH = 5000 # this is cheap, it's just text
514 514 self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
515 515 self.banner2 = banner2
516 516
517 517 # TraceBack handlers:
518 518
519 519 # Syntax error handler.
520 520 self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
521 521
522 522 # The interactive one is initialized with an offset, meaning we always
523 523 # want to remove the topmost item in the traceback, which is our own
524 524 # internal code. Valid modes: ['Plain','Context','Verbose']
525 525 self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
526 526 color_scheme='NoColor',
527 527 tb_offset = 1)
528 528
529 529 # IPython itself shouldn't crash. This will produce a detailed
530 530 # post-mortem if it does. But we only install the crash handler for
531 531 # non-threaded shells, the threaded ones use a normal verbose reporter
532 532 # and lose the crash handler. This is because exceptions in the main
533 533 # thread (such as in GUI code) propagate directly to sys.excepthook,
534 534 # and there's no point in printing crash dumps for every user exception.
535 535 if self.isthreaded:
536 536 ipCrashHandler = ultraTB.FormattedTB()
537 537 else:
538 538 from IPython import CrashHandler
539 539 ipCrashHandler = CrashHandler.IPythonCrashHandler(self)
540 540 self.set_crash_handler(ipCrashHandler)
541 541
542 542 # and add any custom exception handlers the user may have specified
543 543 self.set_custom_exc(*custom_exceptions)
544 544
545 545 # indentation management
546 546 self.autoindent = False
547 547 self.indent_current_nsp = 0
548 548
549 549 # Make some aliases automatically
550 550 # Prepare list of shell aliases to auto-define
551 551 if os.name == 'posix':
552 552 auto_alias = ('mkdir mkdir', 'rmdir rmdir',
553 553 'mv mv -i','rm rm -i','cp cp -i',
554 554 'cat cat','less less','clear clear',
555 555 # a better ls
556 556 'ls ls -F',
557 557 # long ls
558 558 'll ls -lF')
559 559 # Extra ls aliases with color, which need special treatment on BSD
560 560 # variants
561 561 ls_extra = ( # color ls
562 562 'lc ls -F -o --color',
563 563 # ls normal files only
564 564 'lf ls -F -o --color %l | grep ^-',
565 565 # ls symbolic links
566 566 'lk ls -F -o --color %l | grep ^l',
567 567 # directories or links to directories,
568 568 'ldir ls -F -o --color %l | grep /$',
569 569 # things which are executable
570 570 'lx ls -F -o --color %l | grep ^-..x',
571 571 )
572 572 # The BSDs don't ship GNU ls, so they don't understand the
573 573 # --color switch out of the box
574 574 if 'bsd' in sys.platform:
575 575 ls_extra = ( # ls normal files only
576 576 'lf ls -lF | grep ^-',
577 577 # ls symbolic links
578 578 'lk ls -lF | grep ^l',
579 579 # directories or links to directories,
580 580 'ldir ls -lF | grep /$',
581 581 # things which are executable
582 582 'lx ls -lF | grep ^-..x',
583 583 )
584 584 auto_alias = auto_alias + ls_extra
585 585 elif os.name in ['nt','dos']:
586 586 auto_alias = ('ls dir /on',
587 587 'ddir dir /ad /on', 'ldir dir /ad /on',
588 588 'mkdir mkdir','rmdir rmdir','echo echo',
589 589 'ren ren','cls cls','copy copy')
590 590 else:
591 591 auto_alias = ()
592 592 self.auto_alias = [s.split(None,1) for s in auto_alias]
593 593
594 594 # Produce a public API instance
595 595 self.api = IPython.ipapi.IPApi(self)
596 596
597 597 # Call the actual (public) initializer
598 598 self.init_auto_alias()
599 599
600 600 # track which builtins we add, so we can clean up later
601 601 self.builtins_added = {}
602 602 # This method will add the necessary builtins for operation, but
603 603 # tracking what it did via the builtins_added dict.
604 604 self.add_builtins()
605 605
606 606
607 607
608 608 # end __init__
609 609
610 610 def var_expand(self,cmd,depth=0):
611 611 """Expand python variables in a string.
612 612
613 613 The depth argument indicates how many frames above the caller should
614 614 be walked to look for the local namespace where to expand variables.
615 615
616 616 The global namespace for expansion is always the user's interactive
617 617 namespace.
618 618 """
619 619
620 620 return str(ItplNS(cmd,
621 621 self.user_ns, # globals
622 622 # Skip our own frame in searching for locals:
623 623 sys._getframe(depth+1).f_locals # locals
624 624 ))
625 625
626 626 def pre_config_initialization(self):
627 627 """Pre-configuration init method
628 628
629 629 This is called before the configuration files are processed to
630 630 prepare the services the config files might need.
631 631
632 632 self.rc already has reasonable default values at this point.
633 633 """
634 634 rc = self.rc
635 635 try:
636 636 self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
637 637 except exceptions.UnicodeDecodeError:
638 638 print "Your ipythondir can't be decoded to unicode!"
639 639 print "Please set HOME environment variable to something that"
640 640 print r"only has ASCII characters, e.g. c:\home"
641 641 print "Now it is",rc.ipythondir
642 642 sys.exit()
643 643 self.shadowhist = IPython.history.ShadowHist(self.db)
644 644
645 645
646 646 def post_config_initialization(self):
647 647 """Post configuration init method
648 648
649 649 This is called after the configuration files have been processed to
650 650 'finalize' the initialization."""
651 651
652 652 rc = self.rc
653 653
654 654 # Object inspector
655 655 self.inspector = OInspect.Inspector(OInspect.InspectColors,
656 656 PyColorize.ANSICodeColors,
657 657 'NoColor',
658 658 rc.object_info_string_level)
659 659
660 660 self.rl_next_input = None
661 661 self.rl_do_indent = False
662 662 # Load readline proper
663 663 if rc.readline:
664 664 self.init_readline()
665 665
666 666
667 667 # local shortcut, this is used a LOT
668 668 self.log = self.logger.log
669 669
670 670 # Initialize cache, set in/out prompts and printing system
671 671 self.outputcache = CachedOutput(self,
672 672 rc.cache_size,
673 673 rc.pprint,
674 674 input_sep = rc.separate_in,
675 675 output_sep = rc.separate_out,
676 676 output_sep2 = rc.separate_out2,
677 677 ps1 = rc.prompt_in1,
678 678 ps2 = rc.prompt_in2,
679 679 ps_out = rc.prompt_out,
680 680 pad_left = rc.prompts_pad_left)
681 681
682 682 # user may have over-ridden the default print hook:
683 683 try:
684 684 self.outputcache.__class__.display = self.hooks.display
685 685 except AttributeError:
686 686 pass
687 687
688 688 # I don't like assigning globally to sys, because it means when
689 689 # embedding instances, each embedded instance overrides the previous
690 690 # choice. But sys.displayhook seems to be called internally by exec,
691 691 # so I don't see a way around it. We first save the original and then
692 692 # overwrite it.
693 693 self.sys_displayhook = sys.displayhook
694 694 sys.displayhook = self.outputcache
695 695
696 696 # Do a proper resetting of doctest, including the necessary displayhook
697 697 # monkeypatching
698 698 doctest_reload()
699 699
700 700 # Set user colors (don't do it in the constructor above so that it
701 701 # doesn't crash if colors option is invalid)
702 702 self.magic_colors(rc.colors)
703 703
704 704 # Set calling of pdb on exceptions
705 705 self.call_pdb = rc.pdb
706 706
707 707 # Load user aliases
708 708 for alias in rc.alias:
709 709 self.magic_alias(alias)
710 710
711 711 self.hooks.late_startup_hook()
712 712
713 713 batchrun = False
714 714 for batchfile in [path(arg) for arg in self.rc.args
715 715 if arg.lower().endswith('.ipy')]:
716 716 if not batchfile.isfile():
717 717 print "No such batch file:", batchfile
718 718 continue
719 719 self.api.runlines(batchfile.text())
720 720 batchrun = True
721 721 # without -i option, exit after running the batch file
722 722 if batchrun and not self.rc.interact:
723 723 self.exit_now = True
724 724
725 725 def add_builtins(self):
726 726 """Store ipython references into the builtin namespace.
727 727
728 728 Some parts of ipython operate via builtins injected here, which hold a
729 729 reference to IPython itself."""
730 730
731 731 # TODO: deprecate all of these, they are unsafe
732 732 builtins_new = dict(__IPYTHON__ = self,
733 733 ip_set_hook = self.set_hook,
734 734 jobs = self.jobs,
735 735 ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),
736 736 ipalias = wrap_deprecated(self.ipalias),
737 737 ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
738 738 #_ip = self.api
739 739 )
740 740 for biname,bival in builtins_new.items():
741 741 try:
742 742 # store the orignal value so we can restore it
743 743 self.builtins_added[biname] = __builtin__.__dict__[biname]
744 744 except KeyError:
745 745 # or mark that it wasn't defined, and we'll just delete it at
746 746 # cleanup
747 747 self.builtins_added[biname] = Undefined
748 748 __builtin__.__dict__[biname] = bival
749 749
750 750 # Keep in the builtins a flag for when IPython is active. We set it
751 751 # with setdefault so that multiple nested IPythons don't clobber one
752 752 # another. Each will increase its value by one upon being activated,
753 753 # which also gives us a way to determine the nesting level.
754 754 __builtin__.__dict__.setdefault('__IPYTHON__active',0)
755 755
756 756 def clean_builtins(self):
757 757 """Remove any builtins which might have been added by add_builtins, or
758 758 restore overwritten ones to their previous values."""
759 759 for biname,bival in self.builtins_added.items():
760 760 if bival is Undefined:
761 761 del __builtin__.__dict__[biname]
762 762 else:
763 763 __builtin__.__dict__[biname] = bival
764 764 self.builtins_added.clear()
765 765
766 766 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
767 767 """set_hook(name,hook) -> sets an internal IPython hook.
768 768
769 769 IPython exposes some of its internal API as user-modifiable hooks. By
770 770 adding your function to one of these hooks, you can modify IPython's
771 771 behavior to call at runtime your own routines."""
772 772
773 773 # At some point in the future, this should validate the hook before it
774 774 # accepts it. Probably at least check that the hook takes the number
775 775 # of args it's supposed to.
776 776
777 777 f = new.instancemethod(hook,self,self.__class__)
778 778
779 779 # check if the hook is for strdispatcher first
780 780 if str_key is not None:
781 781 sdp = self.strdispatchers.get(name, StrDispatch())
782 782 sdp.add_s(str_key, f, priority )
783 783 self.strdispatchers[name] = sdp
784 784 return
785 785 if re_key is not None:
786 786 sdp = self.strdispatchers.get(name, StrDispatch())
787 787 sdp.add_re(re.compile(re_key), f, priority )
788 788 self.strdispatchers[name] = sdp
789 789 return
790 790
791 791 dp = getattr(self.hooks, name, None)
792 792 if name not in IPython.hooks.__all__:
793 793 print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
794 794 if not dp:
795 795 dp = IPython.hooks.CommandChainDispatcher()
796 796
797 797 try:
798 798 dp.add(f,priority)
799 799 except AttributeError:
800 800 # it was not commandchain, plain old func - replace
801 801 dp = f
802 802
803 803 setattr(self.hooks,name, dp)
804 804
805 805
806 806 #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
807 807
808 808 def set_crash_handler(self,crashHandler):
809 809 """Set the IPython crash handler.
810 810
811 811 This must be a callable with a signature suitable for use as
812 812 sys.excepthook."""
813 813
814 814 # Install the given crash handler as the Python exception hook
815 815 sys.excepthook = crashHandler
816 816
817 817 # The instance will store a pointer to this, so that runtime code
818 818 # (such as magics) can access it. This is because during the
819 819 # read-eval loop, it gets temporarily overwritten (to deal with GUI
820 820 # frameworks).
821 821 self.sys_excepthook = sys.excepthook
822 822
823 823
824 824 def set_custom_exc(self,exc_tuple,handler):
825 825 """set_custom_exc(exc_tuple,handler)
826 826
827 827 Set a custom exception handler, which will be called if any of the
828 828 exceptions in exc_tuple occur in the mainloop (specifically, in the
829 829 runcode() method.
830 830
831 831 Inputs:
832 832
833 833 - exc_tuple: a *tuple* of valid exceptions to call the defined
834 834 handler for. It is very important that you use a tuple, and NOT A
835 835 LIST here, because of the way Python's except statement works. If
836 836 you only want to trap a single exception, use a singleton tuple:
837 837
838 838 exc_tuple == (MyCustomException,)
839 839
840 840 - handler: this must be defined as a function with the following
841 841 basic interface: def my_handler(self,etype,value,tb).
842 842
843 843 This will be made into an instance method (via new.instancemethod)
844 844 of IPython itself, and it will be called if any of the exceptions
845 845 listed in the exc_tuple are caught. If the handler is None, an
846 846 internal basic one is used, which just prints basic info.
847 847
848 848 WARNING: by putting in your own exception handler into IPython's main
849 849 execution loop, you run a very good chance of nasty crashes. This
850 850 facility should only be used if you really know what you are doing."""
851 851
852 852 assert type(exc_tuple)==type(()) , \
853 853 "The custom exceptions must be given AS A TUPLE."
854 854
855 855 def dummy_handler(self,etype,value,tb):
856 856 print '*** Simple custom exception handler ***'
857 857 print 'Exception type :',etype
858 858 print 'Exception value:',value
859 859 print 'Traceback :',tb
860 860 print 'Source code :','\n'.join(self.buffer)
861 861
862 862 if handler is None: handler = dummy_handler
863 863
864 864 self.CustomTB = new.instancemethod(handler,self,self.__class__)
865 865 self.custom_exceptions = exc_tuple
866 866
867 867 def set_custom_completer(self,completer,pos=0):
868 868 """set_custom_completer(completer,pos=0)
869 869
870 870 Adds a new custom completer function.
871 871
872 872 The position argument (defaults to 0) is the index in the completers
873 873 list where you want the completer to be inserted."""
874 874
875 875 newcomp = new.instancemethod(completer,self.Completer,
876 876 self.Completer.__class__)
877 877 self.Completer.matchers.insert(pos,newcomp)
878 878
879 879 def set_completer(self):
880 880 """reset readline's completer to be our own."""
881 881 self.readline.set_completer(self.Completer.complete)
882 882
883 883 def _get_call_pdb(self):
884 884 return self._call_pdb
885 885
886 886 def _set_call_pdb(self,val):
887 887
888 888 if val not in (0,1,False,True):
889 889 raise ValueError,'new call_pdb value must be boolean'
890 890
891 891 # store value in instance
892 892 self._call_pdb = val
893 893
894 894 # notify the actual exception handlers
895 895 self.InteractiveTB.call_pdb = val
896 896 if self.isthreaded:
897 897 try:
898 898 self.sys_excepthook.call_pdb = val
899 899 except:
900 900 warn('Failed to activate pdb for threaded exception handler')
901 901
902 902 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
903 903 'Control auto-activation of pdb at exceptions')
904 904
905 905
906 906 # These special functions get installed in the builtin namespace, to
907 907 # provide programmatic (pure python) access to magics, aliases and system
908 908 # calls. This is important for logging, user scripting, and more.
909 909
910 910 # We are basically exposing, via normal python functions, the three
911 911 # mechanisms in which ipython offers special call modes (magics for
912 912 # internal control, aliases for direct system access via pre-selected
913 913 # names, and !cmd for calling arbitrary system commands).
914 914
915 915 def ipmagic(self,arg_s):
916 916 """Call a magic function by name.
917 917
918 918 Input: a string containing the name of the magic function to call and any
919 919 additional arguments to be passed to the magic.
920 920
921 921 ipmagic('name -opt foo bar') is equivalent to typing at the ipython
922 922 prompt:
923 923
924 924 In[1]: %name -opt foo bar
925 925
926 926 To call a magic without arguments, simply use ipmagic('name').
927 927
928 928 This provides a proper Python function to call IPython's magics in any
929 929 valid Python code you can type at the interpreter, including loops and
930 930 compound statements. It is added by IPython to the Python builtin
931 931 namespace upon initialization."""
932 932
933 933 args = arg_s.split(' ',1)
934 934 magic_name = args[0]
935 935 magic_name = magic_name.lstrip(self.ESC_MAGIC)
936 936
937 937 try:
938 938 magic_args = args[1]
939 939 except IndexError:
940 940 magic_args = ''
941 941 fn = getattr(self,'magic_'+magic_name,None)
942 942 if fn is None:
943 943 error("Magic function `%s` not found." % magic_name)
944 944 else:
945 945 magic_args = self.var_expand(magic_args,1)
946 946 return fn(magic_args)
947 947
948 948 def ipalias(self,arg_s):
949 949 """Call an alias by name.
950 950
951 951 Input: a string containing the name of the alias to call and any
952 952 additional arguments to be passed to the magic.
953 953
954 954 ipalias('name -opt foo bar') is equivalent to typing at the ipython
955 955 prompt:
956 956
957 957 In[1]: name -opt foo bar
958 958
959 959 To call an alias without arguments, simply use ipalias('name').
960 960
961 961 This provides a proper Python function to call IPython's aliases in any
962 962 valid Python code you can type at the interpreter, including loops and
963 963 compound statements. It is added by IPython to the Python builtin
964 964 namespace upon initialization."""
965 965
966 966 args = arg_s.split(' ',1)
967 967 alias_name = args[0]
968 968 try:
969 969 alias_args = args[1]
970 970 except IndexError:
971 971 alias_args = ''
972 972 if alias_name in self.alias_table:
973 973 self.call_alias(alias_name,alias_args)
974 974 else:
975 975 error("Alias `%s` not found." % alias_name)
976 976
977 977 def ipsystem(self,arg_s):
978 978 """Make a system call, using IPython."""
979 979
980 980 self.system(arg_s)
981 981
982 982 def complete(self,text):
983 983 """Return a sorted list of all possible completions on text.
984 984
985 985 Inputs:
986 986
987 987 - text: a string of text to be completed on.
988 988
989 989 This is a wrapper around the completion mechanism, similar to what
990 990 readline does at the command line when the TAB key is hit. By
991 991 exposing it as a method, it can be used by other non-readline
992 992 environments (such as GUIs) for text completion.
993 993
994 994 Simple usage example:
995 995
996 996 In [1]: x = 'hello'
997 997
998 998 In [2]: __IP.complete('x.l')
999 999 Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
1000 1000
1001 1001 complete = self.Completer.complete
1002 1002 state = 0
1003 1003 # use a dict so we get unique keys, since ipyhton's multiple
1004 1004 # completers can return duplicates. When we make 2.4 a requirement,
1005 1005 # start using sets instead, which are faster.
1006 1006 comps = {}
1007 1007 while True:
1008 1008 newcomp = complete(text,state,line_buffer=text)
1009 1009 if newcomp is None:
1010 1010 break
1011 1011 comps[newcomp] = 1
1012 1012 state += 1
1013 1013 outcomps = comps.keys()
1014 1014 outcomps.sort()
1015 1015 return outcomps
1016 1016
1017 1017 def set_completer_frame(self, frame=None):
1018 1018 if frame:
1019 1019 self.Completer.namespace = frame.f_locals
1020 1020 self.Completer.global_namespace = frame.f_globals
1021 1021 else:
1022 1022 self.Completer.namespace = self.user_ns
1023 1023 self.Completer.global_namespace = self.user_global_ns
1024 1024
1025 1025 def init_auto_alias(self):
1026 1026 """Define some aliases automatically.
1027 1027
1028 1028 These are ALL parameter-less aliases"""
1029 1029
1030 1030 for alias,cmd in self.auto_alias:
1031 1031 self.getapi().defalias(alias,cmd)
1032 1032
1033 1033
1034 1034 def alias_table_validate(self,verbose=0):
1035 1035 """Update information about the alias table.
1036 1036
1037 1037 In particular, make sure no Python keywords/builtins are in it."""
1038 1038
1039 1039 no_alias = self.no_alias
1040 1040 for k in self.alias_table.keys():
1041 1041 if k in no_alias:
1042 1042 del self.alias_table[k]
1043 1043 if verbose:
1044 1044 print ("Deleting alias <%s>, it's a Python "
1045 1045 "keyword or builtin." % k)
1046 1046
1047 1047 def set_autoindent(self,value=None):
1048 1048 """Set the autoindent flag, checking for readline support.
1049 1049
1050 1050 If called with no arguments, it acts as a toggle."""
1051 1051
1052 1052 if not self.has_readline:
1053 1053 if os.name == 'posix':
1054 1054 warn("The auto-indent feature requires the readline library")
1055 1055 self.autoindent = 0
1056 1056 return
1057 1057 if value is None:
1058 1058 self.autoindent = not self.autoindent
1059 1059 else:
1060 1060 self.autoindent = value
1061 1061
1062 1062 def rc_set_toggle(self,rc_field,value=None):
1063 1063 """Set or toggle a field in IPython's rc config. structure.
1064 1064
1065 1065 If called with no arguments, it acts as a toggle.
1066 1066
1067 1067 If called with a non-existent field, the resulting AttributeError
1068 1068 exception will propagate out."""
1069 1069
1070 1070 rc_val = getattr(self.rc,rc_field)
1071 1071 if value is None:
1072 1072 value = not rc_val
1073 1073 setattr(self.rc,rc_field,value)
1074 1074
1075 1075 def user_setup(self,ipythondir,rc_suffix,mode='install'):
1076 1076 """Install the user configuration directory.
1077 1077
1078 1078 Can be called when running for the first time or to upgrade the user's
1079 1079 .ipython/ directory with the mode parameter. Valid modes are 'install'
1080 1080 and 'upgrade'."""
1081 1081
1082 1082 def wait():
1083 1083 try:
1084 1084 raw_input("Please press <RETURN> to start IPython.")
1085 1085 except EOFError:
1086 1086 print >> Term.cout
1087 1087 print '*'*70
1088 1088
1089 1089 cwd = os.getcwd() # remember where we started
1090 1090 glb = glob.glob
1091 1091 print '*'*70
1092 1092 if mode == 'install':
1093 1093 print \
1094 1094 """Welcome to IPython. I will try to create a personal configuration directory
1095 1095 where you can customize many aspects of IPython's functionality in:\n"""
1096 1096 else:
1097 1097 print 'I am going to upgrade your configuration in:'
1098 1098
1099 1099 print ipythondir
1100 1100
1101 1101 rcdirend = os.path.join('IPython','UserConfig')
1102 1102 cfg = lambda d: os.path.join(d,rcdirend)
1103 1103 try:
1104 1104 rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
1105 1105 print "Initializing from configuration",rcdir
1106 1106 except IndexError:
1107 1107 warning = """
1108 1108 Installation error. IPython's directory was not found.
1109 1109
1110 1110 Check the following:
1111 1111
1112 1112 The ipython/IPython directory should be in a directory belonging to your
1113 1113 PYTHONPATH environment variable (that is, it should be in a directory
1114 1114 belonging to sys.path). You can copy it explicitly there or just link to it.
1115 1115
1116 1116 IPython will create a minimal default configuration for you.
1117 1117
1118 1118 """
1119 1119 warn(warning)
1120 1120 wait()
1121 1121
1122 1122 if sys.platform =='win32':
1123 1123 inif = 'ipythonrc.ini'
1124 1124 else:
1125 1125 inif = 'ipythonrc'
1126 1126 minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }
1127 1127 os.makedirs(ipythondir)
1128 1128 for f, cont in minimal_setup.items():
1129 1129 open(ipythondir + '/' + f,'w').write(cont)
1130 1130
1131 1131 return
1132 1132
1133 1133 if mode == 'install':
1134 1134 try:
1135 1135 shutil.copytree(rcdir,ipythondir)
1136 1136 os.chdir(ipythondir)
1137 1137 rc_files = glb("ipythonrc*")
1138 1138 for rc_file in rc_files:
1139 1139 os.rename(rc_file,rc_file+rc_suffix)
1140 1140 except:
1141 1141 warning = """
1142 1142
1143 1143 There was a problem with the installation:
1144 1144 %s
1145 1145 Try to correct it or contact the developers if you think it's a bug.
1146 1146 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
1147 1147 warn(warning)
1148 1148 wait()
1149 1149 return
1150 1150
1151 1151 elif mode == 'upgrade':
1152 1152 try:
1153 1153 os.chdir(ipythondir)
1154 1154 except:
1155 1155 print """
1156 1156 Can not upgrade: changing to directory %s failed. Details:
1157 1157 %s
1158 1158 """ % (ipythondir,sys.exc_info()[1])
1159 1159 wait()
1160 1160 return
1161 1161 else:
1162 1162 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
1163 1163 for new_full_path in sources:
1164 1164 new_filename = os.path.basename(new_full_path)
1165 1165 if new_filename.startswith('ipythonrc'):
1166 1166 new_filename = new_filename + rc_suffix
1167 1167 # The config directory should only contain files, skip any
1168 1168 # directories which may be there (like CVS)
1169 1169 if os.path.isdir(new_full_path):
1170 1170 continue
1171 1171 if os.path.exists(new_filename):
1172 1172 old_file = new_filename+'.old'
1173 1173 if os.path.exists(old_file):
1174 1174 os.remove(old_file)
1175 1175 os.rename(new_filename,old_file)
1176 1176 shutil.copy(new_full_path,new_filename)
1177 1177 else:
1178 1178 raise ValueError,'unrecognized mode for install:',`mode`
1179 1179
1180 1180 # Fix line-endings to those native to each platform in the config
1181 1181 # directory.
1182 1182 try:
1183 1183 os.chdir(ipythondir)
1184 1184 except:
1185 1185 print """
1186 1186 Problem: changing to directory %s failed.
1187 1187 Details:
1188 1188 %s
1189 1189
1190 1190 Some configuration files may have incorrect line endings. This should not
1191 1191 cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])
1192 1192 wait()
1193 1193 else:
1194 1194 for fname in glb('ipythonrc*'):
1195 1195 try:
1196 1196 native_line_ends(fname,backup=0)
1197 1197 except IOError:
1198 1198 pass
1199 1199
1200 1200 if mode == 'install':
1201 1201 print """
1202 1202 Successful installation!
1203 1203
1204 1204 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
1205 1205 IPython manual (there are both HTML and PDF versions supplied with the
1206 1206 distribution) to make sure that your system environment is properly configured
1207 1207 to take advantage of IPython's features.
1208 1208
1209 1209 Important note: the configuration system has changed! The old system is
1210 1210 still in place, but its setting may be partly overridden by the settings in
1211 1211 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file
1212 1212 if some of the new settings bother you.
1213 1213
1214 1214 """
1215 1215 else:
1216 1216 print """
1217 1217 Successful upgrade!
1218 1218
1219 1219 All files in your directory:
1220 1220 %(ipythondir)s
1221 1221 which would have been overwritten by the upgrade were backed up with a .old
1222 1222 extension. If you had made particular customizations in those files you may
1223 1223 want to merge them back into the new files.""" % locals()
1224 1224 wait()
1225 1225 os.chdir(cwd)
1226 1226 # end user_setup()
1227 1227
1228 1228 def atexit_operations(self):
1229 1229 """This will be executed at the time of exit.
1230 1230
1231 1231 Saving of persistent data should be performed here. """
1232 1232
1233 1233 #print '*** IPython exit cleanup ***' # dbg
1234 1234 # input history
1235 1235 self.savehist()
1236 1236
1237 1237 # Cleanup all tempfiles left around
1238 1238 for tfile in self.tempfiles:
1239 1239 try:
1240 1240 os.unlink(tfile)
1241 1241 except OSError:
1242 1242 pass
1243 1243
1244 1244 self.hooks.shutdown_hook()
1245 1245
1246 1246 def savehist(self):
1247 1247 """Save input history to a file (via readline library)."""
1248 1248
1249 1249 if not self.has_readline:
1250 1250 return
1251 1251
1252 1252 try:
1253 1253 self.readline.write_history_file(self.histfile)
1254 1254 except:
1255 1255 print 'Unable to save IPython command history to file: ' + \
1256 1256 `self.histfile`
1257 1257
1258 1258 def reloadhist(self):
1259 1259 """Reload the input history from disk file."""
1260 1260
1261 1261 if self.has_readline:
1262 1262 self.readline.clear_history()
1263 1263 self.readline.read_history_file(self.shell.histfile)
1264 1264
1265 1265 def history_saving_wrapper(self, func):
1266 1266 """ Wrap func for readline history saving
1267 1267
1268 1268 Convert func into callable that saves & restores
1269 1269 history around the call """
1270 1270
1271 1271 if not self.has_readline:
1272 1272 return func
1273 1273
1274 1274 def wrapper():
1275 1275 self.savehist()
1276 1276 try:
1277 1277 func()
1278 1278 finally:
1279 1279 readline.read_history_file(self.histfile)
1280 1280 return wrapper
1281 1281
1282 1282
1283 1283 def pre_readline(self):
1284 1284 """readline hook to be used at the start of each line.
1285 1285
1286 1286 Currently it handles auto-indent only."""
1287 1287
1288 1288 #debugx('self.indent_current_nsp','pre_readline:')
1289 1289
1290 1290 if self.rl_do_indent:
1291 1291 self.readline.insert_text(self.indent_current_str())
1292 1292 if self.rl_next_input is not None:
1293 1293 self.readline.insert_text(self.rl_next_input)
1294 1294 self.rl_next_input = None
1295 1295
1296 1296 def init_readline(self):
1297 1297 """Command history completion/saving/reloading."""
1298 1298
1299 1299
1300 1300 import IPython.rlineimpl as readline
1301 1301
1302 1302 if not readline.have_readline:
1303 1303 self.has_readline = 0
1304 1304 self.readline = None
1305 1305 # no point in bugging windows users with this every time:
1306 1306 warn('Readline services not available on this platform.')
1307 1307 else:
1308 1308 sys.modules['readline'] = readline
1309 1309 import atexit
1310 1310 from IPython.completer import IPCompleter
1311 1311 self.Completer = IPCompleter(self,
1312 1312 self.user_ns,
1313 1313 self.user_global_ns,
1314 1314 self.rc.readline_omit__names,
1315 1315 self.alias_table)
1316 1316 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1317 1317 self.strdispatchers['complete_command'] = sdisp
1318 1318 self.Completer.custom_completers = sdisp
1319 1319 # Platform-specific configuration
1320 1320 if os.name == 'nt':
1321 1321 self.readline_startup_hook = readline.set_pre_input_hook
1322 1322 else:
1323 1323 self.readline_startup_hook = readline.set_startup_hook
1324 1324
1325 1325 # Load user's initrc file (readline config)
1326 1326 # Or if libedit is used, load editrc.
1327 1327 inputrc_name = os.environ.get('INPUTRC')
1328 1328 if inputrc_name is None:
1329 1329 home_dir = get_home_dir()
1330 1330 if home_dir is not None:
1331 1331 inputrc_name = '.inputrc'
1332 1332 if readline.uses_libedit:
1333 1333 inputrc_name = '.editrc'
1334 1334 inputrc_name = os.path.join(home_dir, inputrc_name)
1335 1335 if os.path.isfile(inputrc_name):
1336 1336 try:
1337 1337 readline.read_init_file(inputrc_name)
1338 1338 except:
1339 1339 warn('Problems reading readline initialization file <%s>'
1340 1340 % inputrc_name)
1341 1341
1342 1342 self.has_readline = 1
1343 1343 self.readline = readline
1344 1344 # save this in sys so embedded copies can restore it properly
1345 1345 sys.ipcompleter = self.Completer.complete
1346 1346 self.set_completer()
1347 1347
1348 1348 # Configure readline according to user's prefs
1349 1349 # This is only done if GNU readline is being used. If libedit
1350 1350 # is being used (as on Leopard) the readline config is
1351 1351 # not run as the syntax for libedit is different.
1352 1352 if not readline.uses_libedit:
1353 1353 for rlcommand in self.rc.readline_parse_and_bind:
1354 1354 readline.parse_and_bind(rlcommand)
1355 1355
1356 1356 # remove some chars from the delimiters list
1357 1357 delims = readline.get_completer_delims()
1358 1358 delims = delims.translate(string._idmap,
1359 1359 self.rc.readline_remove_delims)
1360 1360 readline.set_completer_delims(delims)
1361 1361 # otherwise we end up with a monster history after a while:
1362 1362 readline.set_history_length(1000)
1363 1363 try:
1364 1364 #print '*** Reading readline history' # dbg
1365 1365 readline.read_history_file(self.histfile)
1366 1366 except IOError:
1367 1367 pass # It doesn't exist yet.
1368 1368
1369 1369 atexit.register(self.atexit_operations)
1370 1370 del atexit
1371 1371
1372 1372 # Configure auto-indent for all platforms
1373 1373 self.set_autoindent(self.rc.autoindent)
1374 1374
1375 1375 def ask_yes_no(self,prompt,default=True):
1376 1376 if self.rc.quiet:
1377 1377 return True
1378 1378 return ask_yes_no(prompt,default)
1379 1379
1380 1380 def _should_recompile(self,e):
1381 1381 """Utility routine for edit_syntax_error"""
1382 1382
1383 1383 if e.filename in ('<ipython console>','<input>','<string>',
1384 1384 '<console>','<BackgroundJob compilation>',
1385 1385 None):
1386 1386
1387 1387 return False
1388 1388 try:
1389 1389 if (self.rc.autoedit_syntax and
1390 1390 not self.ask_yes_no('Return to editor to correct syntax error? '
1391 1391 '[Y/n] ','y')):
1392 1392 return False
1393 1393 except EOFError:
1394 1394 return False
1395 1395
1396 1396 def int0(x):
1397 1397 try:
1398 1398 return int(x)
1399 1399 except TypeError:
1400 1400 return 0
1401 1401 # always pass integer line and offset values to editor hook
1402 1402 self.hooks.fix_error_editor(e.filename,
1403 1403 int0(e.lineno),int0(e.offset),e.msg)
1404 1404 return True
1405 1405
1406 1406 def edit_syntax_error(self):
1407 1407 """The bottom half of the syntax error handler called in the main loop.
1408 1408
1409 1409 Loop until syntax error is fixed or user cancels.
1410 1410 """
1411 1411
1412 1412 while self.SyntaxTB.last_syntax_error:
1413 1413 # copy and clear last_syntax_error
1414 1414 err = self.SyntaxTB.clear_err_state()
1415 1415 if not self._should_recompile(err):
1416 1416 return
1417 1417 try:
1418 1418 # may set last_syntax_error again if a SyntaxError is raised
1419 1419 self.safe_execfile(err.filename,self.user_ns)
1420 1420 except:
1421 1421 self.showtraceback()
1422 1422 else:
1423 1423 try:
1424 1424 f = file(err.filename)
1425 1425 try:
1426 1426 sys.displayhook(f.read())
1427 1427 finally:
1428 1428 f.close()
1429 1429 except:
1430 1430 self.showtraceback()
1431 1431
1432 1432 def showsyntaxerror(self, filename=None):
1433 1433 """Display the syntax error that just occurred.
1434 1434
1435 1435 This doesn't display a stack trace because there isn't one.
1436 1436
1437 1437 If a filename is given, it is stuffed in the exception instead
1438 1438 of what was there before (because Python's parser always uses
1439 1439 "<string>" when reading from a string).
1440 1440 """
1441 1441 etype, value, last_traceback = sys.exc_info()
1442 1442
1443 1443 # See note about these variables in showtraceback() below
1444 1444 sys.last_type = etype
1445 1445 sys.last_value = value
1446 1446 sys.last_traceback = last_traceback
1447 1447
1448 1448 if filename and etype is SyntaxError:
1449 1449 # Work hard to stuff the correct filename in the exception
1450 1450 try:
1451 1451 msg, (dummy_filename, lineno, offset, line) = value
1452 1452 except:
1453 1453 # Not the format we expect; leave it alone
1454 1454 pass
1455 1455 else:
1456 1456 # Stuff in the right filename
1457 1457 try:
1458 1458 # Assume SyntaxError is a class exception
1459 1459 value = SyntaxError(msg, (filename, lineno, offset, line))
1460 1460 except:
1461 1461 # If that failed, assume SyntaxError is a string
1462 1462 value = msg, (filename, lineno, offset, line)
1463 1463 self.SyntaxTB(etype,value,[])
1464 1464
1465 1465 def debugger(self,force=False):
1466 1466 """Call the pydb/pdb debugger.
1467 1467
1468 1468 Keywords:
1469 1469
1470 1470 - force(False): by default, this routine checks the instance call_pdb
1471 1471 flag and does not actually invoke the debugger if the flag is false.
1472 1472 The 'force' option forces the debugger to activate even if the flag
1473 1473 is false.
1474 1474 """
1475 1475
1476 1476 if not (force or self.call_pdb):
1477 1477 return
1478 1478
1479 1479 if not hasattr(sys,'last_traceback'):
1480 1480 error('No traceback has been produced, nothing to debug.')
1481 1481 return
1482 1482
1483 1483 # use pydb if available
1484 1484 if Debugger.has_pydb:
1485 1485 from pydb import pm
1486 1486 else:
1487 1487 # fallback to our internal debugger
1488 1488 pm = lambda : self.InteractiveTB.debugger(force=True)
1489 1489 self.history_saving_wrapper(pm)()
1490 1490
1491 1491 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1492 1492 """Display the exception that just occurred.
1493 1493
1494 1494 If nothing is known about the exception, this is the method which
1495 1495 should be used throughout the code for presenting user tracebacks,
1496 1496 rather than directly invoking the InteractiveTB object.
1497 1497
1498 1498 A specific showsyntaxerror() also exists, but this method can take
1499 1499 care of calling it if needed, so unless you are explicitly catching a
1500 1500 SyntaxError exception, don't try to analyze the stack manually and
1501 1501 simply call this method."""
1502 1502
1503 1503
1504 1504 # Though this won't be called by syntax errors in the input line,
1505 1505 # there may be SyntaxError cases whith imported code.
1506 1506
1507 1507
1508 1508 if exc_tuple is None:
1509 1509 etype, value, tb = sys.exc_info()
1510 1510 else:
1511 1511 etype, value, tb = exc_tuple
1512 1512
1513 1513 if etype is SyntaxError:
1514 1514 self.showsyntaxerror(filename)
1515 1515 elif etype is IPython.ipapi.UsageError:
1516 1516 print "UsageError:", value
1517 1517 else:
1518 1518 # WARNING: these variables are somewhat deprecated and not
1519 1519 # necessarily safe to use in a threaded environment, but tools
1520 1520 # like pdb depend on their existence, so let's set them. If we
1521 1521 # find problems in the field, we'll need to revisit their use.
1522 1522 sys.last_type = etype
1523 1523 sys.last_value = value
1524 1524 sys.last_traceback = tb
1525 1525
1526 1526 if etype in self.custom_exceptions:
1527 1527 self.CustomTB(etype,value,tb)
1528 1528 else:
1529 1529 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1530 1530 if self.InteractiveTB.call_pdb and self.has_readline:
1531 1531 # pdb mucks up readline, fix it back
1532 1532 self.set_completer()
1533 1533
1534 1534
1535 1535 def mainloop(self,banner=None):
1536 1536 """Creates the local namespace and starts the mainloop.
1537 1537
1538 1538 If an optional banner argument is given, it will override the
1539 1539 internally created default banner."""
1540 1540
1541 1541 if self.rc.c: # Emulate Python's -c option
1542 1542 self.exec_init_cmd()
1543 1543 if banner is None:
1544 1544 if not self.rc.banner:
1545 1545 banner = ''
1546 1546 # banner is string? Use it directly!
1547 1547 elif isinstance(self.rc.banner,basestring):
1548 1548 banner = self.rc.banner
1549 1549 else:
1550 1550 banner = self.BANNER+self.banner2
1551 1551
1552 1552 while 1:
1553 1553 try:
1554 1554 self.interact(banner)
1555 1555 break
1556 1556 except KeyboardInterrupt:
1557 1557 # this should not be necessary, but KeyboardInterrupt
1558 1558 # handling seems rather unpredictable...
1559 1559 self.write("\nKeyboardInterrupt in interact()\n")
1560 1560
1561 1561 def exec_init_cmd(self):
1562 1562 """Execute a command given at the command line.
1563 1563
1564 1564 This emulates Python's -c option."""
1565 1565
1566 1566 #sys.argv = ['-c']
1567 1567 self.push(self.prefilter(self.rc.c, False))
1568 1568 if not self.rc.interact:
1569 1569 self.exit_now = True
1570 1570
1571 1571 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1572 1572 """Embeds IPython into a running python program.
1573 1573
1574 1574 Input:
1575 1575
1576 1576 - header: An optional header message can be specified.
1577 1577
1578 1578 - local_ns, global_ns: working namespaces. If given as None, the
1579 1579 IPython-initialized one is updated with __main__.__dict__, so that
1580 1580 program variables become visible but user-specific configuration
1581 1581 remains possible.
1582 1582
1583 1583 - stack_depth: specifies how many levels in the stack to go to
1584 1584 looking for namespaces (when local_ns and global_ns are None). This
1585 1585 allows an intermediate caller to make sure that this function gets
1586 1586 the namespace from the intended level in the stack. By default (0)
1587 1587 it will get its locals and globals from the immediate caller.
1588 1588
1589 1589 Warning: it's possible to use this in a program which is being run by
1590 1590 IPython itself (via %run), but some funny things will happen (a few
1591 1591 globals get overwritten). In the future this will be cleaned up, as
1592 1592 there is no fundamental reason why it can't work perfectly."""
1593 1593
1594 1594 # Get locals and globals from caller
1595 1595 if local_ns is None or global_ns is None:
1596 1596 call_frame = sys._getframe(stack_depth).f_back
1597 1597
1598 1598 if local_ns is None:
1599 1599 local_ns = call_frame.f_locals
1600 1600 if global_ns is None:
1601 1601 global_ns = call_frame.f_globals
1602 1602
1603 1603 # Update namespaces and fire up interpreter
1604 1604
1605 1605 # The global one is easy, we can just throw it in
1606 1606 self.user_global_ns = global_ns
1607 1607
1608 1608 # but the user/local one is tricky: ipython needs it to store internal
1609 1609 # data, but we also need the locals. We'll copy locals in the user
1610 1610 # one, but will track what got copied so we can delete them at exit.
1611 1611 # This is so that a later embedded call doesn't see locals from a
1612 1612 # previous call (which most likely existed in a separate scope).
1613 1613 local_varnames = local_ns.keys()
1614 1614 self.user_ns.update(local_ns)
1615 1615
1616 1616 # Patch for global embedding to make sure that things don't overwrite
1617 1617 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1618 1618 # FIXME. Test this a bit more carefully (the if.. is new)
1619 1619 if local_ns is None and global_ns is None:
1620 1620 self.user_global_ns.update(__main__.__dict__)
1621 1621
1622 1622 # make sure the tab-completer has the correct frame information, so it
1623 1623 # actually completes using the frame's locals/globals
1624 1624 self.set_completer_frame()
1625 1625
1626 1626 # before activating the interactive mode, we need to make sure that
1627 1627 # all names in the builtin namespace needed by ipython point to
1628 1628 # ourselves, and not to other instances.
1629 1629 self.add_builtins()
1630 1630
1631 1631 self.interact(header)
1632 1632
1633 1633 # now, purge out the user namespace from anything we might have added
1634 1634 # from the caller's local namespace
1635 1635 delvar = self.user_ns.pop
1636 1636 for var in local_varnames:
1637 1637 delvar(var,None)
1638 1638 # and clean builtins we may have overridden
1639 1639 self.clean_builtins()
1640 1640
1641 1641 def interact(self, banner=None):
1642 1642 """Closely emulate the interactive Python console.
1643 1643
1644 1644 The optional banner argument specify the banner to print
1645 1645 before the first interaction; by default it prints a banner
1646 1646 similar to the one printed by the real Python interpreter,
1647 1647 followed by the current class name in parentheses (so as not
1648 1648 to confuse this with the real interpreter -- since it's so
1649 1649 close!).
1650 1650
1651 1651 """
1652 1652
1653 1653 if self.exit_now:
1654 1654 # batch run -> do not interact
1655 1655 return
1656 1656 cprt = 'Type "copyright", "credits" or "license" for more information.'
1657 1657 if banner is None:
1658 1658 self.write("Python %s on %s\n%s\n(%s)\n" %
1659 1659 (sys.version, sys.platform, cprt,
1660 1660 self.__class__.__name__))
1661 1661 else:
1662 1662 self.write(banner)
1663 1663
1664 1664 more = 0
1665 1665
1666 1666 # Mark activity in the builtins
1667 1667 __builtin__.__dict__['__IPYTHON__active'] += 1
1668 1668
1669 1669 if self.has_readline:
1670 1670 self.readline_startup_hook(self.pre_readline)
1671 1671 # exit_now is set by a call to %Exit or %Quit
1672 1672
1673 1673 while not self.exit_now:
1674 1674 if more:
1675 1675 try:
1676 1676 prompt = self.hooks.generate_prompt(True)
1677 1677 except:
1678 1678 self.showtraceback()
1679 1679 if self.autoindent:
1680 1680 self.rl_do_indent = True
1681 1681
1682 1682 else:
1683 1683 try:
1684 1684 prompt = self.hooks.generate_prompt(False)
1685 1685 except:
1686 1686 self.showtraceback()
1687 1687 try:
1688 1688 line = self.raw_input(prompt,more)
1689 1689 if self.exit_now:
1690 1690 # quick exit on sys.std[in|out] close
1691 1691 break
1692 1692 if self.autoindent:
1693 1693 self.rl_do_indent = False
1694 1694
1695 1695 except KeyboardInterrupt:
1696 1696 #double-guard against keyboardinterrupts during kbdint handling
1697 1697 try:
1698 1698 self.write('\nKeyboardInterrupt\n')
1699 1699 self.resetbuffer()
1700 1700 # keep cache in sync with the prompt counter:
1701 1701 self.outputcache.prompt_count -= 1
1702 1702
1703 1703 if self.autoindent:
1704 1704 self.indent_current_nsp = 0
1705 1705 more = 0
1706 1706 except KeyboardInterrupt:
1707 1707 pass
1708 1708 except EOFError:
1709 1709 if self.autoindent:
1710 1710 self.rl_do_indent = False
1711 1711 self.readline_startup_hook(None)
1712 1712 self.write('\n')
1713 1713 self.exit()
1714 1714 except bdb.BdbQuit:
1715 1715 warn('The Python debugger has exited with a BdbQuit exception.\n'
1716 1716 'Because of how pdb handles the stack, it is impossible\n'
1717 1717 'for IPython to properly format this particular exception.\n'
1718 1718 'IPython will resume normal operation.')
1719 1719 except:
1720 1720 # exceptions here are VERY RARE, but they can be triggered
1721 1721 # asynchronously by signal handlers, for example.
1722 1722 self.showtraceback()
1723 1723 else:
1724 1724 more = self.push(line)
1725 1725 if (self.SyntaxTB.last_syntax_error and
1726 1726 self.rc.autoedit_syntax):
1727 1727 self.edit_syntax_error()
1728 1728
1729 1729 # We are off again...
1730 1730 __builtin__.__dict__['__IPYTHON__active'] -= 1
1731 1731
1732 1732 def excepthook(self, etype, value, tb):
1733 1733 """One more defense for GUI apps that call sys.excepthook.
1734 1734
1735 1735 GUI frameworks like wxPython trap exceptions and call
1736 1736 sys.excepthook themselves. I guess this is a feature that
1737 1737 enables them to keep running after exceptions that would
1738 1738 otherwise kill their mainloop. This is a bother for IPython
1739 1739 which excepts to catch all of the program exceptions with a try:
1740 1740 except: statement.
1741 1741
1742 1742 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1743 1743 any app directly invokes sys.excepthook, it will look to the user like
1744 1744 IPython crashed. In order to work around this, we can disable the
1745 1745 CrashHandler and replace it with this excepthook instead, which prints a
1746 1746 regular traceback using our InteractiveTB. In this fashion, apps which
1747 1747 call sys.excepthook will generate a regular-looking exception from
1748 1748 IPython, and the CrashHandler will only be triggered by real IPython
1749 1749 crashes.
1750 1750
1751 1751 This hook should be used sparingly, only in places which are not likely
1752 1752 to be true IPython errors.
1753 1753 """
1754 1754 self.showtraceback((etype,value,tb),tb_offset=0)
1755 1755
1756 1756 def expand_aliases(self,fn,rest):
1757 1757 """ Expand multiple levels of aliases:
1758 1758
1759 1759 if:
1760 1760
1761 1761 alias foo bar /tmp
1762 1762 alias baz foo
1763 1763
1764 1764 then:
1765 1765
1766 1766 baz huhhahhei -> bar /tmp huhhahhei
1767 1767
1768 1768 """
1769 1769 line = fn + " " + rest
1770 1770
1771 1771 done = Set()
1772 1772 while 1:
1773 1773 pre,fn,rest = prefilter.splitUserInput(line,
1774 1774 prefilter.shell_line_split)
1775 1775 if fn in self.alias_table:
1776 1776 if fn in done:
1777 1777 warn("Cyclic alias definition, repeated '%s'" % fn)
1778 1778 return ""
1779 1779 done.add(fn)
1780 1780
1781 1781 l2 = self.transform_alias(fn,rest)
1782 1782 # dir -> dir
1783 1783 # print "alias",line, "->",l2 #dbg
1784 1784 if l2 == line:
1785 1785 break
1786 1786 # ls -> ls -F should not recurse forever
1787 1787 if l2.split(None,1)[0] == line.split(None,1)[0]:
1788 1788 line = l2
1789 1789 break
1790 1790
1791 1791 line=l2
1792 1792
1793 1793
1794 1794 # print "al expand to",line #dbg
1795 1795 else:
1796 1796 break
1797 1797
1798 1798 return line
1799 1799
1800 1800 def transform_alias(self, alias,rest=''):
1801 1801 """ Transform alias to system command string.
1802 1802 """
1803 1803 trg = self.alias_table[alias]
1804 1804
1805 1805 nargs,cmd = trg
1806 1806 # print trg #dbg
1807 1807 if ' ' in cmd and os.path.isfile(cmd):
1808 1808 cmd = '"%s"' % cmd
1809 1809
1810 1810 # Expand the %l special to be the user's input line
1811 1811 if cmd.find('%l') >= 0:
1812 1812 cmd = cmd.replace('%l',rest)
1813 1813 rest = ''
1814 1814 if nargs==0:
1815 1815 # Simple, argument-less aliases
1816 1816 cmd = '%s %s' % (cmd,rest)
1817 1817 else:
1818 1818 # Handle aliases with positional arguments
1819 1819 args = rest.split(None,nargs)
1820 1820 if len(args)< nargs:
1821 1821 error('Alias <%s> requires %s arguments, %s given.' %
1822 1822 (alias,nargs,len(args)))
1823 1823 return None
1824 1824 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1825 1825 # Now call the macro, evaluating in the user's namespace
1826 1826 #print 'new command: <%r>' % cmd # dbg
1827 1827 return cmd
1828 1828
1829 1829 def call_alias(self,alias,rest=''):
1830 1830 """Call an alias given its name and the rest of the line.
1831 1831
1832 1832 This is only used to provide backwards compatibility for users of
1833 1833 ipalias(), use of which is not recommended for anymore."""
1834 1834
1835 1835 # Now call the macro, evaluating in the user's namespace
1836 1836 cmd = self.transform_alias(alias, rest)
1837 1837 try:
1838 1838 self.system(cmd)
1839 1839 except:
1840 1840 self.showtraceback()
1841 1841
1842 1842 def indent_current_str(self):
1843 1843 """return the current level of indentation as a string"""
1844 1844 return self.indent_current_nsp * ' '
1845 1845
1846 1846 def autoindent_update(self,line):
1847 1847 """Keep track of the indent level."""
1848 1848
1849 1849 #debugx('line')
1850 1850 #debugx('self.indent_current_nsp')
1851 1851 if self.autoindent:
1852 1852 if line:
1853 1853 inisp = num_ini_spaces(line)
1854 1854 if inisp < self.indent_current_nsp:
1855 1855 self.indent_current_nsp = inisp
1856 1856
1857 1857 if line[-1] == ':':
1858 1858 self.indent_current_nsp += 4
1859 1859 elif dedent_re.match(line):
1860 1860 self.indent_current_nsp -= 4
1861 1861 else:
1862 1862 self.indent_current_nsp = 0
1863 1863
1864 1864 def runlines(self,lines):
1865 1865 """Run a string of one or more lines of source.
1866 1866
1867 1867 This method is capable of running a string containing multiple source
1868 1868 lines, as if they had been entered at the IPython prompt. Since it
1869 1869 exposes IPython's processing machinery, the given strings can contain
1870 1870 magic calls (%magic), special shell access (!cmd), etc."""
1871 1871
1872 1872 # We must start with a clean buffer, in case this is run from an
1873 1873 # interactive IPython session (via a magic, for example).
1874 1874 self.resetbuffer()
1875 1875 lines = lines.split('\n')
1876 1876 more = 0
1877 1877
1878 1878 for line in lines:
1879 1879 # skip blank lines so we don't mess up the prompt counter, but do
1880 1880 # NOT skip even a blank line if we are in a code block (more is
1881 1881 # true)
1882 1882
1883 1883
1884 1884 if line or more:
1885 1885 # push to raw history, so hist line numbers stay in sync
1886 1886 self.input_hist_raw.append("# " + line + "\n")
1887 1887 more = self.push(self.prefilter(line,more))
1888 1888 # IPython's runsource returns None if there was an error
1889 1889 # compiling the code. This allows us to stop processing right
1890 1890 # away, so the user gets the error message at the right place.
1891 1891 if more is None:
1892 1892 break
1893 1893 else:
1894 1894 self.input_hist_raw.append("\n")
1895 1895 # final newline in case the input didn't have it, so that the code
1896 1896 # actually does get executed
1897 1897 if more:
1898 1898 self.push('\n')
1899 1899
1900 1900 def runsource(self, source, filename='<input>', symbol='single'):
1901 1901 """Compile and run some source in the interpreter.
1902 1902
1903 1903 Arguments are as for compile_command().
1904 1904
1905 1905 One several things can happen:
1906 1906
1907 1907 1) The input is incorrect; compile_command() raised an
1908 1908 exception (SyntaxError or OverflowError). A syntax traceback
1909 1909 will be printed by calling the showsyntaxerror() method.
1910 1910
1911 1911 2) The input is incomplete, and more input is required;
1912 1912 compile_command() returned None. Nothing happens.
1913 1913
1914 1914 3) The input is complete; compile_command() returned a code
1915 1915 object. The code is executed by calling self.runcode() (which
1916 1916 also handles run-time exceptions, except for SystemExit).
1917 1917
1918 1918 The return value is:
1919 1919
1920 1920 - True in case 2
1921 1921
1922 1922 - False in the other cases, unless an exception is raised, where
1923 1923 None is returned instead. This can be used by external callers to
1924 1924 know whether to continue feeding input or not.
1925 1925
1926 1926 The return value can be used to decide whether to use sys.ps1 or
1927 1927 sys.ps2 to prompt the next line."""
1928 1928
1929 1929 # if the source code has leading blanks, add 'if 1:\n' to it
1930 1930 # this allows execution of indented pasted code. It is tempting
1931 1931 # to add '\n' at the end of source to run commands like ' a=1'
1932 1932 # directly, but this fails for more complicated scenarios
1933 1933 source=source.encode(self.stdin_encoding)
1934 1934 if source[:1] in [' ', '\t']:
1935 1935 source = 'if 1:\n%s' % source
1936 1936
1937 1937 try:
1938 1938 code = self.compile(source,filename,symbol)
1939 1939 except (OverflowError, SyntaxError, ValueError):
1940 1940 # Case 1
1941 1941 self.showsyntaxerror(filename)
1942 1942 return None
1943 1943
1944 1944 if code is None:
1945 1945 # Case 2
1946 1946 return True
1947 1947
1948 1948 # Case 3
1949 1949 # We store the code object so that threaded shells and
1950 1950 # custom exception handlers can access all this info if needed.
1951 1951 # The source corresponding to this can be obtained from the
1952 1952 # buffer attribute as '\n'.join(self.buffer).
1953 1953 self.code_to_run = code
1954 1954 # now actually execute the code object
1955 1955 if self.runcode(code) == 0:
1956 1956 return False
1957 1957 else:
1958 1958 return None
1959 1959
1960 1960 def runcode(self,code_obj):
1961 1961 """Execute a code object.
1962 1962
1963 1963 When an exception occurs, self.showtraceback() is called to display a
1964 1964 traceback.
1965 1965
1966 1966 Return value: a flag indicating whether the code to be run completed
1967 1967 successfully:
1968 1968
1969 1969 - 0: successful execution.
1970 1970 - 1: an error occurred.
1971 1971 """
1972 1972
1973 1973 # Set our own excepthook in case the user code tries to call it
1974 1974 # directly, so that the IPython crash handler doesn't get triggered
1975 1975 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
1976 1976
1977 1977 # we save the original sys.excepthook in the instance, in case config
1978 1978 # code (such as magics) needs access to it.
1979 1979 self.sys_excepthook = old_excepthook
1980 1980 outflag = 1 # happens in more places, so it's easier as default
1981 1981 try:
1982 1982 try:
1983 1983 # Embedded instances require separate global/local namespaces
1984 1984 # so they can see both the surrounding (local) namespace and
1985 1985 # the module-level globals when called inside another function.
1986 1986 if self.embedded:
1987 1987 exec code_obj in self.user_global_ns, self.user_ns
1988 1988 # Normal (non-embedded) instances should only have a single
1989 1989 # namespace for user code execution, otherwise functions won't
1990 1990 # see interactive top-level globals.
1991 1991 else:
1992 1992 exec code_obj in self.user_ns
1993 1993 finally:
1994 1994 # Reset our crash handler in place
1995 1995 sys.excepthook = old_excepthook
1996 1996 except SystemExit:
1997 1997 self.resetbuffer()
1998 1998 self.showtraceback()
1999 1999 warn("Type %exit or %quit to exit IPython "
2000 2000 "(%Exit or %Quit do so unconditionally).",level=1)
2001 2001 except self.custom_exceptions:
2002 2002 etype,value,tb = sys.exc_info()
2003 2003 self.CustomTB(etype,value,tb)
2004 2004 except:
2005 2005 self.showtraceback()
2006 2006 else:
2007 2007 outflag = 0
2008 2008 if softspace(sys.stdout, 0):
2009 2009 print
2010 2010 # Flush out code object which has been run (and source)
2011 2011 self.code_to_run = None
2012 2012 return outflag
2013 2013
2014 2014 def push(self, line):
2015 2015 """Push a line to the interpreter.
2016 2016
2017 2017 The line should not have a trailing newline; it may have
2018 2018 internal newlines. The line is appended to a buffer and the
2019 2019 interpreter's runsource() method is called with the
2020 2020 concatenated contents of the buffer as source. If this
2021 2021 indicates that the command was executed or invalid, the buffer
2022 2022 is reset; otherwise, the command is incomplete, and the buffer
2023 2023 is left as it was after the line was appended. The return
2024 2024 value is 1 if more input is required, 0 if the line was dealt
2025 2025 with in some way (this is the same as runsource()).
2026 2026 """
2027 2027
2028 2028 # autoindent management should be done here, and not in the
2029 2029 # interactive loop, since that one is only seen by keyboard input. We
2030 2030 # need this done correctly even for code run via runlines (which uses
2031 2031 # push).
2032 2032
2033 2033 #print 'push line: <%s>' % line # dbg
2034 2034 for subline in line.splitlines():
2035 2035 self.autoindent_update(subline)
2036 2036 self.buffer.append(line)
2037 2037 more = self.runsource('\n'.join(self.buffer), self.filename)
2038 2038 if not more:
2039 2039 self.resetbuffer()
2040 2040 return more
2041 2041
2042 2042 def split_user_input(self, line):
2043 2043 # This is really a hold-over to support ipapi and some extensions
2044 2044 return prefilter.splitUserInput(line)
2045 2045
2046 2046 def resetbuffer(self):
2047 2047 """Reset the input buffer."""
2048 2048 self.buffer[:] = []
2049 2049
2050 2050 def raw_input(self,prompt='',continue_prompt=False):
2051 2051 """Write a prompt and read a line.
2052 2052
2053 2053 The returned line does not include the trailing newline.
2054 2054 When the user enters the EOF key sequence, EOFError is raised.
2055 2055
2056 2056 Optional inputs:
2057 2057
2058 2058 - prompt(''): a string to be printed to prompt the user.
2059 2059
2060 2060 - continue_prompt(False): whether this line is the first one or a
2061 2061 continuation in a sequence of inputs.
2062 2062 """
2063 2063
2064 2064 # Code run by the user may have modified the readline completer state.
2065 2065 # We must ensure that our completer is back in place.
2066 2066 if self.has_readline:
2067 2067 self.set_completer()
2068 2068
2069 2069 try:
2070 2070 line = raw_input_original(prompt).decode(self.stdin_encoding)
2071 2071 except ValueError:
2072 2072 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2073 2073 " or sys.stdout.close()!\nExiting IPython!")
2074 2074 self.exit_now = True
2075 2075 return ""
2076 2076
2077 2077 # Try to be reasonably smart about not re-indenting pasted input more
2078 2078 # than necessary. We do this by trimming out the auto-indent initial
2079 2079 # spaces, if the user's actual input started itself with whitespace.
2080 2080 #debugx('self.buffer[-1]')
2081 2081
2082 2082 if self.autoindent:
2083 2083 if num_ini_spaces(line) > self.indent_current_nsp:
2084 2084 line = line[self.indent_current_nsp:]
2085 2085 self.indent_current_nsp = 0
2086 2086
2087 2087 # store the unfiltered input before the user has any chance to modify
2088 2088 # it.
2089 2089 if line.strip():
2090 2090 if continue_prompt:
2091 2091 self.input_hist_raw[-1] += '%s\n' % line
2092 2092 if self.has_readline: # and some config option is set?
2093 2093 try:
2094 2094 histlen = self.readline.get_current_history_length()
2095 if histlen > 1:
2095 2096 newhist = self.input_hist_raw[-1].rstrip()
2096 2097 self.readline.remove_history_item(histlen-1)
2097 2098 self.readline.replace_history_item(histlen-2,
2098 2099 newhist.encode(self.stdin_encoding))
2099 2100 except AttributeError:
2100 2101 pass # re{move,place}_history_item are new in 2.4.
2101 2102 else:
2102 2103 self.input_hist_raw.append('%s\n' % line)
2103 2104 # only entries starting at first column go to shadow history
2104 2105 if line.lstrip() == line:
2105 2106 self.shadowhist.add(line.strip())
2106 2107 elif not continue_prompt:
2107 2108 self.input_hist_raw.append('\n')
2108 2109 try:
2109 2110 lineout = self.prefilter(line,continue_prompt)
2110 2111 except:
2111 2112 # blanket except, in case a user-defined prefilter crashes, so it
2112 2113 # can't take all of ipython with it.
2113 2114 self.showtraceback()
2114 2115 return ''
2115 2116 else:
2116 2117 return lineout
2117 2118
2118 2119 def _prefilter(self, line, continue_prompt):
2119 2120 """Calls different preprocessors, depending on the form of line."""
2120 2121
2121 2122 # All handlers *must* return a value, even if it's blank ('').
2122 2123
2123 2124 # Lines are NOT logged here. Handlers should process the line as
2124 2125 # needed, update the cache AND log it (so that the input cache array
2125 2126 # stays synced).
2126 2127
2127 2128 #.....................................................................
2128 2129 # Code begins
2129 2130
2130 2131 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
2131 2132
2132 2133 # save the line away in case we crash, so the post-mortem handler can
2133 2134 # record it
2134 2135 self._last_input_line = line
2135 2136
2136 2137 #print '***line: <%s>' % line # dbg
2137 2138
2138 2139 if not line:
2139 2140 # Return immediately on purely empty lines, so that if the user
2140 2141 # previously typed some whitespace that started a continuation
2141 2142 # prompt, he can break out of that loop with just an empty line.
2142 2143 # This is how the default python prompt works.
2143 2144
2144 2145 # Only return if the accumulated input buffer was just whitespace!
2145 2146 if ''.join(self.buffer).isspace():
2146 2147 self.buffer[:] = []
2147 2148 return ''
2148 2149
2149 2150 line_info = prefilter.LineInfo(line, continue_prompt)
2150 2151
2151 2152 # the input history needs to track even empty lines
2152 2153 stripped = line.strip()
2153 2154
2154 2155 if not stripped:
2155 2156 if not continue_prompt:
2156 2157 self.outputcache.prompt_count -= 1
2157 2158 return self.handle_normal(line_info)
2158 2159
2159 2160 # print '***cont',continue_prompt # dbg
2160 2161 # special handlers are only allowed for single line statements
2161 2162 if continue_prompt and not self.rc.multi_line_specials:
2162 2163 return self.handle_normal(line_info)
2163 2164
2164 2165
2165 2166 # See whether any pre-existing handler can take care of it
2166 2167 rewritten = self.hooks.input_prefilter(stripped)
2167 2168 if rewritten != stripped: # ok, some prefilter did something
2168 2169 rewritten = line_info.pre + rewritten # add indentation
2169 2170 return self.handle_normal(prefilter.LineInfo(rewritten,
2170 2171 continue_prompt))
2171 2172
2172 2173 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2173 2174
2174 2175 return prefilter.prefilter(line_info, self)
2175 2176
2176 2177
2177 2178 def _prefilter_dumb(self, line, continue_prompt):
2178 2179 """simple prefilter function, for debugging"""
2179 2180 return self.handle_normal(line,continue_prompt)
2180 2181
2181 2182
2182 2183 def multiline_prefilter(self, line, continue_prompt):
2183 2184 """ Run _prefilter for each line of input
2184 2185
2185 2186 Covers cases where there are multiple lines in the user entry,
2186 2187 which is the case when the user goes back to a multiline history
2187 2188 entry and presses enter.
2188 2189
2189 2190 """
2190 2191 out = []
2191 2192 for l in line.rstrip('\n').split('\n'):
2192 2193 out.append(self._prefilter(l, continue_prompt))
2193 2194 return '\n'.join(out)
2194 2195
2195 2196 # Set the default prefilter() function (this can be user-overridden)
2196 2197 prefilter = multiline_prefilter
2197 2198
2198 2199 def handle_normal(self,line_info):
2199 2200 """Handle normal input lines. Use as a template for handlers."""
2200 2201
2201 2202 # With autoindent on, we need some way to exit the input loop, and I
2202 2203 # don't want to force the user to have to backspace all the way to
2203 2204 # clear the line. The rule will be in this case, that either two
2204 2205 # lines of pure whitespace in a row, or a line of pure whitespace but
2205 2206 # of a size different to the indent level, will exit the input loop.
2206 2207 line = line_info.line
2207 2208 continue_prompt = line_info.continue_prompt
2208 2209
2209 2210 if (continue_prompt and self.autoindent and line.isspace() and
2210 2211 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2211 2212 (self.buffer[-1]).isspace() )):
2212 2213 line = ''
2213 2214
2214 2215 self.log(line,line,continue_prompt)
2215 2216 return line
2216 2217
2217 2218 def handle_alias(self,line_info):
2218 2219 """Handle alias input lines. """
2219 2220 tgt = self.alias_table[line_info.iFun]
2220 2221 # print "=>",tgt #dbg
2221 2222 if callable(tgt):
2222 2223 if '$' in line_info.line:
2223 2224 call_meth = '(_ip, _ip.itpl(%s))'
2224 2225 else:
2225 2226 call_meth = '(_ip,%s)'
2226 2227 line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
2227 2228 line_info.iFun,
2228 2229 make_quoted_expr(line_info.line))
2229 2230 else:
2230 2231 transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
2231 2232
2232 2233 # pre is needed, because it carries the leading whitespace. Otherwise
2233 2234 # aliases won't work in indented sections.
2234 2235 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2235 2236 make_quoted_expr( transformed ))
2236 2237
2237 2238 self.log(line_info.line,line_out,line_info.continue_prompt)
2238 2239 #print 'line out:',line_out # dbg
2239 2240 return line_out
2240 2241
2241 2242 def handle_shell_escape(self, line_info):
2242 2243 """Execute the line in a shell, empty return value"""
2243 2244 #print 'line in :', `line` # dbg
2244 2245 line = line_info.line
2245 2246 if line.lstrip().startswith('!!'):
2246 2247 # rewrite LineInfo's line, iFun and theRest to properly hold the
2247 2248 # call to %sx and the actual command to be executed, so
2248 2249 # handle_magic can work correctly. Note that this works even if
2249 2250 # the line is indented, so it handles multi_line_specials
2250 2251 # properly.
2251 2252 new_rest = line.lstrip()[2:]
2252 2253 line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
2253 2254 line_info.iFun = 'sx'
2254 2255 line_info.theRest = new_rest
2255 2256 return self.handle_magic(line_info)
2256 2257 else:
2257 2258 cmd = line.lstrip().lstrip('!')
2258 2259 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2259 2260 make_quoted_expr(cmd))
2260 2261 # update cache/log and return
2261 2262 self.log(line,line_out,line_info.continue_prompt)
2262 2263 return line_out
2263 2264
2264 2265 def handle_magic(self, line_info):
2265 2266 """Execute magic functions."""
2266 2267 iFun = line_info.iFun
2267 2268 theRest = line_info.theRest
2268 2269 cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
2269 2270 make_quoted_expr(iFun + " " + theRest))
2270 2271 self.log(line_info.line,cmd,line_info.continue_prompt)
2271 2272 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2272 2273 return cmd
2273 2274
2274 2275 def handle_auto(self, line_info):
2275 2276 """Hande lines which can be auto-executed, quoting if requested."""
2276 2277
2277 2278 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2278 2279 line = line_info.line
2279 2280 iFun = line_info.iFun
2280 2281 theRest = line_info.theRest
2281 2282 pre = line_info.pre
2282 2283 continue_prompt = line_info.continue_prompt
2283 2284 obj = line_info.ofind(self)['obj']
2284 2285
2285 2286 # This should only be active for single-line input!
2286 2287 if continue_prompt:
2287 2288 self.log(line,line,continue_prompt)
2288 2289 return line
2289 2290
2290 2291 force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
2291 2292 auto_rewrite = True
2292 2293
2293 2294 if pre == self.ESC_QUOTE:
2294 2295 # Auto-quote splitting on whitespace
2295 2296 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2296 2297 elif pre == self.ESC_QUOTE2:
2297 2298 # Auto-quote whole string
2298 2299 newcmd = '%s("%s")' % (iFun,theRest)
2299 2300 elif pre == self.ESC_PAREN:
2300 2301 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2301 2302 else:
2302 2303 # Auto-paren.
2303 2304 # We only apply it to argument-less calls if the autocall
2304 2305 # parameter is set to 2. We only need to check that autocall is <
2305 2306 # 2, since this function isn't called unless it's at least 1.
2306 2307 if not theRest and (self.rc.autocall < 2) and not force_auto:
2307 2308 newcmd = '%s %s' % (iFun,theRest)
2308 2309 auto_rewrite = False
2309 2310 else:
2310 2311 if not force_auto and theRest.startswith('['):
2311 2312 if hasattr(obj,'__getitem__'):
2312 2313 # Don't autocall in this case: item access for an object
2313 2314 # which is BOTH callable and implements __getitem__.
2314 2315 newcmd = '%s %s' % (iFun,theRest)
2315 2316 auto_rewrite = False
2316 2317 else:
2317 2318 # if the object doesn't support [] access, go ahead and
2318 2319 # autocall
2319 2320 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2320 2321 elif theRest.endswith(';'):
2321 2322 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2322 2323 else:
2323 2324 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2324 2325
2325 2326 if auto_rewrite:
2326 2327 rw = self.outputcache.prompt1.auto_rewrite() + newcmd
2327 2328
2328 2329 try:
2329 2330 # plain ascii works better w/ pyreadline, on some machines, so
2330 2331 # we use it and only print uncolored rewrite if we have unicode
2331 2332 rw = str(rw)
2332 2333 print >>Term.cout, rw
2333 2334 except UnicodeEncodeError:
2334 2335 print "-------------->" + newcmd
2335 2336
2336 2337 # log what is now valid Python, not the actual user input (without the
2337 2338 # final newline)
2338 2339 self.log(line,newcmd,continue_prompt)
2339 2340 return newcmd
2340 2341
2341 2342 def handle_help(self, line_info):
2342 2343 """Try to get some help for the object.
2343 2344
2344 2345 obj? or ?obj -> basic information.
2345 2346 obj?? or ??obj -> more details.
2346 2347 """
2347 2348
2348 2349 line = line_info.line
2349 2350 # We need to make sure that we don't process lines which would be
2350 2351 # otherwise valid python, such as "x=1 # what?"
2351 2352 try:
2352 2353 codeop.compile_command(line)
2353 2354 except SyntaxError:
2354 2355 # We should only handle as help stuff which is NOT valid syntax
2355 2356 if line[0]==self.ESC_HELP:
2356 2357 line = line[1:]
2357 2358 elif line[-1]==self.ESC_HELP:
2358 2359 line = line[:-1]
2359 2360 self.log(line,'#?'+line,line_info.continue_prompt)
2360 2361 if line:
2361 2362 #print 'line:<%r>' % line # dbg
2362 2363 self.magic_pinfo(line)
2363 2364 else:
2364 2365 page(self.usage,screen_lines=self.rc.screen_length)
2365 2366 return '' # Empty string is needed here!
2366 2367 except:
2367 2368 # Pass any other exceptions through to the normal handler
2368 2369 return self.handle_normal(line_info)
2369 2370 else:
2370 2371 # If the code compiles ok, we should handle it normally
2371 2372 return self.handle_normal(line_info)
2372 2373
2373 2374 def getapi(self):
2374 2375 """ Get an IPApi object for this shell instance
2375 2376
2376 2377 Getting an IPApi object is always preferable to accessing the shell
2377 2378 directly, but this holds true especially for extensions.
2378 2379
2379 2380 It should always be possible to implement an extension with IPApi
2380 2381 alone. If not, contact maintainer to request an addition.
2381 2382
2382 2383 """
2383 2384 return self.api
2384 2385
2385 2386 def handle_emacs(self, line_info):
2386 2387 """Handle input lines marked by python-mode."""
2387 2388
2388 2389 # Currently, nothing is done. Later more functionality can be added
2389 2390 # here if needed.
2390 2391
2391 2392 # The input cache shouldn't be updated
2392 2393 return line_info.line
2393 2394
2394 2395
2395 2396 def mktempfile(self,data=None):
2396 2397 """Make a new tempfile and return its filename.
2397 2398
2398 2399 This makes a call to tempfile.mktemp, but it registers the created
2399 2400 filename internally so ipython cleans it up at exit time.
2400 2401
2401 2402 Optional inputs:
2402 2403
2403 2404 - data(None): if data is given, it gets written out to the temp file
2404 2405 immediately, and the file is closed again."""
2405 2406
2406 2407 filename = tempfile.mktemp('.py','ipython_edit_')
2407 2408 self.tempfiles.append(filename)
2408 2409
2409 2410 if data:
2410 2411 tmp_file = open(filename,'w')
2411 2412 tmp_file.write(data)
2412 2413 tmp_file.close()
2413 2414 return filename
2414 2415
2415 2416 def write(self,data):
2416 2417 """Write a string to the default output"""
2417 2418 Term.cout.write(data)
2418 2419
2419 2420 def write_err(self,data):
2420 2421 """Write a string to the default error output"""
2421 2422 Term.cerr.write(data)
2422 2423
2423 2424 def exit(self):
2424 2425 """Handle interactive exit.
2425 2426
2426 2427 This method sets the exit_now attribute."""
2427 2428
2428 2429 if self.rc.confirm_exit:
2429 2430 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2430 2431 self.exit_now = True
2431 2432 else:
2432 2433 self.exit_now = True
2433 2434
2434 2435 def safe_execfile(self,fname,*where,**kw):
2435 2436 """A safe version of the builtin execfile().
2436 2437
2437 2438 This version will never throw an exception, and knows how to handle
2438 2439 ipython logs as well.
2439 2440
2440 2441 :Parameters:
2441 2442 fname : string
2442 2443 Name of the file to be executed.
2443 2444
2444 2445 where : tuple
2445 2446 One or two namespaces, passed to execfile() as (globals,locals).
2446 2447 If only one is given, it is passed as both.
2447 2448
2448 2449 :Keywords:
2449 2450 islog : boolean (False)
2450 2451
2451 2452 quiet : boolean (True)
2452 2453
2453 2454 exit_ignore : boolean (False)
2454 2455 """
2455 2456
2456 2457 def syspath_cleanup():
2457 2458 """Internal cleanup routine for sys.path."""
2458 2459 if add_dname:
2459 2460 try:
2460 2461 sys.path.remove(dname)
2461 2462 except ValueError:
2462 2463 # For some reason the user has already removed it, ignore.
2463 2464 pass
2464 2465
2465 2466 fname = os.path.expanduser(fname)
2466 2467
2467 2468 # Find things also in current directory. This is needed to mimic the
2468 2469 # behavior of running a script from the system command line, where
2469 2470 # Python inserts the script's directory into sys.path
2470 2471 dname = os.path.dirname(os.path.abspath(fname))
2471 2472 add_dname = False
2472 2473 if dname not in sys.path:
2473 2474 sys.path.insert(0,dname)
2474 2475 add_dname = True
2475 2476
2476 2477 try:
2477 2478 xfile = open(fname)
2478 2479 except:
2479 2480 print >> Term.cerr, \
2480 2481 'Could not open file <%s> for safe execution.' % fname
2481 2482 syspath_cleanup()
2482 2483 return None
2483 2484
2484 2485 kw.setdefault('islog',0)
2485 2486 kw.setdefault('quiet',1)
2486 2487 kw.setdefault('exit_ignore',0)
2487 2488
2488 2489 first = xfile.readline()
2489 2490 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2490 2491 xfile.close()
2491 2492 # line by line execution
2492 2493 if first.startswith(loghead) or kw['islog']:
2493 2494 print 'Loading log file <%s> one line at a time...' % fname
2494 2495 if kw['quiet']:
2495 2496 stdout_save = sys.stdout
2496 2497 sys.stdout = StringIO.StringIO()
2497 2498 try:
2498 2499 globs,locs = where[0:2]
2499 2500 except:
2500 2501 try:
2501 2502 globs = locs = where[0]
2502 2503 except:
2503 2504 globs = locs = globals()
2504 2505 badblocks = []
2505 2506
2506 2507 # we also need to identify indented blocks of code when replaying
2507 2508 # logs and put them together before passing them to an exec
2508 2509 # statement. This takes a bit of regexp and look-ahead work in the
2509 2510 # file. It's easiest if we swallow the whole thing in memory
2510 2511 # first, and manually walk through the lines list moving the
2511 2512 # counter ourselves.
2512 2513 indent_re = re.compile('\s+\S')
2513 2514 xfile = open(fname)
2514 2515 filelines = xfile.readlines()
2515 2516 xfile.close()
2516 2517 nlines = len(filelines)
2517 2518 lnum = 0
2518 2519 while lnum < nlines:
2519 2520 line = filelines[lnum]
2520 2521 lnum += 1
2521 2522 # don't re-insert logger status info into cache
2522 2523 if line.startswith('#log#'):
2523 2524 continue
2524 2525 else:
2525 2526 # build a block of code (maybe a single line) for execution
2526 2527 block = line
2527 2528 try:
2528 2529 next = filelines[lnum] # lnum has already incremented
2529 2530 except:
2530 2531 next = None
2531 2532 while next and indent_re.match(next):
2532 2533 block += next
2533 2534 lnum += 1
2534 2535 try:
2535 2536 next = filelines[lnum]
2536 2537 except:
2537 2538 next = None
2538 2539 # now execute the block of one or more lines
2539 2540 try:
2540 2541 exec block in globs,locs
2541 2542 except SystemExit:
2542 2543 pass
2543 2544 except:
2544 2545 badblocks.append(block.rstrip())
2545 2546 if kw['quiet']: # restore stdout
2546 2547 sys.stdout.close()
2547 2548 sys.stdout = stdout_save
2548 2549 print 'Finished replaying log file <%s>' % fname
2549 2550 if badblocks:
2550 2551 print >> sys.stderr, ('\nThe following lines/blocks in file '
2551 2552 '<%s> reported errors:' % fname)
2552 2553
2553 2554 for badline in badblocks:
2554 2555 print >> sys.stderr, badline
2555 2556 else: # regular file execution
2556 2557 try:
2557 2558 if sys.platform == 'win32' and sys.version_info < (2,5,1):
2558 2559 # Work around a bug in Python for Windows. The bug was
2559 2560 # fixed in in Python 2.5 r54159 and 54158, but that's still
2560 2561 # SVN Python as of March/07. For details, see:
2561 2562 # http://projects.scipy.org/ipython/ipython/ticket/123
2562 2563 try:
2563 2564 globs,locs = where[0:2]
2564 2565 except:
2565 2566 try:
2566 2567 globs = locs = where[0]
2567 2568 except:
2568 2569 globs = locs = globals()
2569 2570 exec file(fname) in globs,locs
2570 2571 else:
2571 2572 execfile(fname,*where)
2572 2573 except SyntaxError:
2573 2574 self.showsyntaxerror()
2574 2575 warn('Failure executing file: <%s>' % fname)
2575 2576 except SystemExit,status:
2576 2577 # Code that correctly sets the exit status flag to success (0)
2577 2578 # shouldn't be bothered with a traceback. Note that a plain
2578 2579 # sys.exit() does NOT set the message to 0 (it's empty) so that
2579 2580 # will still get a traceback. Note that the structure of the
2580 2581 # SystemExit exception changed between Python 2.4 and 2.5, so
2581 2582 # the checks must be done in a version-dependent way.
2582 2583 show = False
2583 2584
2584 2585 if sys.version_info[:2] > (2,5):
2585 2586 if status.message!=0 and not kw['exit_ignore']:
2586 2587 show = True
2587 2588 else:
2588 2589 if status.code and not kw['exit_ignore']:
2589 2590 show = True
2590 2591 if show:
2591 2592 self.showtraceback()
2592 2593 warn('Failure executing file: <%s>' % fname)
2593 2594 except:
2594 2595 self.showtraceback()
2595 2596 warn('Failure executing file: <%s>' % fname)
2596 2597
2597 2598 syspath_cleanup()
2598 2599
2599 2600 #************************* end of file <iplib.py> *****************************
General Comments 0
You need to be logged in to leave comments. Login now