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