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