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