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