##// END OF EJS Templates
croak cleanly on non-ascii home dir names
vivainio -
Show More

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

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