##// END OF EJS Templates
ipapi decorators ashook, asmagic; ipapi.options() for __IP.rc access
vivainio -
Show More

The requested changes are too big and content was truncated. Show full diff

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