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