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