##// END OF EJS Templates
Fix crash when input: foo(**dict(k,d[k] for k in vn))
vivainio2 -
Show More
@@ -1,2681 +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 1271 try:
1272 1272 self.readline.clear_history()
1273 1273 self.readline.read_history_file(self.shell.histfile)
1274 1274 except AttributeError:
1275 1275 pass
1276 1276
1277 1277
1278 1278 def history_saving_wrapper(self, func):
1279 1279 """ Wrap func for readline history saving
1280 1280
1281 1281 Convert func into callable that saves & restores
1282 1282 history around the call """
1283 1283
1284 1284 if not self.has_readline:
1285 1285 return func
1286 1286
1287 1287 def wrapper():
1288 1288 self.savehist()
1289 1289 try:
1290 1290 func()
1291 1291 finally:
1292 1292 readline.read_history_file(self.histfile)
1293 1293 return wrapper
1294 1294
1295 1295
1296 1296 def pre_readline(self):
1297 1297 """readline hook to be used at the start of each line.
1298 1298
1299 1299 Currently it handles auto-indent only."""
1300 1300
1301 1301 #debugx('self.indent_current_nsp','pre_readline:')
1302 1302
1303 1303 if self.rl_do_indent:
1304 1304 self.readline.insert_text(self.indent_current_str())
1305 1305 if self.rl_next_input is not None:
1306 1306 self.readline.insert_text(self.rl_next_input)
1307 1307 self.rl_next_input = None
1308 1308
1309 1309 def init_readline(self):
1310 1310 """Command history completion/saving/reloading."""
1311 1311
1312 1312
1313 1313 import IPython.rlineimpl as readline
1314 1314
1315 1315 if not readline.have_readline:
1316 1316 self.has_readline = 0
1317 1317 self.readline = None
1318 1318 # no point in bugging windows users with this every time:
1319 1319 warn('Readline services not available on this platform.')
1320 1320 else:
1321 1321 sys.modules['readline'] = readline
1322 1322 import atexit
1323 1323 from IPython.completer import IPCompleter
1324 1324 self.Completer = IPCompleter(self,
1325 1325 self.user_ns,
1326 1326 self.user_global_ns,
1327 1327 self.rc.readline_omit__names,
1328 1328 self.alias_table)
1329 1329 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1330 1330 self.strdispatchers['complete_command'] = sdisp
1331 1331 self.Completer.custom_completers = sdisp
1332 1332 # Platform-specific configuration
1333 1333 if os.name == 'nt':
1334 1334 self.readline_startup_hook = readline.set_pre_input_hook
1335 1335 else:
1336 1336 self.readline_startup_hook = readline.set_startup_hook
1337 1337
1338 1338 # Load user's initrc file (readline config)
1339 1339 # Or if libedit is used, load editrc.
1340 1340 inputrc_name = os.environ.get('INPUTRC')
1341 1341 if inputrc_name is None:
1342 1342 home_dir = get_home_dir()
1343 1343 if home_dir is not None:
1344 1344 inputrc_name = '.inputrc'
1345 1345 if readline.uses_libedit:
1346 1346 inputrc_name = '.editrc'
1347 1347 inputrc_name = os.path.join(home_dir, inputrc_name)
1348 1348 if os.path.isfile(inputrc_name):
1349 1349 try:
1350 1350 readline.read_init_file(inputrc_name)
1351 1351 except:
1352 1352 warn('Problems reading readline initialization file <%s>'
1353 1353 % inputrc_name)
1354 1354
1355 1355 self.has_readline = 1
1356 1356 self.readline = readline
1357 1357 # save this in sys so embedded copies can restore it properly
1358 1358 sys.ipcompleter = self.Completer.complete
1359 1359 self.set_completer()
1360 1360
1361 1361 # Configure readline according to user's prefs
1362 1362 # This is only done if GNU readline is being used. If libedit
1363 1363 # is being used (as on Leopard) the readline config is
1364 1364 # not run as the syntax for libedit is different.
1365 1365 if not readline.uses_libedit:
1366 1366 for rlcommand in self.rc.readline_parse_and_bind:
1367 1367 readline.parse_and_bind(rlcommand)
1368 1368
1369 1369 # remove some chars from the delimiters list
1370 1370 delims = readline.get_completer_delims()
1371 1371 delims = delims.translate(string._idmap,
1372 1372 self.rc.readline_remove_delims)
1373 1373 readline.set_completer_delims(delims)
1374 1374 # otherwise we end up with a monster history after a while:
1375 1375 readline.set_history_length(1000)
1376 1376 try:
1377 1377 #print '*** Reading readline history' # dbg
1378 1378 readline.read_history_file(self.histfile)
1379 1379 except IOError:
1380 1380 pass # It doesn't exist yet.
1381 1381
1382 1382 atexit.register(self.atexit_operations)
1383 1383 del atexit
1384 1384
1385 1385 # Configure auto-indent for all platforms
1386 1386 self.set_autoindent(self.rc.autoindent)
1387 1387
1388 1388 def ask_yes_no(self,prompt,default=True):
1389 1389 if self.rc.quiet:
1390 1390 return True
1391 1391 return ask_yes_no(prompt,default)
1392 1392
1393 1393 def _should_recompile(self,e):
1394 1394 """Utility routine for edit_syntax_error"""
1395 1395
1396 1396 if e.filename in ('<ipython console>','<input>','<string>',
1397 1397 '<console>','<BackgroundJob compilation>',
1398 1398 None):
1399 1399
1400 1400 return False
1401 1401 try:
1402 1402 if (self.rc.autoedit_syntax and
1403 1403 not self.ask_yes_no('Return to editor to correct syntax error? '
1404 1404 '[Y/n] ','y')):
1405 1405 return False
1406 1406 except EOFError:
1407 1407 return False
1408 1408
1409 1409 def int0(x):
1410 1410 try:
1411 1411 return int(x)
1412 1412 except TypeError:
1413 1413 return 0
1414 1414 # always pass integer line and offset values to editor hook
1415 1415 self.hooks.fix_error_editor(e.filename,
1416 1416 int0(e.lineno),int0(e.offset),e.msg)
1417 1417 return True
1418 1418
1419 1419 def edit_syntax_error(self):
1420 1420 """The bottom half of the syntax error handler called in the main loop.
1421 1421
1422 1422 Loop until syntax error is fixed or user cancels.
1423 1423 """
1424 1424
1425 1425 while self.SyntaxTB.last_syntax_error:
1426 1426 # copy and clear last_syntax_error
1427 1427 err = self.SyntaxTB.clear_err_state()
1428 1428 if not self._should_recompile(err):
1429 1429 return
1430 1430 try:
1431 1431 # may set last_syntax_error again if a SyntaxError is raised
1432 1432 self.safe_execfile(err.filename,self.user_ns)
1433 1433 except:
1434 1434 self.showtraceback()
1435 1435 else:
1436 1436 try:
1437 1437 f = file(err.filename)
1438 1438 try:
1439 1439 sys.displayhook(f.read())
1440 1440 finally:
1441 1441 f.close()
1442 1442 except:
1443 1443 self.showtraceback()
1444 1444
1445 1445 def showsyntaxerror(self, filename=None):
1446 1446 """Display the syntax error that just occurred.
1447 1447
1448 1448 This doesn't display a stack trace because there isn't one.
1449 1449
1450 1450 If a filename is given, it is stuffed in the exception instead
1451 1451 of what was there before (because Python's parser always uses
1452 1452 "<string>" when reading from a string).
1453 1453 """
1454 1454 etype, value, last_traceback = sys.exc_info()
1455 1455
1456 1456 # See note about these variables in showtraceback() below
1457 1457 sys.last_type = etype
1458 1458 sys.last_value = value
1459 1459 sys.last_traceback = last_traceback
1460 1460
1461 1461 if filename and etype is SyntaxError:
1462 1462 # Work hard to stuff the correct filename in the exception
1463 1463 try:
1464 1464 msg, (dummy_filename, lineno, offset, line) = value
1465 1465 except:
1466 1466 # Not the format we expect; leave it alone
1467 1467 pass
1468 1468 else:
1469 1469 # Stuff in the right filename
1470 1470 try:
1471 1471 # Assume SyntaxError is a class exception
1472 1472 value = SyntaxError(msg, (filename, lineno, offset, line))
1473 1473 except:
1474 1474 # If that failed, assume SyntaxError is a string
1475 1475 value = msg, (filename, lineno, offset, line)
1476 1476 self.SyntaxTB(etype,value,[])
1477 1477
1478 1478 def debugger(self,force=False):
1479 1479 """Call the pydb/pdb debugger.
1480 1480
1481 1481 Keywords:
1482 1482
1483 1483 - force(False): by default, this routine checks the instance call_pdb
1484 1484 flag and does not actually invoke the debugger if the flag is false.
1485 1485 The 'force' option forces the debugger to activate even if the flag
1486 1486 is false.
1487 1487 """
1488 1488
1489 1489 if not (force or self.call_pdb):
1490 1490 return
1491 1491
1492 1492 if not hasattr(sys,'last_traceback'):
1493 1493 error('No traceback has been produced, nothing to debug.')
1494 1494 return
1495 1495
1496 1496 # use pydb if available
1497 1497 if Debugger.has_pydb:
1498 1498 from pydb import pm
1499 1499 else:
1500 1500 # fallback to our internal debugger
1501 1501 pm = lambda : self.InteractiveTB.debugger(force=True)
1502 1502 self.history_saving_wrapper(pm)()
1503 1503
1504 1504 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
1505 1505 """Display the exception that just occurred.
1506 1506
1507 1507 If nothing is known about the exception, this is the method which
1508 1508 should be used throughout the code for presenting user tracebacks,
1509 1509 rather than directly invoking the InteractiveTB object.
1510 1510
1511 1511 A specific showsyntaxerror() also exists, but this method can take
1512 1512 care of calling it if needed, so unless you are explicitly catching a
1513 1513 SyntaxError exception, don't try to analyze the stack manually and
1514 1514 simply call this method."""
1515 1515
1516 1516
1517 1517 # Though this won't be called by syntax errors in the input line,
1518 1518 # there may be SyntaxError cases whith imported code.
1519 1519
1520 1520 try:
1521 1521 if exc_tuple is None:
1522 1522 etype, value, tb = sys.exc_info()
1523 1523 else:
1524 1524 etype, value, tb = exc_tuple
1525 1525
1526 1526 if etype is SyntaxError:
1527 1527 self.showsyntaxerror(filename)
1528 1528 elif etype is IPython.ipapi.UsageError:
1529 1529 print "UsageError:", value
1530 1530 else:
1531 1531 # WARNING: these variables are somewhat deprecated and not
1532 1532 # necessarily safe to use in a threaded environment, but tools
1533 1533 # like pdb depend on their existence, so let's set them. If we
1534 1534 # find problems in the field, we'll need to revisit their use.
1535 1535 sys.last_type = etype
1536 1536 sys.last_value = value
1537 1537 sys.last_traceback = tb
1538 1538
1539 1539 if etype in self.custom_exceptions:
1540 1540 self.CustomTB(etype,value,tb)
1541 1541 else:
1542 1542 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1543 1543 if self.InteractiveTB.call_pdb and self.has_readline:
1544 1544 # pdb mucks up readline, fix it back
1545 1545 self.set_completer()
1546 1546 except KeyboardInterrupt:
1547 1547 self.write("\nKeyboardInterrupt\n")
1548 1548
1549 1549
1550 1550
1551 1551 def mainloop(self,banner=None):
1552 1552 """Creates the local namespace and starts the mainloop.
1553 1553
1554 1554 If an optional banner argument is given, it will override the
1555 1555 internally created default banner."""
1556 1556
1557 1557 if self.rc.c: # Emulate Python's -c option
1558 1558 self.exec_init_cmd()
1559 1559 if banner is None:
1560 1560 if not self.rc.banner:
1561 1561 banner = ''
1562 1562 # banner is string? Use it directly!
1563 1563 elif isinstance(self.rc.banner,basestring):
1564 1564 banner = self.rc.banner
1565 1565 else:
1566 1566 banner = self.BANNER+self.banner2
1567 1567
1568 1568 while 1:
1569 1569 try:
1570 1570 self.interact(banner)
1571 1571 #self.interact_with_readline()
1572 1572 # XXX for testing of a readline-decoupled repl loop, call interact_with_readline above
1573 1573
1574 1574 break
1575 1575 except KeyboardInterrupt:
1576 1576 # this should not be necessary, but KeyboardInterrupt
1577 1577 # handling seems rather unpredictable...
1578 1578 self.write("\nKeyboardInterrupt in interact()\n")
1579 1579
1580 1580 def exec_init_cmd(self):
1581 1581 """Execute a command given at the command line.
1582 1582
1583 1583 This emulates Python's -c option."""
1584 1584
1585 1585 #sys.argv = ['-c']
1586 1586 self.push(self.prefilter(self.rc.c, False))
1587 1587 if not self.rc.interact:
1588 1588 self.exit_now = True
1589 1589
1590 1590 def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
1591 1591 """Embeds IPython into a running python program.
1592 1592
1593 1593 Input:
1594 1594
1595 1595 - header: An optional header message can be specified.
1596 1596
1597 1597 - local_ns, global_ns: working namespaces. If given as None, the
1598 1598 IPython-initialized one is updated with __main__.__dict__, so that
1599 1599 program variables become visible but user-specific configuration
1600 1600 remains possible.
1601 1601
1602 1602 - stack_depth: specifies how many levels in the stack to go to
1603 1603 looking for namespaces (when local_ns and global_ns are None). This
1604 1604 allows an intermediate caller to make sure that this function gets
1605 1605 the namespace from the intended level in the stack. By default (0)
1606 1606 it will get its locals and globals from the immediate caller.
1607 1607
1608 1608 Warning: it's possible to use this in a program which is being run by
1609 1609 IPython itself (via %run), but some funny things will happen (a few
1610 1610 globals get overwritten). In the future this will be cleaned up, as
1611 1611 there is no fundamental reason why it can't work perfectly."""
1612 1612
1613 1613 # Get locals and globals from caller
1614 1614 if local_ns is None or global_ns is None:
1615 1615 call_frame = sys._getframe(stack_depth).f_back
1616 1616
1617 1617 if local_ns is None:
1618 1618 local_ns = call_frame.f_locals
1619 1619 if global_ns is None:
1620 1620 global_ns = call_frame.f_globals
1621 1621
1622 1622 # Update namespaces and fire up interpreter
1623 1623
1624 1624 # The global one is easy, we can just throw it in
1625 1625 self.user_global_ns = global_ns
1626 1626
1627 1627 # but the user/local one is tricky: ipython needs it to store internal
1628 1628 # data, but we also need the locals. We'll copy locals in the user
1629 1629 # one, but will track what got copied so we can delete them at exit.
1630 1630 # This is so that a later embedded call doesn't see locals from a
1631 1631 # previous call (which most likely existed in a separate scope).
1632 1632 local_varnames = local_ns.keys()
1633 1633 self.user_ns.update(local_ns)
1634 1634
1635 1635 # Patch for global embedding to make sure that things don't overwrite
1636 1636 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
1637 1637 # FIXME. Test this a bit more carefully (the if.. is new)
1638 1638 if local_ns is None and global_ns is None:
1639 1639 self.user_global_ns.update(__main__.__dict__)
1640 1640
1641 1641 # make sure the tab-completer has the correct frame information, so it
1642 1642 # actually completes using the frame's locals/globals
1643 1643 self.set_completer_frame()
1644 1644
1645 1645 # before activating the interactive mode, we need to make sure that
1646 1646 # all names in the builtin namespace needed by ipython point to
1647 1647 # ourselves, and not to other instances.
1648 1648 self.add_builtins()
1649 1649
1650 1650 self.interact(header)
1651 1651
1652 1652 # now, purge out the user namespace from anything we might have added
1653 1653 # from the caller's local namespace
1654 1654 delvar = self.user_ns.pop
1655 1655 for var in local_varnames:
1656 1656 delvar(var,None)
1657 1657 # and clean builtins we may have overridden
1658 1658 self.clean_builtins()
1659 1659
1660 1660 def interact_prompt(self):
1661 1661 """ Print the prompt (in read-eval-print loop)
1662 1662
1663 1663 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1664 1664 used in standard IPython flow.
1665 1665 """
1666 1666 if self.more:
1667 1667 try:
1668 1668 prompt = self.hooks.generate_prompt(True)
1669 1669 except:
1670 1670 self.showtraceback()
1671 1671 if self.autoindent:
1672 1672 self.rl_do_indent = True
1673 1673
1674 1674 else:
1675 1675 try:
1676 1676 prompt = self.hooks.generate_prompt(False)
1677 1677 except:
1678 1678 self.showtraceback()
1679 1679 self.write(prompt)
1680 1680
1681 1681 def interact_handle_input(self,line):
1682 1682 """ Handle the input line (in read-eval-print loop)
1683 1683
1684 1684 Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not
1685 1685 used in standard IPython flow.
1686 1686 """
1687 1687 if line.lstrip() == line:
1688 1688 self.shadowhist.add(line.strip())
1689 1689 lineout = self.prefilter(line,self.more)
1690 1690
1691 1691 if line.strip():
1692 1692 if self.more:
1693 1693 self.input_hist_raw[-1] += '%s\n' % line
1694 1694 else:
1695 1695 self.input_hist_raw.append('%s\n' % line)
1696 1696
1697 1697
1698 1698 self.more = self.push(lineout)
1699 1699 if (self.SyntaxTB.last_syntax_error and
1700 1700 self.rc.autoedit_syntax):
1701 1701 self.edit_syntax_error()
1702 1702
1703 1703 def interact_with_readline(self):
1704 1704 """ Demo of using interact_handle_input, interact_prompt
1705 1705
1706 1706 This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
1707 1707 it should work like this.
1708 1708 """
1709 1709 self.readline_startup_hook(self.pre_readline)
1710 1710 while not self.exit_now:
1711 1711 self.interact_prompt()
1712 1712 if self.more:
1713 1713 self.rl_do_indent = True
1714 1714 else:
1715 1715 self.rl_do_indent = False
1716 1716 line = raw_input_original().decode(self.stdin_encoding)
1717 1717 self.interact_handle_input(line)
1718 1718
1719 1719
1720 1720 def interact(self, banner=None):
1721 1721 """Closely emulate the interactive Python console.
1722 1722
1723 1723 The optional banner argument specify the banner to print
1724 1724 before the first interaction; by default it prints a banner
1725 1725 similar to the one printed by the real Python interpreter,
1726 1726 followed by the current class name in parentheses (so as not
1727 1727 to confuse this with the real interpreter -- since it's so
1728 1728 close!).
1729 1729
1730 1730 """
1731 1731
1732 1732 if self.exit_now:
1733 1733 # batch run -> do not interact
1734 1734 return
1735 1735 cprt = 'Type "copyright", "credits" or "license" for more information.'
1736 1736 if banner is None:
1737 1737 self.write("Python %s on %s\n%s\n(%s)\n" %
1738 1738 (sys.version, sys.platform, cprt,
1739 1739 self.__class__.__name__))
1740 1740 else:
1741 1741 self.write(banner)
1742 1742
1743 1743 more = 0
1744 1744
1745 1745 # Mark activity in the builtins
1746 1746 __builtin__.__dict__['__IPYTHON__active'] += 1
1747 1747
1748 1748 if self.has_readline:
1749 1749 self.readline_startup_hook(self.pre_readline)
1750 1750 # exit_now is set by a call to %Exit or %Quit
1751 1751
1752 1752 while not self.exit_now:
1753 1753 self.hooks.pre_prompt_hook()
1754 1754 if more:
1755 1755 try:
1756 1756 prompt = self.hooks.generate_prompt(True)
1757 1757 except:
1758 1758 self.showtraceback()
1759 1759 if self.autoindent:
1760 1760 self.rl_do_indent = True
1761 1761
1762 1762 else:
1763 1763 try:
1764 1764 prompt = self.hooks.generate_prompt(False)
1765 1765 except:
1766 1766 self.showtraceback()
1767 1767 try:
1768 1768 line = self.raw_input(prompt,more)
1769 1769 if self.exit_now:
1770 1770 # quick exit on sys.std[in|out] close
1771 1771 break
1772 1772 if self.autoindent:
1773 1773 self.rl_do_indent = False
1774 1774
1775 1775 except KeyboardInterrupt:
1776 1776 #double-guard against keyboardinterrupts during kbdint handling
1777 1777 try:
1778 1778 self.write('\nKeyboardInterrupt\n')
1779 1779 self.resetbuffer()
1780 1780 # keep cache in sync with the prompt counter:
1781 1781 self.outputcache.prompt_count -= 1
1782 1782
1783 1783 if self.autoindent:
1784 1784 self.indent_current_nsp = 0
1785 1785 more = 0
1786 1786 except KeyboardInterrupt:
1787 1787 pass
1788 1788 except EOFError:
1789 1789 if self.autoindent:
1790 1790 self.rl_do_indent = False
1791 1791 self.readline_startup_hook(None)
1792 1792 self.write('\n')
1793 1793 self.exit()
1794 1794 except bdb.BdbQuit:
1795 1795 warn('The Python debugger has exited with a BdbQuit exception.\n'
1796 1796 'Because of how pdb handles the stack, it is impossible\n'
1797 1797 'for IPython to properly format this particular exception.\n'
1798 1798 'IPython will resume normal operation.')
1799 1799 except:
1800 1800 # exceptions here are VERY RARE, but they can be triggered
1801 1801 # asynchronously by signal handlers, for example.
1802 1802 self.showtraceback()
1803 1803 else:
1804 1804 more = self.push(line)
1805 1805 if (self.SyntaxTB.last_syntax_error and
1806 1806 self.rc.autoedit_syntax):
1807 1807 self.edit_syntax_error()
1808 1808
1809 1809 # We are off again...
1810 1810 __builtin__.__dict__['__IPYTHON__active'] -= 1
1811 1811
1812 1812 def excepthook(self, etype, value, tb):
1813 1813 """One more defense for GUI apps that call sys.excepthook.
1814 1814
1815 1815 GUI frameworks like wxPython trap exceptions and call
1816 1816 sys.excepthook themselves. I guess this is a feature that
1817 1817 enables them to keep running after exceptions that would
1818 1818 otherwise kill their mainloop. This is a bother for IPython
1819 1819 which excepts to catch all of the program exceptions with a try:
1820 1820 except: statement.
1821 1821
1822 1822 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1823 1823 any app directly invokes sys.excepthook, it will look to the user like
1824 1824 IPython crashed. In order to work around this, we can disable the
1825 1825 CrashHandler and replace it with this excepthook instead, which prints a
1826 1826 regular traceback using our InteractiveTB. In this fashion, apps which
1827 1827 call sys.excepthook will generate a regular-looking exception from
1828 1828 IPython, and the CrashHandler will only be triggered by real IPython
1829 1829 crashes.
1830 1830
1831 1831 This hook should be used sparingly, only in places which are not likely
1832 1832 to be true IPython errors.
1833 1833 """
1834 1834 self.showtraceback((etype,value,tb),tb_offset=0)
1835 1835
1836 1836 def expand_aliases(self,fn,rest):
1837 1837 """ Expand multiple levels of aliases:
1838 1838
1839 1839 if:
1840 1840
1841 1841 alias foo bar /tmp
1842 1842 alias baz foo
1843 1843
1844 1844 then:
1845 1845
1846 1846 baz huhhahhei -> bar /tmp huhhahhei
1847 1847
1848 1848 """
1849 1849 line = fn + " " + rest
1850 1850
1851 1851 done = Set()
1852 1852 while 1:
1853 1853 pre,fn,rest = prefilter.splitUserInput(line,
1854 1854 prefilter.shell_line_split)
1855 1855 if fn in self.alias_table:
1856 1856 if fn in done:
1857 1857 warn("Cyclic alias definition, repeated '%s'" % fn)
1858 1858 return ""
1859 1859 done.add(fn)
1860 1860
1861 1861 l2 = self.transform_alias(fn,rest)
1862 1862 # dir -> dir
1863 1863 # print "alias",line, "->",l2 #dbg
1864 1864 if l2 == line:
1865 1865 break
1866 1866 # ls -> ls -F should not recurse forever
1867 1867 if l2.split(None,1)[0] == line.split(None,1)[0]:
1868 1868 line = l2
1869 1869 break
1870 1870
1871 1871 line=l2
1872 1872
1873 1873
1874 1874 # print "al expand to",line #dbg
1875 1875 else:
1876 1876 break
1877 1877
1878 1878 return line
1879 1879
1880 1880 def transform_alias(self, alias,rest=''):
1881 1881 """ Transform alias to system command string.
1882 1882 """
1883 1883 trg = self.alias_table[alias]
1884 1884
1885 1885 nargs,cmd = trg
1886 1886 # print trg #dbg
1887 1887 if ' ' in cmd and os.path.isfile(cmd):
1888 1888 cmd = '"%s"' % cmd
1889 1889
1890 1890 # Expand the %l special to be the user's input line
1891 1891 if cmd.find('%l') >= 0:
1892 1892 cmd = cmd.replace('%l',rest)
1893 1893 rest = ''
1894 1894 if nargs==0:
1895 1895 # Simple, argument-less aliases
1896 1896 cmd = '%s %s' % (cmd,rest)
1897 1897 else:
1898 1898 # Handle aliases with positional arguments
1899 1899 args = rest.split(None,nargs)
1900 1900 if len(args)< nargs:
1901 1901 error('Alias <%s> requires %s arguments, %s given.' %
1902 1902 (alias,nargs,len(args)))
1903 1903 return None
1904 1904 cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
1905 1905 # Now call the macro, evaluating in the user's namespace
1906 1906 #print 'new command: <%r>' % cmd # dbg
1907 1907 return cmd
1908 1908
1909 1909 def call_alias(self,alias,rest=''):
1910 1910 """Call an alias given its name and the rest of the line.
1911 1911
1912 1912 This is only used to provide backwards compatibility for users of
1913 1913 ipalias(), use of which is not recommended for anymore."""
1914 1914
1915 1915 # Now call the macro, evaluating in the user's namespace
1916 1916 cmd = self.transform_alias(alias, rest)
1917 1917 try:
1918 1918 self.system(cmd)
1919 1919 except:
1920 1920 self.showtraceback()
1921 1921
1922 1922 def indent_current_str(self):
1923 1923 """return the current level of indentation as a string"""
1924 1924 return self.indent_current_nsp * ' '
1925 1925
1926 1926 def autoindent_update(self,line):
1927 1927 """Keep track of the indent level."""
1928 1928
1929 1929 #debugx('line')
1930 1930 #debugx('self.indent_current_nsp')
1931 1931 if self.autoindent:
1932 1932 if line:
1933 1933 inisp = num_ini_spaces(line)
1934 1934 if inisp < self.indent_current_nsp:
1935 1935 self.indent_current_nsp = inisp
1936 1936
1937 1937 if line[-1] == ':':
1938 1938 self.indent_current_nsp += 4
1939 1939 elif dedent_re.match(line):
1940 1940 self.indent_current_nsp -= 4
1941 1941 else:
1942 1942 self.indent_current_nsp = 0
1943 1943
1944 1944 def runlines(self,lines):
1945 1945 """Run a string of one or more lines of source.
1946 1946
1947 1947 This method is capable of running a string containing multiple source
1948 1948 lines, as if they had been entered at the IPython prompt. Since it
1949 1949 exposes IPython's processing machinery, the given strings can contain
1950 1950 magic calls (%magic), special shell access (!cmd), etc."""
1951 1951
1952 1952 # We must start with a clean buffer, in case this is run from an
1953 1953 # interactive IPython session (via a magic, for example).
1954 1954 self.resetbuffer()
1955 1955 lines = lines.split('\n')
1956 1956 more = 0
1957 1957
1958 1958 for line in lines:
1959 1959 # skip blank lines so we don't mess up the prompt counter, but do
1960 1960 # NOT skip even a blank line if we are in a code block (more is
1961 1961 # true)
1962 1962
1963 1963
1964 1964 if line or more:
1965 1965 # push to raw history, so hist line numbers stay in sync
1966 1966 self.input_hist_raw.append("# " + line + "\n")
1967 1967 more = self.push(self.prefilter(line,more))
1968 1968 # IPython's runsource returns None if there was an error
1969 1969 # compiling the code. This allows us to stop processing right
1970 1970 # away, so the user gets the error message at the right place.
1971 1971 if more is None:
1972 1972 break
1973 1973 else:
1974 1974 self.input_hist_raw.append("\n")
1975 1975 # final newline in case the input didn't have it, so that the code
1976 1976 # actually does get executed
1977 1977 if more:
1978 1978 self.push('\n')
1979 1979
1980 1980 def runsource(self, source, filename='<input>', symbol='single'):
1981 1981 """Compile and run some source in the interpreter.
1982 1982
1983 1983 Arguments are as for compile_command().
1984 1984
1985 1985 One several things can happen:
1986 1986
1987 1987 1) The input is incorrect; compile_command() raised an
1988 1988 exception (SyntaxError or OverflowError). A syntax traceback
1989 1989 will be printed by calling the showsyntaxerror() method.
1990 1990
1991 1991 2) The input is incomplete, and more input is required;
1992 1992 compile_command() returned None. Nothing happens.
1993 1993
1994 1994 3) The input is complete; compile_command() returned a code
1995 1995 object. The code is executed by calling self.runcode() (which
1996 1996 also handles run-time exceptions, except for SystemExit).
1997 1997
1998 1998 The return value is:
1999 1999
2000 2000 - True in case 2
2001 2001
2002 2002 - False in the other cases, unless an exception is raised, where
2003 2003 None is returned instead. This can be used by external callers to
2004 2004 know whether to continue feeding input or not.
2005 2005
2006 2006 The return value can be used to decide whether to use sys.ps1 or
2007 2007 sys.ps2 to prompt the next line."""
2008 2008
2009 2009 # if the source code has leading blanks, add 'if 1:\n' to it
2010 2010 # this allows execution of indented pasted code. It is tempting
2011 2011 # to add '\n' at the end of source to run commands like ' a=1'
2012 2012 # directly, but this fails for more complicated scenarios
2013 2013 source=source.encode(self.stdin_encoding)
2014 2014 if source[:1] in [' ', '\t']:
2015 2015 source = 'if 1:\n%s' % source
2016 2016
2017 2017 try:
2018 2018 code = self.compile(source,filename,symbol)
2019 except (OverflowError, SyntaxError, ValueError):
2019 except (OverflowError, SyntaxError, ValueError, TypeError):
2020 2020 # Case 1
2021 2021 self.showsyntaxerror(filename)
2022 2022 return None
2023 2023
2024 2024 if code is None:
2025 2025 # Case 2
2026 2026 return True
2027 2027
2028 2028 # Case 3
2029 2029 # We store the code object so that threaded shells and
2030 2030 # custom exception handlers can access all this info if needed.
2031 2031 # The source corresponding to this can be obtained from the
2032 2032 # buffer attribute as '\n'.join(self.buffer).
2033 2033 self.code_to_run = code
2034 2034 # now actually execute the code object
2035 2035 if self.runcode(code) == 0:
2036 2036 return False
2037 2037 else:
2038 2038 return None
2039 2039
2040 2040 def runcode(self,code_obj):
2041 2041 """Execute a code object.
2042 2042
2043 2043 When an exception occurs, self.showtraceback() is called to display a
2044 2044 traceback.
2045 2045
2046 2046 Return value: a flag indicating whether the code to be run completed
2047 2047 successfully:
2048 2048
2049 2049 - 0: successful execution.
2050 2050 - 1: an error occurred.
2051 2051 """
2052 2052
2053 2053 # Set our own excepthook in case the user code tries to call it
2054 2054 # directly, so that the IPython crash handler doesn't get triggered
2055 2055 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2056 2056
2057 2057 # we save the original sys.excepthook in the instance, in case config
2058 2058 # code (such as magics) needs access to it.
2059 2059 self.sys_excepthook = old_excepthook
2060 2060 outflag = 1 # happens in more places, so it's easier as default
2061 2061 try:
2062 2062 try:
2063 2063 self.hooks.pre_runcode_hook()
2064 2064 # Embedded instances require separate global/local namespaces
2065 2065 # so they can see both the surrounding (local) namespace and
2066 2066 # the module-level globals when called inside another function.
2067 2067 if self.embedded:
2068 2068 exec code_obj in self.user_global_ns, self.user_ns
2069 2069 # Normal (non-embedded) instances should only have a single
2070 2070 # namespace for user code execution, otherwise functions won't
2071 2071 # see interactive top-level globals.
2072 2072 else:
2073 2073 exec code_obj in self.user_ns
2074 2074 finally:
2075 2075 # Reset our crash handler in place
2076 2076 sys.excepthook = old_excepthook
2077 2077 except SystemExit:
2078 2078 self.resetbuffer()
2079 2079 self.showtraceback()
2080 2080 warn("Type %exit or %quit to exit IPython "
2081 2081 "(%Exit or %Quit do so unconditionally).",level=1)
2082 2082 except self.custom_exceptions:
2083 2083 etype,value,tb = sys.exc_info()
2084 2084 self.CustomTB(etype,value,tb)
2085 2085 except:
2086 2086 self.showtraceback()
2087 2087 else:
2088 2088 outflag = 0
2089 2089 if softspace(sys.stdout, 0):
2090 2090 print
2091 2091 # Flush out code object which has been run (and source)
2092 2092 self.code_to_run = None
2093 2093 return outflag
2094 2094
2095 2095 def push(self, line):
2096 2096 """Push a line to the interpreter.
2097 2097
2098 2098 The line should not have a trailing newline; it may have
2099 2099 internal newlines. The line is appended to a buffer and the
2100 2100 interpreter's runsource() method is called with the
2101 2101 concatenated contents of the buffer as source. If this
2102 2102 indicates that the command was executed or invalid, the buffer
2103 2103 is reset; otherwise, the command is incomplete, and the buffer
2104 2104 is left as it was after the line was appended. The return
2105 2105 value is 1 if more input is required, 0 if the line was dealt
2106 2106 with in some way (this is the same as runsource()).
2107 2107 """
2108 2108
2109 2109 # autoindent management should be done here, and not in the
2110 2110 # interactive loop, since that one is only seen by keyboard input. We
2111 2111 # need this done correctly even for code run via runlines (which uses
2112 2112 # push).
2113 2113
2114 2114 #print 'push line: <%s>' % line # dbg
2115 2115 for subline in line.splitlines():
2116 2116 self.autoindent_update(subline)
2117 2117 self.buffer.append(line)
2118 2118 more = self.runsource('\n'.join(self.buffer), self.filename)
2119 2119 if not more:
2120 2120 self.resetbuffer()
2121 2121 return more
2122 2122
2123 2123 def split_user_input(self, line):
2124 2124 # This is really a hold-over to support ipapi and some extensions
2125 2125 return prefilter.splitUserInput(line)
2126 2126
2127 2127 def resetbuffer(self):
2128 2128 """Reset the input buffer."""
2129 2129 self.buffer[:] = []
2130 2130
2131 2131 def raw_input(self,prompt='',continue_prompt=False):
2132 2132 """Write a prompt and read a line.
2133 2133
2134 2134 The returned line does not include the trailing newline.
2135 2135 When the user enters the EOF key sequence, EOFError is raised.
2136 2136
2137 2137 Optional inputs:
2138 2138
2139 2139 - prompt(''): a string to be printed to prompt the user.
2140 2140
2141 2141 - continue_prompt(False): whether this line is the first one or a
2142 2142 continuation in a sequence of inputs.
2143 2143 """
2144 2144
2145 2145 # Code run by the user may have modified the readline completer state.
2146 2146 # We must ensure that our completer is back in place.
2147 2147 if self.has_readline:
2148 2148 self.set_completer()
2149 2149
2150 2150 try:
2151 2151 line = raw_input_original(prompt).decode(self.stdin_encoding)
2152 2152 except ValueError:
2153 2153 warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
2154 2154 " or sys.stdout.close()!\nExiting IPython!")
2155 2155 self.exit_now = True
2156 2156 return ""
2157 2157
2158 2158 # Try to be reasonably smart about not re-indenting pasted input more
2159 2159 # than necessary. We do this by trimming out the auto-indent initial
2160 2160 # spaces, if the user's actual input started itself with whitespace.
2161 2161 #debugx('self.buffer[-1]')
2162 2162
2163 2163 if self.autoindent:
2164 2164 if num_ini_spaces(line) > self.indent_current_nsp:
2165 2165 line = line[self.indent_current_nsp:]
2166 2166 self.indent_current_nsp = 0
2167 2167
2168 2168 # store the unfiltered input before the user has any chance to modify
2169 2169 # it.
2170 2170 if line.strip():
2171 2171 if continue_prompt:
2172 2172 self.input_hist_raw[-1] += '%s\n' % line
2173 2173 if self.has_readline: # and some config option is set?
2174 2174 try:
2175 2175 histlen = self.readline.get_current_history_length()
2176 2176 if histlen > 1:
2177 2177 newhist = self.input_hist_raw[-1].rstrip()
2178 2178 self.readline.remove_history_item(histlen-1)
2179 2179 self.readline.replace_history_item(histlen-2,
2180 2180 newhist.encode(self.stdin_encoding))
2181 2181 except AttributeError:
2182 2182 pass # re{move,place}_history_item are new in 2.4.
2183 2183 else:
2184 2184 self.input_hist_raw.append('%s\n' % line)
2185 2185 # only entries starting at first column go to shadow history
2186 2186 if line.lstrip() == line:
2187 2187 self.shadowhist.add(line.strip())
2188 2188 elif not continue_prompt:
2189 2189 self.input_hist_raw.append('\n')
2190 2190 try:
2191 2191 lineout = self.prefilter(line,continue_prompt)
2192 2192 except:
2193 2193 # blanket except, in case a user-defined prefilter crashes, so it
2194 2194 # can't take all of ipython with it.
2195 2195 self.showtraceback()
2196 2196 return ''
2197 2197 else:
2198 2198 return lineout
2199 2199
2200 2200 def _prefilter(self, line, continue_prompt):
2201 2201 """Calls different preprocessors, depending on the form of line."""
2202 2202
2203 2203 # All handlers *must* return a value, even if it's blank ('').
2204 2204
2205 2205 # Lines are NOT logged here. Handlers should process the line as
2206 2206 # needed, update the cache AND log it (so that the input cache array
2207 2207 # stays synced).
2208 2208
2209 2209 #.....................................................................
2210 2210 # Code begins
2211 2211
2212 2212 #if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg
2213 2213
2214 2214 # save the line away in case we crash, so the post-mortem handler can
2215 2215 # record it
2216 2216 self._last_input_line = line
2217 2217
2218 2218 #print '***line: <%s>' % line # dbg
2219 2219
2220 2220 if not line:
2221 2221 # Return immediately on purely empty lines, so that if the user
2222 2222 # previously typed some whitespace that started a continuation
2223 2223 # prompt, he can break out of that loop with just an empty line.
2224 2224 # This is how the default python prompt works.
2225 2225
2226 2226 # Only return if the accumulated input buffer was just whitespace!
2227 2227 if ''.join(self.buffer).isspace():
2228 2228 self.buffer[:] = []
2229 2229 return ''
2230 2230
2231 2231 line_info = prefilter.LineInfo(line, continue_prompt)
2232 2232
2233 2233 # the input history needs to track even empty lines
2234 2234 stripped = line.strip()
2235 2235
2236 2236 if not stripped:
2237 2237 if not continue_prompt:
2238 2238 self.outputcache.prompt_count -= 1
2239 2239 return self.handle_normal(line_info)
2240 2240
2241 2241 # print '***cont',continue_prompt # dbg
2242 2242 # special handlers are only allowed for single line statements
2243 2243 if continue_prompt and not self.rc.multi_line_specials:
2244 2244 return self.handle_normal(line_info)
2245 2245
2246 2246
2247 2247 # See whether any pre-existing handler can take care of it
2248 2248 rewritten = self.hooks.input_prefilter(stripped)
2249 2249 if rewritten != stripped: # ok, some prefilter did something
2250 2250 rewritten = line_info.pre + rewritten # add indentation
2251 2251 return self.handle_normal(prefilter.LineInfo(rewritten,
2252 2252 continue_prompt))
2253 2253
2254 2254 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2255 2255
2256 2256 return prefilter.prefilter(line_info, self)
2257 2257
2258 2258
2259 2259 def _prefilter_dumb(self, line, continue_prompt):
2260 2260 """simple prefilter function, for debugging"""
2261 2261 return self.handle_normal(line,continue_prompt)
2262 2262
2263 2263
2264 2264 def multiline_prefilter(self, line, continue_prompt):
2265 2265 """ Run _prefilter for each line of input
2266 2266
2267 2267 Covers cases where there are multiple lines in the user entry,
2268 2268 which is the case when the user goes back to a multiline history
2269 2269 entry and presses enter.
2270 2270
2271 2271 """
2272 2272 out = []
2273 2273 for l in line.rstrip('\n').split('\n'):
2274 2274 out.append(self._prefilter(l, continue_prompt))
2275 2275 return '\n'.join(out)
2276 2276
2277 2277 # Set the default prefilter() function (this can be user-overridden)
2278 2278 prefilter = multiline_prefilter
2279 2279
2280 2280 def handle_normal(self,line_info):
2281 2281 """Handle normal input lines. Use as a template for handlers."""
2282 2282
2283 2283 # With autoindent on, we need some way to exit the input loop, and I
2284 2284 # don't want to force the user to have to backspace all the way to
2285 2285 # clear the line. The rule will be in this case, that either two
2286 2286 # lines of pure whitespace in a row, or a line of pure whitespace but
2287 2287 # of a size different to the indent level, will exit the input loop.
2288 2288 line = line_info.line
2289 2289 continue_prompt = line_info.continue_prompt
2290 2290
2291 2291 if (continue_prompt and self.autoindent and line.isspace() and
2292 2292 (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
2293 2293 (self.buffer[-1]).isspace() )):
2294 2294 line = ''
2295 2295
2296 2296 self.log(line,line,continue_prompt)
2297 2297 return line
2298 2298
2299 2299 def handle_alias(self,line_info):
2300 2300 """Handle alias input lines. """
2301 2301 tgt = self.alias_table[line_info.iFun]
2302 2302 # print "=>",tgt #dbg
2303 2303 if callable(tgt):
2304 2304 if '$' in line_info.line:
2305 2305 call_meth = '(_ip, _ip.itpl(%s))'
2306 2306 else:
2307 2307 call_meth = '(_ip,%s)'
2308 2308 line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
2309 2309 line_info.iFun,
2310 2310 make_quoted_expr(line_info.line))
2311 2311 else:
2312 2312 transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
2313 2313
2314 2314 # pre is needed, because it carries the leading whitespace. Otherwise
2315 2315 # aliases won't work in indented sections.
2316 2316 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2317 2317 make_quoted_expr( transformed ))
2318 2318
2319 2319 self.log(line_info.line,line_out,line_info.continue_prompt)
2320 2320 #print 'line out:',line_out # dbg
2321 2321 return line_out
2322 2322
2323 2323 def handle_shell_escape(self, line_info):
2324 2324 """Execute the line in a shell, empty return value"""
2325 2325 #print 'line in :', `line` # dbg
2326 2326 line = line_info.line
2327 2327 if line.lstrip().startswith('!!'):
2328 2328 # rewrite LineInfo's line, iFun and theRest to properly hold the
2329 2329 # call to %sx and the actual command to be executed, so
2330 2330 # handle_magic can work correctly. Note that this works even if
2331 2331 # the line is indented, so it handles multi_line_specials
2332 2332 # properly.
2333 2333 new_rest = line.lstrip()[2:]
2334 2334 line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
2335 2335 line_info.iFun = 'sx'
2336 2336 line_info.theRest = new_rest
2337 2337 return self.handle_magic(line_info)
2338 2338 else:
2339 2339 cmd = line.lstrip().lstrip('!')
2340 2340 line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
2341 2341 make_quoted_expr(cmd))
2342 2342 # update cache/log and return
2343 2343 self.log(line,line_out,line_info.continue_prompt)
2344 2344 return line_out
2345 2345
2346 2346 def handle_magic(self, line_info):
2347 2347 """Execute magic functions."""
2348 2348 iFun = line_info.iFun
2349 2349 theRest = line_info.theRest
2350 2350 cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
2351 2351 make_quoted_expr(iFun + " " + theRest))
2352 2352 self.log(line_info.line,cmd,line_info.continue_prompt)
2353 2353 #print 'in handle_magic, cmd=<%s>' % cmd # dbg
2354 2354 return cmd
2355 2355
2356 2356 def handle_auto(self, line_info):
2357 2357 """Hande lines which can be auto-executed, quoting if requested."""
2358 2358
2359 2359 #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
2360 2360 line = line_info.line
2361 2361 iFun = line_info.iFun
2362 2362 theRest = line_info.theRest
2363 2363 pre = line_info.pre
2364 2364 continue_prompt = line_info.continue_prompt
2365 2365 obj = line_info.ofind(self)['obj']
2366 2366
2367 2367 # This should only be active for single-line input!
2368 2368 if continue_prompt:
2369 2369 self.log(line,line,continue_prompt)
2370 2370 return line
2371 2371
2372 2372 force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
2373 2373 auto_rewrite = True
2374 2374
2375 2375 if pre == self.ESC_QUOTE:
2376 2376 # Auto-quote splitting on whitespace
2377 2377 newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
2378 2378 elif pre == self.ESC_QUOTE2:
2379 2379 # Auto-quote whole string
2380 2380 newcmd = '%s("%s")' % (iFun,theRest)
2381 2381 elif pre == self.ESC_PAREN:
2382 2382 newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
2383 2383 else:
2384 2384 # Auto-paren.
2385 2385 # We only apply it to argument-less calls if the autocall
2386 2386 # parameter is set to 2. We only need to check that autocall is <
2387 2387 # 2, since this function isn't called unless it's at least 1.
2388 2388 if not theRest and (self.rc.autocall < 2) and not force_auto:
2389 2389 newcmd = '%s %s' % (iFun,theRest)
2390 2390 auto_rewrite = False
2391 2391 else:
2392 2392 if not force_auto and theRest.startswith('['):
2393 2393 if hasattr(obj,'__getitem__'):
2394 2394 # Don't autocall in this case: item access for an object
2395 2395 # which is BOTH callable and implements __getitem__.
2396 2396 newcmd = '%s %s' % (iFun,theRest)
2397 2397 auto_rewrite = False
2398 2398 else:
2399 2399 # if the object doesn't support [] access, go ahead and
2400 2400 # autocall
2401 2401 newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
2402 2402 elif theRest.endswith(';'):
2403 2403 newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
2404 2404 else:
2405 2405 newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
2406 2406
2407 2407 if auto_rewrite:
2408 2408 rw = self.outputcache.prompt1.auto_rewrite() + newcmd
2409 2409
2410 2410 try:
2411 2411 # plain ascii works better w/ pyreadline, on some machines, so
2412 2412 # we use it and only print uncolored rewrite if we have unicode
2413 2413 rw = str(rw)
2414 2414 print >>Term.cout, rw
2415 2415 except UnicodeEncodeError:
2416 2416 print "-------------->" + newcmd
2417 2417
2418 2418 # log what is now valid Python, not the actual user input (without the
2419 2419 # final newline)
2420 2420 self.log(line,newcmd,continue_prompt)
2421 2421 return newcmd
2422 2422
2423 2423 def handle_help(self, line_info):
2424 2424 """Try to get some help for the object.
2425 2425
2426 2426 obj? or ?obj -> basic information.
2427 2427 obj?? or ??obj -> more details.
2428 2428 """
2429 2429
2430 2430 line = line_info.line
2431 2431 # We need to make sure that we don't process lines which would be
2432 2432 # otherwise valid python, such as "x=1 # what?"
2433 2433 try:
2434 2434 codeop.compile_command(line)
2435 2435 except SyntaxError:
2436 2436 # We should only handle as help stuff which is NOT valid syntax
2437 2437 if line[0]==self.ESC_HELP:
2438 2438 line = line[1:]
2439 2439 elif line[-1]==self.ESC_HELP:
2440 2440 line = line[:-1]
2441 2441 self.log(line,'#?'+line,line_info.continue_prompt)
2442 2442 if line:
2443 2443 #print 'line:<%r>' % line # dbg
2444 2444 self.magic_pinfo(line)
2445 2445 else:
2446 2446 page(self.usage,screen_lines=self.rc.screen_length)
2447 2447 return '' # Empty string is needed here!
2448 2448 except:
2449 2449 # Pass any other exceptions through to the normal handler
2450 2450 return self.handle_normal(line_info)
2451 2451 else:
2452 2452 # If the code compiles ok, we should handle it normally
2453 2453 return self.handle_normal(line_info)
2454 2454
2455 2455 def getapi(self):
2456 2456 """ Get an IPApi object for this shell instance
2457 2457
2458 2458 Getting an IPApi object is always preferable to accessing the shell
2459 2459 directly, but this holds true especially for extensions.
2460 2460
2461 2461 It should always be possible to implement an extension with IPApi
2462 2462 alone. If not, contact maintainer to request an addition.
2463 2463
2464 2464 """
2465 2465 return self.api
2466 2466
2467 2467 def handle_emacs(self, line_info):
2468 2468 """Handle input lines marked by python-mode."""
2469 2469
2470 2470 # Currently, nothing is done. Later more functionality can be added
2471 2471 # here if needed.
2472 2472
2473 2473 # The input cache shouldn't be updated
2474 2474 return line_info.line
2475 2475
2476 2476
2477 2477 def mktempfile(self,data=None):
2478 2478 """Make a new tempfile and return its filename.
2479 2479
2480 2480 This makes a call to tempfile.mktemp, but it registers the created
2481 2481 filename internally so ipython cleans it up at exit time.
2482 2482
2483 2483 Optional inputs:
2484 2484
2485 2485 - data(None): if data is given, it gets written out to the temp file
2486 2486 immediately, and the file is closed again."""
2487 2487
2488 2488 filename = tempfile.mktemp('.py','ipython_edit_')
2489 2489 self.tempfiles.append(filename)
2490 2490
2491 2491 if data:
2492 2492 tmp_file = open(filename,'w')
2493 2493 tmp_file.write(data)
2494 2494 tmp_file.close()
2495 2495 return filename
2496 2496
2497 2497 def write(self,data):
2498 2498 """Write a string to the default output"""
2499 2499 Term.cout.write(data)
2500 2500
2501 2501 def write_err(self,data):
2502 2502 """Write a string to the default error output"""
2503 2503 Term.cerr.write(data)
2504 2504
2505 2505 def exit(self):
2506 2506 """Handle interactive exit.
2507 2507
2508 2508 This method sets the exit_now attribute."""
2509 2509
2510 2510 if self.rc.confirm_exit:
2511 2511 if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
2512 2512 self.exit_now = True
2513 2513 else:
2514 2514 self.exit_now = True
2515 2515
2516 2516 def safe_execfile(self,fname,*where,**kw):
2517 2517 """A safe version of the builtin execfile().
2518 2518
2519 2519 This version will never throw an exception, and knows how to handle
2520 2520 ipython logs as well.
2521 2521
2522 2522 :Parameters:
2523 2523 fname : string
2524 2524 Name of the file to be executed.
2525 2525
2526 2526 where : tuple
2527 2527 One or two namespaces, passed to execfile() as (globals,locals).
2528 2528 If only one is given, it is passed as both.
2529 2529
2530 2530 :Keywords:
2531 2531 islog : boolean (False)
2532 2532
2533 2533 quiet : boolean (True)
2534 2534
2535 2535 exit_ignore : boolean (False)
2536 2536 """
2537 2537
2538 2538 def syspath_cleanup():
2539 2539 """Internal cleanup routine for sys.path."""
2540 2540 if add_dname:
2541 2541 try:
2542 2542 sys.path.remove(dname)
2543 2543 except ValueError:
2544 2544 # For some reason the user has already removed it, ignore.
2545 2545 pass
2546 2546
2547 2547 fname = os.path.expanduser(fname)
2548 2548
2549 2549 # Find things also in current directory. This is needed to mimic the
2550 2550 # behavior of running a script from the system command line, where
2551 2551 # Python inserts the script's directory into sys.path
2552 2552 dname = os.path.dirname(os.path.abspath(fname))
2553 2553 add_dname = False
2554 2554 if dname not in sys.path:
2555 2555 sys.path.insert(0,dname)
2556 2556 add_dname = True
2557 2557
2558 2558 try:
2559 2559 xfile = open(fname)
2560 2560 except:
2561 2561 print >> Term.cerr, \
2562 2562 'Could not open file <%s> for safe execution.' % fname
2563 2563 syspath_cleanup()
2564 2564 return None
2565 2565
2566 2566 kw.setdefault('islog',0)
2567 2567 kw.setdefault('quiet',1)
2568 2568 kw.setdefault('exit_ignore',0)
2569 2569
2570 2570 first = xfile.readline()
2571 2571 loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
2572 2572 xfile.close()
2573 2573 # line by line execution
2574 2574 if first.startswith(loghead) or kw['islog']:
2575 2575 print 'Loading log file <%s> one line at a time...' % fname
2576 2576 if kw['quiet']:
2577 2577 stdout_save = sys.stdout
2578 2578 sys.stdout = StringIO.StringIO()
2579 2579 try:
2580 2580 globs,locs = where[0:2]
2581 2581 except:
2582 2582 try:
2583 2583 globs = locs = where[0]
2584 2584 except:
2585 2585 globs = locs = globals()
2586 2586 badblocks = []
2587 2587
2588 2588 # we also need to identify indented blocks of code when replaying
2589 2589 # logs and put them together before passing them to an exec
2590 2590 # statement. This takes a bit of regexp and look-ahead work in the
2591 2591 # file. It's easiest if we swallow the whole thing in memory
2592 2592 # first, and manually walk through the lines list moving the
2593 2593 # counter ourselves.
2594 2594 indent_re = re.compile('\s+\S')
2595 2595 xfile = open(fname)
2596 2596 filelines = xfile.readlines()
2597 2597 xfile.close()
2598 2598 nlines = len(filelines)
2599 2599 lnum = 0
2600 2600 while lnum < nlines:
2601 2601 line = filelines[lnum]
2602 2602 lnum += 1
2603 2603 # don't re-insert logger status info into cache
2604 2604 if line.startswith('#log#'):
2605 2605 continue
2606 2606 else:
2607 2607 # build a block of code (maybe a single line) for execution
2608 2608 block = line
2609 2609 try:
2610 2610 next = filelines[lnum] # lnum has already incremented
2611 2611 except:
2612 2612 next = None
2613 2613 while next and indent_re.match(next):
2614 2614 block += next
2615 2615 lnum += 1
2616 2616 try:
2617 2617 next = filelines[lnum]
2618 2618 except:
2619 2619 next = None
2620 2620 # now execute the block of one or more lines
2621 2621 try:
2622 2622 exec block in globs,locs
2623 2623 except SystemExit:
2624 2624 pass
2625 2625 except:
2626 2626 badblocks.append(block.rstrip())
2627 2627 if kw['quiet']: # restore stdout
2628 2628 sys.stdout.close()
2629 2629 sys.stdout = stdout_save
2630 2630 print 'Finished replaying log file <%s>' % fname
2631 2631 if badblocks:
2632 2632 print >> sys.stderr, ('\nThe following lines/blocks in file '
2633 2633 '<%s> reported errors:' % fname)
2634 2634
2635 2635 for badline in badblocks:
2636 2636 print >> sys.stderr, badline
2637 2637 else: # regular file execution
2638 2638 try:
2639 2639 if sys.platform == 'win32' and sys.version_info < (2,5,1):
2640 2640 # Work around a bug in Python for Windows. The bug was
2641 2641 # fixed in in Python 2.5 r54159 and 54158, but that's still
2642 2642 # SVN Python as of March/07. For details, see:
2643 2643 # http://projects.scipy.org/ipython/ipython/ticket/123
2644 2644 try:
2645 2645 globs,locs = where[0:2]
2646 2646 except:
2647 2647 try:
2648 2648 globs = locs = where[0]
2649 2649 except:
2650 2650 globs = locs = globals()
2651 2651 exec file(fname) in globs,locs
2652 2652 else:
2653 2653 execfile(fname,*where)
2654 2654 except SyntaxError:
2655 2655 self.showsyntaxerror()
2656 2656 warn('Failure executing file: <%s>' % fname)
2657 2657 except SystemExit,status:
2658 2658 # Code that correctly sets the exit status flag to success (0)
2659 2659 # shouldn't be bothered with a traceback. Note that a plain
2660 2660 # sys.exit() does NOT set the message to 0 (it's empty) so that
2661 2661 # will still get a traceback. Note that the structure of the
2662 2662 # SystemExit exception changed between Python 2.4 and 2.5, so
2663 2663 # the checks must be done in a version-dependent way.
2664 2664 show = False
2665 2665
2666 2666 if sys.version_info[:2] > (2,5):
2667 2667 if status.message!=0 and not kw['exit_ignore']:
2668 2668 show = True
2669 2669 else:
2670 2670 if status.code and not kw['exit_ignore']:
2671 2671 show = True
2672 2672 if show:
2673 2673 self.showtraceback()
2674 2674 warn('Failure executing file: <%s>' % fname)
2675 2675 except:
2676 2676 self.showtraceback()
2677 2677 warn('Failure executing file: <%s>' % fname)
2678 2678
2679 2679 syspath_cleanup()
2680 2680
2681 2681 #************************* end of file <iplib.py> *****************************
General Comments 0
You need to be logged in to leave comments. Login now