iplib.py
2519 lines
| 96.0 KiB
| text/x-python
|
PythonLexer
/ IPython / iplib.py
|
r0 | # -*- coding: utf-8 -*- | ||
""" | ||||
IPython -- An enhanced Interactive Python | ||||
|
r109 | Requires Python 2.3 or newer. | ||
|
r0 | |||
This file contains all the classes and helper functions specific to IPython. | ||||
|
r787 | $Id: iplib.py 2652 2007-08-22 17:25:24Z vivainio $ | ||
|
r0 | """ | ||
#***************************************************************************** | ||||
# Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and | ||||
|
r88 | # Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu> | ||
|
r0 | # | ||
# Distributed under the terms of the BSD License. The full license is in | ||||
# the file COPYING, distributed as part of this software. | ||||
# | ||||
# Note: this code originally subclassed code.InteractiveConsole from the | ||||
|
r51 | # Python standard library. Over time, all of that class has been copied | ||
|
r0 | # verbatim here for modifications which could not be accomplished by | ||
|
r51 | # subclassing. At this point, there are no dependencies at all on the code | ||
# module anymore (it is not even imported). The Python License (sec. 2) | ||||
# allows for this, but it's always nice to acknowledge credit where credit is | ||||
# due. | ||||
|
r0 | #***************************************************************************** | ||
#**************************************************************************** | ||||
# Modules and globals | ||||
from IPython import Release | ||||
__author__ = '%s <%s>\n%s <%s>' % \ | ||||
( Release.authors['Janko'] + Release.authors['Fernando'] ) | ||||
__license__ = Release.license | ||||
__version__ = Release.version | ||||
# Python standard modules | ||||
import __main__ | ||||
import __builtin__ | ||||
|
r53 | import StringIO | ||
|
r51 | import bdb | ||
import cPickle as pickle | ||||
|
r53 | import codeop | ||
|
r764 | import doctest | ||
|
r0 | import exceptions | ||
|
r51 | import glob | ||
import inspect | ||||
|
r0 | import keyword | ||
import new | ||||
|
r51 | import os | ||
import pydoc | ||||
import re | ||||
import shutil | ||||
import string | ||||
import sys | ||||
|
r82 | import tempfile | ||
|
r0 | import traceback | ||
|
r51 | import types | ||
|
r165 | import pickleshare | ||
|
r377 | from sets import Set | ||
|
r51 | from pprint import pprint, pformat | ||
|
r0 | |||
# IPython's own modules | ||||
|
r729 | #import IPython | ||
|
r587 | from IPython import Debugger,OInspect,PyColorize,ultraTB | ||
|
r46 | from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names | ||
|
r52 | from IPython.FakeModule import FakeModule | ||
from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns | ||||
|
r0 | from IPython.Logger import Logger | ||
|
r60 | from IPython.Magic import Magic | ||
from IPython.Prompts import CachedOutput | ||||
|
r98 | from IPython.ipstruct import Struct | ||
|
r0 | from IPython.background_jobs import BackgroundJobManager | ||
|
r52 | from IPython.usage import cmd_line_usage,interactive_usage | ||
|
r0 | from IPython.genutils import * | ||
|
r394 | from IPython.strdispatch import StrDispatch | ||
|
r109 | import IPython.ipapi | ||
|
r729 | import IPython.history | ||
|
r657 | import IPython.prefilter as prefilter | ||
|
r737 | import IPython.shadowns | ||
|
r88 | # Globals | ||
|
r0 | # store the builtin raw_input globally, and use this always, in case user code | ||
# overwrites it (like wx.py.PyShell does) | ||||
raw_input_original = raw_input | ||||
|
r69 | # compiled regexps for autoindent management | ||
dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass') | ||||
|
r88 | |||
|
r0 | #**************************************************************************** | ||
# Some utility function definitions | ||||
|
r106 | ini_spaces_re = re.compile(r'^(\s+)') | ||
def num_ini_spaces(strng): | ||||
"""Return the number of initial spaces in a string""" | ||||
ini_spaces = ini_spaces_re.match(strng) | ||||
if ini_spaces: | ||||
return ini_spaces.end() | ||||
else: | ||||
return 0 | ||||
|
r61 | def softspace(file, newvalue): | ||
"""Copied from code.py, to remove the dependency""" | ||||
|
r106 | |||
|
r61 | oldvalue = 0 | ||
try: | ||||
oldvalue = file.softspace | ||||
except AttributeError: | ||||
pass | ||||
try: | ||||
file.softspace = newvalue | ||||
except (AttributeError, TypeError): | ||||
# "attribute-less object" or "read-only attributes" | ||||
pass | ||||
return oldvalue | ||||
|
r0 | |||
|
r72 | |||
|
r51 | #**************************************************************************** | ||
# Local use exceptions | ||||
class SpaceInInput(exceptions.Exception): pass | ||||
|
r0 | |||
|
r88 | |||
|
r51 | #**************************************************************************** | ||
# Local use classes | ||||
class Bunch: pass | ||||
|
r0 | |||
|
r82 | class Undefined: pass | ||
|
r369 | class Quitter(object): | ||
"""Simple class to handle exit, similar to Python 2.5's. | ||||
It handles exiting in an ipython-safe manner, which the one in Python 2.5 | ||||
doesn't do (obviously, since it doesn't know about ipython).""" | ||||
def __init__(self,shell,name): | ||||
self.shell = shell | ||||
self.name = name | ||||
def __repr__(self): | ||||
return 'Type %s() to exit.' % self.name | ||||
__str__ = __repr__ | ||||
def __call__(self): | ||||
self.shell.exit() | ||||
|
r51 | class InputList(list): | ||
|
r0 | """Class to store user input. | ||
It's basically a list, but slices return a string instead of a list, thus | ||||
allowing things like (assuming 'In' is an instance): | ||||
exec In[4:7] | ||||
or | ||||
exec In[5:9] + In[14] + In[21:25]""" | ||||
def __getslice__(self,i,j): | ||||
|
r51 | return ''.join(list.__getslice__(self,i,j)) | ||
|
r0 | |||
|
r54 | class SyntaxTB(ultraTB.ListTB): | ||
"""Extension which holds some state: the last exception value""" | ||||
def __init__(self,color_scheme = 'NoColor'): | ||||
ultraTB.ListTB.__init__(self,color_scheme) | ||||
self.last_syntax_error = None | ||||
def __call__(self, etype, value, elist): | ||||
self.last_syntax_error = value | ||||
ultraTB.ListTB.__call__(self,etype,value,elist) | ||||
def clear_err_state(self): | ||||
"""Return the current error state and clear it""" | ||||
e = self.last_syntax_error | ||||
self.last_syntax_error = None | ||||
return e | ||||
|
r0 | #**************************************************************************** | ||
# Main IPython class | ||||
|
r60 | |||
# FIXME: the Magic class is a mixin for now, and will unfortunately remain so | ||||
# until a full rewrite is made. I've cleaned all cross-class uses of | ||||
# attributes and methods, but too much user code out there relies on the | ||||
# equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage. | ||||
# | ||||
# But at least now, all the pieces have been separated and we could, in | ||||
# principle, stop using the mixin. This will ease the transition to the | ||||
# chainsaw branch. | ||||
# For reference, the following is the list of 'self.foo' uses in the Magic | ||||
# class as of 2005-12-28. These are names we CAN'T use in the main ipython | ||||
# class, to prevent clashes. | ||||
# ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind', | ||||
# 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic', | ||||
# 'self.magic_', 'self.options_table', 'self.parse', 'self.shell', | ||||
# 'self.value'] | ||||
|
r78 | class InteractiveShell(object,Magic): | ||
|
r0 | """An enhanced console for Python.""" | ||
|
r59 | # class attribute to indicate whether the class supports threads or not. | ||
# Subclasses with thread support should override this as needed. | ||||
isthreaded = False | ||||
|
r0 | def __init__(self,name,usage=None,rc=Struct(opts=None,args=None), | ||
|
r39 | user_ns = None,user_global_ns=None,banner2='', | ||
|
r41 | custom_exceptions=((),None),embedded=False): | ||
|
r0 | |||
|
r124 | # log system | ||
self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate') | ||||
|
r58 | # some minimal strict typechecks. For some core data structures, I | ||
# want actual basic python types, not just anything that looks like | ||||
# one. This is especially true for namespaces. | ||||
for ns in (user_ns,user_global_ns): | ||||
if ns is not None and type(ns) != types.DictType: | ||||
raise TypeError,'namespace must be a dictionary' | ||||
|
r82 | # Job manager (for jobs run as background threads) | ||
self.jobs = BackgroundJobManager() | ||||
|
r0 | |||
|
r59 | # Store the actual shell's name | ||
self.name = name | ||||
|
r41 | # We need to know whether the instance is meant for embedding, since | ||
# global/local namespaces need to be handled differently in that case | ||||
self.embedded = embedded | ||||
|
r749 | if embedded: | ||
# Control variable so users can, from within the embedded instance, | ||||
# permanently deactivate it. | ||||
self.embedded_active = True | ||||
|
r41 | |||
|
r53 | # command compiler | ||
|
r51 | self.compile = codeop.CommandCompiler() | ||
|
r39 | |||
# User input buffer | ||||
self.buffer = [] | ||||
# Default name given in compilation of code | ||||
self.filename = '<ipython console>' | ||||
|
r368 | # Install our own quitter instead of the builtins. For python2.3-2.4, | ||
|
r369 | # this brings in behavior like 2.5, and for 2.5 it's identical. | ||
__builtin__.exit = Quitter(self,'exit') | ||||
__builtin__.quit = Quitter(self,'quit') | ||||
|
r81 | # Make an empty namespace, which extension writers can rely on both | ||
# existing and NEVER being used by ipython itself. This gives them a | ||||
# convenient location for storing additional information and state | ||||
# their extensions may require, without fear of collisions with other | ||||
# ipython names that may develop later. | ||||
|
r151 | self.meta = Struct() | ||
|
r81 | |||
|
r39 | # Create the namespace where the user will operate. user_ns is | ||
# normally the only one used, and it is passed to the exec calls as | ||||
# the locals argument. But we do carry a user_global_ns namespace | ||||
# given as the exec 'globals' argument, This is useful in embedding | ||||
# situations where the ipython shell opens in a context where the | ||||
# distinction between locals and globals is meaningful. | ||||
|
r0 | |||
# FIXME. For some strange reason, __builtins__ is showing up at user | ||||
# level as a dict instead of a module. This is a manual fix, but I | ||||
# should really track down where the problem is coming from. Alex | ||||
# Schmolck reported this problem first. | ||||
# A useful post by Alex Martelli on this topic: | ||||
# Re: inconsistent value from __builtins__ | ||||
# Von: Alex Martelli <aleaxit@yahoo.com> | ||||
# Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends | ||||
# Gruppen: comp.lang.python | ||||
# Michael Hohn <hohn@hooknose.lbl.gov> wrote: | ||||
# > >>> print type(builtin_check.get_global_binding('__builtins__')) | ||||
# > <type 'dict'> | ||||
# > >>> print type(__builtins__) | ||||
# > <type 'module'> | ||||
# > Is this difference in return value intentional? | ||||
# Well, it's documented that '__builtins__' can be either a dictionary | ||||
# or a module, and it's been that way for a long time. Whether it's | ||||
|
r51 | # intentional (or sensible), I don't know. In any case, the idea is | ||
# that if you need to access the built-in namespace directly, you | ||||
# should start with "import __builtin__" (note, no 's') which will | ||||
|
r136 | # definitely give you a module. Yeah, it's somewhat confusing:-(. | ||
|
r39 | |||
|
r296 | # These routines return properly built dicts as needed by the rest of | ||
# the code, and can also be used by extension writers to generate | ||||
# properly initialized namespaces. | ||||
user_ns = IPython.ipapi.make_user_ns(user_ns) | ||||
user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns) | ||||
|
r41 | # Assign namespaces | ||
# This is the namespace where all normal user variables live | ||||
|
r39 | self.user_ns = user_ns | ||
|
r41 | # Embedded instances require a separate namespace for globals. | ||
# Normally this one is unused by non-embedded instances. | ||||
|
r39 | self.user_global_ns = user_global_ns | ||
|
r41 | # A namespace to keep track of internal data structures to prevent | ||
# them from cluttering user-visible stuff. Will be updated later | ||||
self.internal_ns = {} | ||||
# Namespace of system aliases. Each entry in the alias | ||||
# table must be a 2-tuple of the form (N,name), where N is the number | ||||
# of positional arguments of the alias. | ||||
self.alias_table = {} | ||||
# A table holding all the namespaces IPython deals with, so that | ||||
# introspection facilities can search easily. | ||||
self.ns_table = {'user':user_ns, | ||||
'user_global':user_global_ns, | ||||
'alias':self.alias_table, | ||||
'internal':self.internal_ns, | ||||
'builtin':__builtin__.__dict__ | ||||
} | ||||
|
r0 | |||
# The user namespace MUST have a pointer to the shell itself. | ||||
self.user_ns[name] = self | ||||
# We need to insert into sys.modules something that looks like a | ||||
# module but which accesses the IPython namespace, for shelve and | ||||
# pickle to work interactively. Normally they rely on getting | ||||
# everything out of __main__, but for embedding purposes each IPython | ||||
# instance has its own private namespace, so we can't go shoving | ||||
# everything into __main__. | ||||
|
r47 | # note, however, that we should only do this for non-embedded | ||
# ipythons, which really mimic the __main__.__dict__ with their own | ||||
# namespace. Embedded instances, on the other hand, should not do | ||||
# this because they need to manage the user local/global namespaces | ||||
# only, but they live within a 'normal' __main__ (meaning, they | ||||
# shouldn't overtake the execution environment of the script they're | ||||
# embedded in). | ||||
if not embedded: | ||||
try: | ||||
main_name = self.user_ns['__name__'] | ||||
except KeyError: | ||||
raise KeyError,'user_ns dictionary MUST have a "__name__" key' | ||||
else: | ||||
#print "pickle hack in place" # dbg | ||||
|
r78 | #print 'main_name:',main_name # dbg | ||
|
r47 | sys.modules[main_name] = FakeModule(self.user_ns) | ||
|
r0 | |||
# List of input with multi-line handling. | ||||
# Fill its zero entry, user counter starts at 1 | ||||
self.input_hist = InputList(['\n']) | ||||
|
r145 | # This one will hold the 'raw' input history, without any | ||
# pre-processing. This will allow users to retrieve the input just as | ||||
# it was exactly typed in by the user, with %hist -r. | ||||
self.input_hist_raw = InputList(['\n']) | ||||
|
r0 | |||
# list of visited directories | ||||
|
r18 | try: | ||
self.dir_hist = [os.getcwd()] | ||||
|
r717 | except OSError: | ||
|
r18 | self.dir_hist = [] | ||
|
r0 | |||
# dict of output history | ||||
self.output_hist = {} | ||||
|
r595 | # Get system encoding at startup time. Certain terminals (like Emacs | ||
# under Win32 have it set to None, and we need to have a known valid | ||||
# encoding to use in the raw_input() method | ||||
self.stdin_encoding = sys.stdin.encoding or 'ascii' | ||||
|
r51 | # dict of things NOT to alias (keywords, builtins and some magics) | ||
|
r18 | no_alias = {} | ||
no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias'] | ||||
for key in keyword.kwlist + no_alias_magics: | ||||
no_alias[key] = 1 | ||||
no_alias.update(__builtin__.__dict__) | ||||
self.no_alias = no_alias | ||||
|
r39 | |||
|
r0 | # make global variables for user access to these | ||
self.user_ns['_ih'] = self.input_hist | ||||
self.user_ns['_oh'] = self.output_hist | ||||
self.user_ns['_dh'] = self.dir_hist | ||||
# user aliases to input and output histories | ||||
self.user_ns['In'] = self.input_hist | ||||
self.user_ns['Out'] = self.output_hist | ||||
|
r737 | self.user_ns['_sh'] = IPython.shadowns | ||
|
r0 | # Object variable to store code object waiting execution. This is | ||
# used mainly by the multithreaded shells, but it can come in handy in | ||||
# other situations. No need to use a Queue here, since it's a single | ||||
# item which gets cleared once run. | ||||
self.code_to_run = None | ||||
# escapes for automatic behavior on the command line | ||||
|
r52 | self.ESC_SHELL = '!' | ||
|
r657 | self.ESC_SH_CAP = '!!' | ||
|
r52 | self.ESC_HELP = '?' | ||
self.ESC_MAGIC = '%' | ||||
self.ESC_QUOTE = ',' | ||||
|
r0 | self.ESC_QUOTE2 = ';' | ||
|
r52 | self.ESC_PAREN = '/' | ||
|
r0 | |||
# And their associated handlers | ||||
|
r60 | self.esc_handlers = {self.ESC_PAREN : self.handle_auto, | ||
self.ESC_QUOTE : self.handle_auto, | ||||
self.ESC_QUOTE2 : self.handle_auto, | ||||
self.ESC_MAGIC : self.handle_magic, | ||||
self.ESC_HELP : self.handle_help, | ||||
self.ESC_SHELL : self.handle_shell_escape, | ||||
|
r657 | self.ESC_SH_CAP : self.handle_shell_escape, | ||
|
r0 | } | ||
# class initializations | ||||
Magic.__init__(self,self) | ||||
|
r31 | # Python source parser/formatter for syntax highlighting | ||
|
r52 | pyformat = PyColorize.Parser().format | ||
|
r31 | self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors']) | ||
|
r0 | # hooks holds pointers used for user-side customizations | ||
self.hooks = Struct() | ||||
|
r394 | self.strdispatchers = {} | ||
|
r0 | # Set all default hooks, defined in the IPython.hooks module. | ||
hooks = IPython.hooks | ||||
for hook_name in hooks.__all__: | ||||
|
r595 | # default hooks have priority 100, i.e. low; user hooks should have | ||
# 0-100 priority | ||||
|
r112 | self.set_hook(hook_name,getattr(hooks,hook_name), 100) | ||
|
r150 | #print "bound hook",hook_name | ||
|
r0 | |||
# Flag to mark unconditional exit | ||||
self.exit_now = False | ||||
self.usage_min = """\ | ||||
An enhanced console for Python. | ||||
Some of its features are: | ||||
- Readline support if the readline library is present. | ||||
- Tab completion in the local namespace. | ||||
- Logging of input, see command-line options. | ||||
- System shell escape via ! , eg !ls. | ||||
- Magic commands, starting with a % (like %ls, %pwd, %cd, etc.) | ||||
- Keeps track of locally defined variables via %who, %whos. | ||||
- Show object information with a ? eg ?x or x? (use ?? for more info). | ||||
""" | ||||
if usage: self.usage = usage | ||||
else: self.usage = self.usage_min | ||||
# Storage | ||||
self.rc = rc # This will hold all configuration information | ||||
self.pager = 'less' | ||||
# temporary files used for various purposes. Deleted at exit. | ||||
self.tempfiles = [] | ||||
|
r11 | # Keep track of readline usage (later set by init_readline) | ||
|
r51 | self.has_readline = False | ||
|
r11 | |||
|
r60 | # template for logfile headers. It gets resolved at runtime by the | ||
# logstart method. | ||||
self.loghead_tpl = \ | ||||
"""#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE *** | ||||
#log# DO NOT CHANGE THIS LINE OR THE TWO BELOW | ||||
#log# opts = %s | ||||
#log# args = %s | ||||
#log# It is safe to make manual edits below here. | ||||
#log#----------------------------------------------------------------------- | ||||
""" | ||||
|
r0 | # for pushd/popd management | ||
try: | ||||
self.home_dir = get_home_dir() | ||||
except HomeDirError,msg: | ||||
fatal(msg) | ||||
self.dir_stack = [os.getcwd().replace(self.home_dir,'~')] | ||||
# Functions to call the underlying shell. | ||||
# The first is similar to os.system, but it doesn't return a value, | ||||
# and it allows interpolation of variables in the user's namespace. | ||||
|
r417 | self.system = lambda cmd: \ | ||
shell(self.var_expand(cmd,depth=2), | ||||
|
r418 | header=self.rc.system_header, | ||
|
r417 | verbose=self.rc.system_verbose) | ||
|
r418 | |||
|
r0 | # These are for getoutput and getoutputerror: | ||
self.getoutput = lambda cmd: \ | ||||
|
r417 | getoutput(self.var_expand(cmd,depth=2), | ||
|
r418 | header=self.rc.system_header, | ||
|
r0 | verbose=self.rc.system_verbose) | ||
|
r418 | |||
|
r0 | self.getoutputerror = lambda cmd: \ | ||
|
r417 | getoutputerror(self.var_expand(cmd,depth=2), | ||
|
r418 | header=self.rc.system_header, | ||
|
r317 | verbose=self.rc.system_verbose) | ||
|
r0 | |||
# keep track of where we started running (mainly for crash post-mortem) | ||||
self.starting_dir = os.getcwd() | ||||
# Various switches which can be set | ||||
self.CACHELENGTH = 5000 # this is cheap, it's just text | ||||
self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__ | ||||
self.banner2 = banner2 | ||||
# TraceBack handlers: | ||||
|
r59 | |||
# Syntax error handler. | ||||
|
r54 | self.SyntaxTB = SyntaxTB(color_scheme='NoColor') | ||
|
r59 | |||
|
r54 | # The interactive one is initialized with an offset, meaning we always | ||
# want to remove the topmost item in the traceback, which is our own | ||||
# internal code. Valid modes: ['Plain','Context','Verbose'] | ||||
|
r0 | self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain', | ||
color_scheme='NoColor', | ||||
tb_offset = 1) | ||||
|
r59 | |||
# IPython itself shouldn't crash. This will produce a detailed | ||||
# post-mortem if it does. But we only install the crash handler for | ||||
# non-threaded shells, the threaded ones use a normal verbose reporter | ||||
# and lose the crash handler. This is because exceptions in the main | ||||
# thread (such as in GUI code) propagate directly to sys.excepthook, | ||||
# and there's no point in printing crash dumps for every user exception. | ||||
if self.isthreaded: | ||||
|
r381 | ipCrashHandler = ultraTB.FormattedTB() | ||
|
r59 | else: | ||
from IPython import CrashHandler | ||||
|
r381 | ipCrashHandler = CrashHandler.IPythonCrashHandler(self) | ||
self.set_crash_handler(ipCrashHandler) | ||||
|
r59 | |||
|
r0 | # and add any custom exception handlers the user may have specified | ||
self.set_custom_exc(*custom_exceptions) | ||||
|
r53 | # indentation management | ||
|
r51 | self.autoindent = False | ||
|
r53 | self.indent_current_nsp = 0 | ||
|
r0 | |||
# Make some aliases automatically | ||||
# Prepare list of shell aliases to auto-define | ||||
|
r253 | if os.name == 'posix': | ||
|
r0 | auto_alias = ('mkdir mkdir', 'rmdir rmdir', | ||
'mv mv -i','rm rm -i','cp cp -i', | ||||
'cat cat','less less','clear clear', | ||||
# a better ls | ||||
'ls ls -F', | ||||
# long ls | ||||
|
r304 | 'll ls -lF') | ||
# Extra ls aliases with color, which need special treatment on BSD | ||||
# variants | ||||
ls_extra = ( # color ls | ||||
'lc ls -F -o --color', | ||||
# ls normal files only | ||||
'lf ls -F -o --color %l | grep ^-', | ||||
# ls symbolic links | ||||
'lk ls -F -o --color %l | grep ^l', | ||||
# directories or links to directories, | ||||
'ldir ls -F -o --color %l | grep /$', | ||||
# things which are executable | ||||
'lx ls -F -o --color %l | grep ^-..x', | ||||
) | ||||
# The BSDs don't ship GNU ls, so they don't understand the | ||||
# --color switch out of the box | ||||
if 'bsd' in sys.platform: | ||||
ls_extra = ( # ls normal files only | ||||
|
r324 | 'lf ls -lF | grep ^-', | ||
|
r304 | # ls symbolic links | ||
|
r324 | 'lk ls -lF | grep ^l', | ||
|
r304 | # directories or links to directories, | ||
|
r324 | 'ldir ls -lF | grep /$', | ||
|
r304 | # things which are executable | ||
|
r324 | 'lx ls -lF | grep ^-..x', | ||
|
r304 | ) | ||
auto_alias = auto_alias + ls_extra | ||||
|
r0 | elif os.name in ['nt','dos']: | ||
auto_alias = ('dir dir /on', 'ls dir /on', | ||||
'ddir dir /ad /on', 'ldir dir /ad /on', | ||||
'mkdir mkdir','rmdir rmdir','echo echo', | ||||
'ren ren','cls cls','copy copy') | ||||
else: | ||||
auto_alias = () | ||||
|
r304 | self.auto_alias = [s.split(None,1) for s in auto_alias] | ||
|
r284 | |||
# Produce a public API instance | ||||
self.api = IPython.ipapi.IPApi(self) | ||||
|
r784 | # Call the actual (public) initializer | ||
self.init_auto_alias() | ||||
|
r284 | # track which builtins we add, so we can clean up later | ||
self.builtins_added = {} | ||||
# This method will add the necessary builtins for operation, but | ||||
# tracking what it did via the builtins_added dict. | ||||
self.add_builtins() | ||||
|
r0 | # end __init__ | ||
|
r417 | def var_expand(self,cmd,depth=0): | ||
"""Expand python variables in a string. | ||||
The depth argument indicates how many frames above the caller should | ||||
be walked to look for the local namespace where to expand variables. | ||||
The global namespace for expansion is always the user's interactive | ||||
namespace. | ||||
""" | ||||
return str(ItplNS(cmd.replace('#','\#'), | ||||
self.user_ns, # globals | ||||
# Skip our own frame in searching for locals: | ||||
sys._getframe(depth+1).f_locals # locals | ||||
)) | ||||
|
r185 | def pre_config_initialization(self): | ||
"""Pre-configuration init method | ||||
This is called before the configuration files are processed to | ||||
prepare the services the config files might need. | ||||
self.rc already has reasonable default values at this point. | ||||
""" | ||||
rc = self.rc | ||||
|
r634 | try: | ||
self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db") | ||||
except exceptions.UnicodeDecodeError: | ||||
print "Your ipythondir can't be decoded to unicode!" | ||||
print "Please set HOME environment variable to something that" | ||||
print r"only has ASCII characters, e.g. c:\home" | ||||
print "Now it is",rc.ipythondir | ||||
sys.exit() | ||||
|
r729 | self.shadowhist = IPython.history.ShadowHist(self.db) | ||
|
r634 | |||
|
r185 | |||
|
r59 | def post_config_initialization(self): | ||
"""Post configuration init method | ||||
This is called after the configuration files have been processed to | ||||
'finalize' the initialization.""" | ||||
rc = self.rc | ||||
|
r299 | |||
# Object inspector | ||||
self.inspector = OInspect.Inspector(OInspect.InspectColors, | ||||
PyColorize.ANSICodeColors, | ||||
'NoColor', | ||||
rc.object_info_string_level) | ||||
|
r59 | |||
|
r682 | self.rl_next_input = None | ||
self.rl_do_indent = False | ||||
|
r59 | # Load readline proper | ||
if rc.readline: | ||||
self.init_readline() | ||||
|
r682 | |||
|
r60 | # local shortcut, this is used a LOT | ||
self.log = self.logger.log | ||||
# Initialize cache, set in/out prompts and printing system | ||||
self.outputcache = CachedOutput(self, | ||||
rc.cache_size, | ||||
rc.pprint, | ||||
input_sep = rc.separate_in, | ||||
output_sep = rc.separate_out, | ||||
output_sep2 = rc.separate_out2, | ||||
ps1 = rc.prompt_in1, | ||||
ps2 = rc.prompt_in2, | ||||
ps_out = rc.prompt_out, | ||||
pad_left = rc.prompts_pad_left) | ||||
# user may have over-ridden the default print hook: | ||||
try: | ||||
self.outputcache.__class__.display = self.hooks.display | ||||
except AttributeError: | ||||
pass | ||||
|
r390 | # I don't like assigning globally to sys, because it means when | ||
# embedding instances, each embedded instance overrides the previous | ||||
# choice. But sys.displayhook seems to be called internally by exec, | ||||
# so I don't see a way around it. We first save the original and then | ||||
# overwrite it. | ||||
self.sys_displayhook = sys.displayhook | ||||
|
r60 | sys.displayhook = self.outputcache | ||
|
r764 | |||
# Monkeypatch doctest so that its core test runner method is protected | ||||
# from IPython's modified displayhook. Doctest expects the default | ||||
# displayhook behavior deep down, so our modification breaks it | ||||
# completely. For this reason, a hard monkeypatch seems like a | ||||
# reasonable solution rather than asking users to manually use a | ||||
# different doctest runner when under IPython. | ||||
doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run) | ||||
|
r59 | # Set user colors (don't do it in the constructor above so that it | ||
# doesn't crash if colors option is invalid) | ||||
self.magic_colors(rc.colors) | ||||
|
r60 | # Set calling of pdb on exceptions | ||
self.call_pdb = rc.pdb | ||||
|
r59 | # Load user aliases | ||
for alias in rc.alias: | ||||
self.magic_alias(alias) | ||||
|
r165 | self.hooks.late_startup_hook() | ||
|
r62 | |||
|
r325 | batchrun = False | ||
|
r241 | for batchfile in [path(arg) for arg in self.rc.args | ||
if arg.lower().endswith('.ipy')]: | ||||
if not batchfile.isfile(): | ||||
print "No such batch file:", batchfile | ||||
continue | ||||
self.api.runlines(batchfile.text()) | ||||
|
r325 | batchrun = True | ||
if batchrun: | ||||
self.exit_now = True | ||||
|
r82 | |||
def add_builtins(self): | ||||
"""Store ipython references into the builtin namespace. | ||||
Some parts of ipython operate via builtins injected here, which hold a | ||||
reference to IPython itself.""" | ||||
|
r158 | # TODO: deprecate all except _ip; 'jobs' should be installed | ||
|
r169 | # by an extension and the rest are under _ip, ipalias is redundant | ||
|
r82 | builtins_new = dict(__IPYTHON__ = self, | ||
|
r449 | ip_set_hook = self.set_hook, | ||
jobs = self.jobs, | ||||
ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'), | ||||
ipalias = wrap_deprecated(self.ipalias), | ||||
ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'), | ||||
_ip = self.api | ||||
) | ||||
|
r82 | for biname,bival in builtins_new.items(): | ||
try: | ||||
# store the orignal value so we can restore it | ||||
self.builtins_added[biname] = __builtin__.__dict__[biname] | ||||
except KeyError: | ||||
# or mark that it wasn't defined, and we'll just delete it at | ||||
# cleanup | ||||
self.builtins_added[biname] = Undefined | ||||
__builtin__.__dict__[biname] = bival | ||||
# Keep in the builtins a flag for when IPython is active. We set it | ||||
# with setdefault so that multiple nested IPythons don't clobber one | ||||
# another. Each will increase its value by one upon being activated, | ||||
# which also gives us a way to determine the nesting level. | ||||
__builtin__.__dict__.setdefault('__IPYTHON__active',0) | ||||
def clean_builtins(self): | ||||
"""Remove any builtins which might have been added by add_builtins, or | ||||
restore overwritten ones to their previous values.""" | ||||
for biname,bival in self.builtins_added.items(): | ||||
if bival is Undefined: | ||||
del __builtin__.__dict__[biname] | ||||
else: | ||||
__builtin__.__dict__[biname] = bival | ||||
self.builtins_added.clear() | ||||
|
r78 | |||
|
r394 | def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None): | ||
|
r0 | """set_hook(name,hook) -> sets an internal IPython hook. | ||
IPython exposes some of its internal API as user-modifiable hooks. By | ||||
|
r112 | adding your function to one of these hooks, you can modify IPython's | ||
behavior to call at runtime your own routines.""" | ||||
|
r0 | |||
# At some point in the future, this should validate the hook before it | ||||
# accepts it. Probably at least check that the hook takes the number | ||||
# of args it's supposed to. | ||||
|
r394 | |||
f = new.instancemethod(hook,self,self.__class__) | ||||
# check if the hook is for strdispatcher first | ||||
if str_key is not None: | ||||
sdp = self.strdispatchers.get(name, StrDispatch()) | ||||
sdp.add_s(str_key, f, priority ) | ||||
self.strdispatchers[name] = sdp | ||||
return | ||||
if re_key is not None: | ||||
sdp = self.strdispatchers.get(name, StrDispatch()) | ||||
sdp.add_re(re.compile(re_key), f, priority ) | ||||
self.strdispatchers[name] = sdp | ||||
return | ||||
|
r112 | dp = getattr(self.hooks, name, None) | ||
|
r151 | if name not in IPython.hooks.__all__: | ||
print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ ) | ||||
|
r112 | if not dp: | ||
dp = IPython.hooks.CommandChainDispatcher() | ||||
try: | ||||
dp.add(f,priority) | ||||
except AttributeError: | ||||
# it was not commandchain, plain old func - replace | ||||
dp = f | ||||
setattr(self.hooks,name, dp) | ||||
#setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__)) | ||||
|
r0 | |||
|
r381 | def set_crash_handler(self,crashHandler): | ||
"""Set the IPython crash handler. | ||||
This must be a callable with a signature suitable for use as | ||||
sys.excepthook.""" | ||||
# Install the given crash handler as the Python exception hook | ||||
sys.excepthook = crashHandler | ||||
# The instance will store a pointer to this, so that runtime code | ||||
# (such as magics) can access it. This is because during the | ||||
# read-eval loop, it gets temporarily overwritten (to deal with GUI | ||||
# frameworks). | ||||
self.sys_excepthook = sys.excepthook | ||||
|
r0 | def set_custom_exc(self,exc_tuple,handler): | ||
"""set_custom_exc(exc_tuple,handler) | ||||
Set a custom exception handler, which will be called if any of the | ||||
exceptions in exc_tuple occur in the mainloop (specifically, in the | ||||
runcode() method. | ||||
Inputs: | ||||
- exc_tuple: a *tuple* of valid exceptions to call the defined | ||||
handler for. It is very important that you use a tuple, and NOT A | ||||
LIST here, because of the way Python's except statement works. If | ||||
you only want to trap a single exception, use a singleton tuple: | ||||
exc_tuple == (MyCustomException,) | ||||
- handler: this must be defined as a function with the following | ||||
basic interface: def my_handler(self,etype,value,tb). | ||||
This will be made into an instance method (via new.instancemethod) | ||||
of IPython itself, and it will be called if any of the exceptions | ||||
listed in the exc_tuple are caught. If the handler is None, an | ||||
internal basic one is used, which just prints basic info. | ||||
WARNING: by putting in your own exception handler into IPython's main | ||||
execution loop, you run a very good chance of nasty crashes. This | ||||
facility should only be used if you really know what you are doing.""" | ||||
assert type(exc_tuple)==type(()) , \ | ||||
"The custom exceptions must be given AS A TUPLE." | ||||
def dummy_handler(self,etype,value,tb): | ||||
print '*** Simple custom exception handler ***' | ||||
print 'Exception type :',etype | ||||
print 'Exception value:',value | ||||
print 'Traceback :',tb | ||||
|
r10 | print 'Source code :','\n'.join(self.buffer) | ||
|
r0 | |||
if handler is None: handler = dummy_handler | ||||
self.CustomTB = new.instancemethod(handler,self,self.__class__) | ||||
self.custom_exceptions = exc_tuple | ||||
def set_custom_completer(self,completer,pos=0): | ||||
"""set_custom_completer(completer,pos=0) | ||||
Adds a new custom completer function. | ||||
The position argument (defaults to 0) is the index in the completers | ||||
list where you want the completer to be inserted.""" | ||||
newcomp = new.instancemethod(completer,self.Completer, | ||||
self.Completer.__class__) | ||||
self.Completer.matchers.insert(pos,newcomp) | ||||
|
r593 | def set_completer(self): | ||
"""reset readline's completer to be our own.""" | ||||
self.readline.set_completer(self.Completer.complete) | ||||
|
r60 | def _get_call_pdb(self): | ||
return self._call_pdb | ||||
def _set_call_pdb(self,val): | ||||
if val not in (0,1,False,True): | ||||
raise ValueError,'new call_pdb value must be boolean' | ||||
# store value in instance | ||||
self._call_pdb = val | ||||
# notify the actual exception handlers | ||||
self.InteractiveTB.call_pdb = val | ||||
if self.isthreaded: | ||||
try: | ||||
self.sys_excepthook.call_pdb = val | ||||
except: | ||||
warn('Failed to activate pdb for threaded exception handler') | ||||
call_pdb = property(_get_call_pdb,_set_call_pdb,None, | ||||
'Control auto-activation of pdb at exceptions') | ||||
|
r82 | |||
# These special functions get installed in the builtin namespace, to | ||||
# provide programmatic (pure python) access to magics, aliases and system | ||||
# calls. This is important for logging, user scripting, and more. | ||||
# We are basically exposing, via normal python functions, the three | ||||
# mechanisms in which ipython offers special call modes (magics for | ||||
# internal control, aliases for direct system access via pre-selected | ||||
# names, and !cmd for calling arbitrary system commands). | ||||
def ipmagic(self,arg_s): | ||||
"""Call a magic function by name. | ||||
Input: a string containing the name of the magic function to call and any | ||||
additional arguments to be passed to the magic. | ||||
ipmagic('name -opt foo bar') is equivalent to typing at the ipython | ||||
prompt: | ||||
In[1]: %name -opt foo bar | ||||
To call a magic without arguments, simply use ipmagic('name'). | ||||
This provides a proper Python function to call IPython's magics in any | ||||
valid Python code you can type at the interpreter, including loops and | ||||
compound statements. It is added by IPython to the Python builtin | ||||
namespace upon initialization.""" | ||||
args = arg_s.split(' ',1) | ||||
magic_name = args[0] | ||||
|
r109 | magic_name = magic_name.lstrip(self.ESC_MAGIC) | ||
|
r82 | try: | ||
magic_args = args[1] | ||||
except IndexError: | ||||
magic_args = '' | ||||
fn = getattr(self,'magic_'+magic_name,None) | ||||
if fn is None: | ||||
error("Magic function `%s` not found." % magic_name) | ||||
else: | ||||
|
r417 | magic_args = self.var_expand(magic_args,1) | ||
|
r82 | return fn(magic_args) | ||
def ipalias(self,arg_s): | ||||
"""Call an alias by name. | ||||
Input: a string containing the name of the alias to call and any | ||||
additional arguments to be passed to the magic. | ||||
ipalias('name -opt foo bar') is equivalent to typing at the ipython | ||||
prompt: | ||||
In[1]: name -opt foo bar | ||||
To call an alias without arguments, simply use ipalias('name'). | ||||
This provides a proper Python function to call IPython's aliases in any | ||||
valid Python code you can type at the interpreter, including loops and | ||||
compound statements. It is added by IPython to the Python builtin | ||||
namespace upon initialization.""" | ||||
args = arg_s.split(' ',1) | ||||
alias_name = args[0] | ||||
try: | ||||
alias_args = args[1] | ||||
except IndexError: | ||||
alias_args = '' | ||||
if alias_name in self.alias_table: | ||||
self.call_alias(alias_name,alias_args) | ||||
else: | ||||
error("Alias `%s` not found." % alias_name) | ||||
def ipsystem(self,arg_s): | ||||
"""Make a system call, using IPython.""" | ||||
|
r89 | |||
|
r82 | self.system(arg_s) | ||
|
r16 | def complete(self,text): | ||
"""Return a sorted list of all possible completions on text. | ||||
Inputs: | ||||
- text: a string of text to be completed on. | ||||
This is a wrapper around the completion mechanism, similar to what | ||||
readline does at the command line when the TAB key is hit. By | ||||
exposing it as a method, it can be used by other non-readline | ||||
environments (such as GUIs) for text completion. | ||||
Simple usage example: | ||||
In [1]: x = 'hello' | ||||
In [2]: __IP.complete('x.l') | ||||
Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']""" | ||||
complete = self.Completer.complete | ||||
state = 0 | ||||
# use a dict so we get unique keys, since ipyhton's multiple | ||||
|
r583 | # completers can return duplicates. When we make 2.4 a requirement, | ||
# start using sets instead, which are faster. | ||||
|
r16 | comps = {} | ||
while True: | ||||
|
r583 | newcomp = complete(text,state,line_buffer=text) | ||
|
r16 | if newcomp is None: | ||
break | ||||
comps[newcomp] = 1 | ||||
state += 1 | ||||
outcomps = comps.keys() | ||||
outcomps.sort() | ||||
return outcomps | ||||
|
r46 | |||
|
r89 | def set_completer_frame(self, frame=None): | ||
|
r46 | if frame: | ||
|
r47 | self.Completer.namespace = frame.f_locals | ||
self.Completer.global_namespace = frame.f_globals | ||||
|
r46 | else: | ||
self.Completer.namespace = self.user_ns | ||||
|
r47 | self.Completer.global_namespace = self.user_global_ns | ||
|
r16 | |||
|
r0 | def init_auto_alias(self): | ||
"""Define some aliases automatically. | ||||
These are ALL parameter-less aliases""" | ||||
|
r89 | |||
|
r0 | for alias,cmd in self.auto_alias: | ||
|
r784 | self.getapi().defalias(alias,cmd) | ||
|
r0 | |||
def alias_table_validate(self,verbose=0): | ||||
"""Update information about the alias table. | ||||
In particular, make sure no Python keywords/builtins are in it.""" | ||||
no_alias = self.no_alias | ||||
|
r20 | for k in self.alias_table.keys(): | ||
|
r0 | if k in no_alias: | ||
del self.alias_table[k] | ||||
if verbose: | ||||
print ("Deleting alias <%s>, it's a Python " | ||||
"keyword or builtin." % k) | ||||
def set_autoindent(self,value=None): | ||||
"""Set the autoindent flag, checking for readline support. | ||||
If called with no arguments, it acts as a toggle.""" | ||||
if not self.has_readline: | ||||
if os.name == 'posix': | ||||
warn("The auto-indent feature requires the readline library") | ||||
self.autoindent = 0 | ||||
return | ||||
if value is None: | ||||
self.autoindent = not self.autoindent | ||||
else: | ||||
self.autoindent = value | ||||
def rc_set_toggle(self,rc_field,value=None): | ||||
"""Set or toggle a field in IPython's rc config. structure. | ||||
If called with no arguments, it acts as a toggle. | ||||
If called with a non-existent field, the resulting AttributeError | ||||
exception will propagate out.""" | ||||
rc_val = getattr(self.rc,rc_field) | ||||
if value is None: | ||||
value = not rc_val | ||||
setattr(self.rc,rc_field,value) | ||||
def user_setup(self,ipythondir,rc_suffix,mode='install'): | ||||
"""Install the user configuration directory. | ||||
Can be called when running for the first time or to upgrade the user's | ||||
.ipython/ directory with the mode parameter. Valid modes are 'install' | ||||
and 'upgrade'.""" | ||||
def wait(): | ||||
try: | ||||
raw_input("Please press <RETURN> to start IPython.") | ||||
except EOFError: | ||||
print >> Term.cout | ||||
print '*'*70 | ||||
cwd = os.getcwd() # remember where we started | ||||
glb = glob.glob | ||||
print '*'*70 | ||||
if mode == 'install': | ||||
print \ | ||||
"""Welcome to IPython. I will try to create a personal configuration directory | ||||
where you can customize many aspects of IPython's functionality in:\n""" | ||||
else: | ||||
print 'I am going to upgrade your configuration in:' | ||||
print ipythondir | ||||
rcdirend = os.path.join('IPython','UserConfig') | ||||
cfg = lambda d: os.path.join(d,rcdirend) | ||||
try: | ||||
rcdir = filter(os.path.isdir,map(cfg,sys.path))[0] | ||||
except IOError: | ||||
warning = """ | ||||
Installation error. IPython's directory was not found. | ||||
Check the following: | ||||
The ipython/IPython directory should be in a directory belonging to your | ||||
PYTHONPATH environment variable (that is, it should be in a directory | ||||
belonging to sys.path). You can copy it explicitly there or just link to it. | ||||
IPython will proceed with builtin defaults. | ||||
""" | ||||
warn(warning) | ||||
wait() | ||||
return | ||||
if mode == 'install': | ||||
try: | ||||
shutil.copytree(rcdir,ipythondir) | ||||
os.chdir(ipythondir) | ||||
rc_files = glb("ipythonrc*") | ||||
for rc_file in rc_files: | ||||
os.rename(rc_file,rc_file+rc_suffix) | ||||
except: | ||||
warning = """ | ||||
There was a problem with the installation: | ||||
%s | ||||
Try to correct it or contact the developers if you think it's a bug. | ||||
IPython will proceed with builtin defaults.""" % sys.exc_info()[1] | ||||
warn(warning) | ||||
wait() | ||||
return | ||||
elif mode == 'upgrade': | ||||
try: | ||||
os.chdir(ipythondir) | ||||
except: | ||||
print """ | ||||
Can not upgrade: changing to directory %s failed. Details: | ||||
%s | ||||
""" % (ipythondir,sys.exc_info()[1]) | ||||
wait() | ||||
return | ||||
else: | ||||
sources = glb(os.path.join(rcdir,'[A-Za-z]*')) | ||||
for new_full_path in sources: | ||||
new_filename = os.path.basename(new_full_path) | ||||
if new_filename.startswith('ipythonrc'): | ||||
new_filename = new_filename + rc_suffix | ||||
# The config directory should only contain files, skip any | ||||
# directories which may be there (like CVS) | ||||
if os.path.isdir(new_full_path): | ||||
continue | ||||
if os.path.exists(new_filename): | ||||
old_file = new_filename+'.old' | ||||
if os.path.exists(old_file): | ||||
os.remove(old_file) | ||||
os.rename(new_filename,old_file) | ||||
shutil.copy(new_full_path,new_filename) | ||||
else: | ||||
raise ValueError,'unrecognized mode for install:',`mode` | ||||
# Fix line-endings to those native to each platform in the config | ||||
# directory. | ||||
try: | ||||
os.chdir(ipythondir) | ||||
except: | ||||
print """ | ||||
Problem: changing to directory %s failed. | ||||
Details: | ||||
%s | ||||
Some configuration files may have incorrect line endings. This should not | ||||
cause any problems during execution. """ % (ipythondir,sys.exc_info()[1]) | ||||
wait() | ||||
else: | ||||
for fname in glb('ipythonrc*'): | ||||
try: | ||||
native_line_ends(fname,backup=0) | ||||
except IOError: | ||||
pass | ||||
if mode == 'install': | ||||
print """ | ||||
Successful installation! | ||||
Please read the sections 'Initial Configuration' and 'Quick Tips' in the | ||||
IPython manual (there are both HTML and PDF versions supplied with the | ||||
distribution) to make sure that your system environment is properly configured | ||||
|
r131 | to take advantage of IPython's features. | ||
Important note: the configuration system has changed! The old system is | ||||
still in place, but its setting may be partly overridden by the settings in | ||||
"~/.ipython/ipy_user_conf.py" config file. Please take a look at the file | ||||
if some of the new settings bother you. | ||||
""" | ||||
|
r0 | else: | ||
print """ | ||||
Successful upgrade! | ||||
All files in your directory: | ||||
%(ipythondir)s | ||||
which would have been overwritten by the upgrade were backed up with a .old | ||||
extension. If you had made particular customizations in those files you may | ||||
want to merge them back into the new files.""" % locals() | ||||
wait() | ||||
os.chdir(cwd) | ||||
# end user_setup() | ||||
def atexit_operations(self): | ||||
"""This will be executed at the time of exit. | ||||
Saving of persistent data should be performed here. """ | ||||
|
r106 | #print '*** IPython exit cleanup ***' # dbg | ||
|
r0 | # input history | ||
self.savehist() | ||||
# Cleanup all tempfiles left around | ||||
for tfile in self.tempfiles: | ||||
try: | ||||
os.unlink(tfile) | ||||
except OSError: | ||||
pass | ||||
|
r165 | self.hooks.shutdown_hook() | ||
|
r0 | |||
def savehist(self): | ||||
"""Save input history to a file (via readline library).""" | ||||
try: | ||||
self.readline.write_history_file(self.histfile) | ||||
except: | ||||
print 'Unable to save IPython command history to file: ' + \ | ||||
`self.histfile` | ||||
|
r595 | def reloadhist(self): | ||
"""Reload the input history from disk file.""" | ||||
if self.has_readline: | ||||
self.readline.clear_history() | ||||
self.readline.read_history_file(self.shell.histfile) | ||||
|
r408 | def history_saving_wrapper(self, func): | ||
""" Wrap func for readline history saving | ||||
Convert func into callable that saves & restores | ||||
history around the call """ | ||||
if not self.has_readline: | ||||
return func | ||||
def wrapper(): | ||||
self.savehist() | ||||
try: | ||||
func() | ||||
finally: | ||||
readline.read_history_file(self.histfile) | ||||
return wrapper | ||||
|
r0 | def pre_readline(self): | ||
"""readline hook to be used at the start of each line. | ||||
Currently it handles auto-indent only.""" | ||||
|
r53 | |||
|
r145 | #debugx('self.indent_current_nsp','pre_readline:') | ||
|
r648 | |||
|
r682 | if self.rl_do_indent: | ||
self.readline.insert_text(self.indent_current_str()) | ||||
if self.rl_next_input is not None: | ||||
self.readline.insert_text(self.rl_next_input) | ||||
self.rl_next_input = None | ||||
|
r0 | |||
def init_readline(self): | ||||
"""Command history completion/saving/reloading.""" | ||||
|
r161 | |||
|
r784 | |||
|
r161 | import IPython.rlineimpl as readline | ||
|
r784 | |||
|
r161 | if not readline.have_readline: | ||
|
r0 | self.has_readline = 0 | ||
|
r51 | self.readline = None | ||
|
r0 | # no point in bugging windows users with this every time: | ||
|
r160 | warn('Readline services not available on this platform.') | ||
|
r0 | else: | ||
|
r161 | sys.modules['readline'] = readline | ||
|
r0 | import atexit | ||
|
r51 | from IPython.completer import IPCompleter | ||
self.Completer = IPCompleter(self, | ||||
self.user_ns, | ||||
self.user_global_ns, | ||||
self.rc.readline_omit__names, | ||||
self.alias_table) | ||||
|
r394 | sdisp = self.strdispatchers.get('complete_command', StrDispatch()) | ||
self.strdispatchers['complete_command'] = sdisp | ||||
self.Completer.custom_completers = sdisp | ||||
|
r0 | # Platform-specific configuration | ||
if os.name == 'nt': | ||||
self.readline_startup_hook = readline.set_pre_input_hook | ||||
else: | ||||
self.readline_startup_hook = readline.set_startup_hook | ||||
# Load user's initrc file (readline config) | ||||
inputrc_name = os.environ.get('INPUTRC') | ||||
if inputrc_name is None: | ||||
home_dir = get_home_dir() | ||||
if home_dir is not None: | ||||
inputrc_name = os.path.join(home_dir,'.inputrc') | ||||
if os.path.isfile(inputrc_name): | ||||
try: | ||||
readline.read_init_file(inputrc_name) | ||||
except: | ||||
warn('Problems reading readline initialization file <%s>' | ||||
% inputrc_name) | ||||
self.has_readline = 1 | ||||
self.readline = readline | ||||
# save this in sys so embedded copies can restore it properly | ||||
sys.ipcompleter = self.Completer.complete | ||||
|
r593 | self.set_completer() | ||
|
r0 | |||
# Configure readline according to user's prefs | ||||
for rlcommand in self.rc.readline_parse_and_bind: | ||||
readline.parse_and_bind(rlcommand) | ||||
# remove some chars from the delimiters list | ||||
delims = readline.get_completer_delims() | ||||
delims = delims.translate(string._idmap, | ||||
self.rc.readline_remove_delims) | ||||
readline.set_completer_delims(delims) | ||||
# otherwise we end up with a monster history after a while: | ||||
readline.set_history_length(1000) | ||||
try: | ||||
#print '*** Reading readline history' # dbg | ||||
readline.read_history_file(self.histfile) | ||||
except IOError: | ||||
pass # It doesn't exist yet. | ||||
atexit.register(self.atexit_operations) | ||||
del atexit | ||||
# Configure auto-indent for all platforms | ||||
self.set_autoindent(self.rc.autoindent) | ||||
|
r323 | def ask_yes_no(self,prompt,default=True): | ||
if self.rc.quiet: | ||||
return True | ||||
return ask_yes_no(prompt,default) | ||||
|
r54 | def _should_recompile(self,e): | ||
"""Utility routine for edit_syntax_error""" | ||||
|
r95 | |||
|
r54 | if e.filename in ('<ipython console>','<input>','<string>', | ||
|
r292 | '<console>','<BackgroundJob compilation>', | ||
None): | ||||
|
r100 | |||
|
r54 | return False | ||
try: | ||||
|
r172 | if (self.rc.autoedit_syntax and | ||
|
r323 | not self.ask_yes_no('Return to editor to correct syntax error? ' | ||
|
r158 | '[Y/n] ','y')): | ||
|
r54 | return False | ||
except EOFError: | ||||
return False | ||||
|
r88 | |||
def int0(x): | ||||
try: | ||||
return int(x) | ||||
except TypeError: | ||||
return 0 | ||||
# always pass integer line and offset values to editor hook | ||||
self.hooks.fix_error_editor(e.filename, | ||||
int0(e.lineno),int0(e.offset),e.msg) | ||||
|
r54 | return True | ||
def edit_syntax_error(self): | ||||
"""The bottom half of the syntax error handler called in the main loop. | ||||
Loop until syntax error is fixed or user cancels. | ||||
""" | ||||
while self.SyntaxTB.last_syntax_error: | ||||
# copy and clear last_syntax_error | ||||
err = self.SyntaxTB.clear_err_state() | ||||
if not self._should_recompile(err): | ||||
return | ||||
try: | ||||
# may set last_syntax_error again if a SyntaxError is raised | ||||
|
r319 | self.safe_execfile(err.filename,self.user_ns) | ||
|
r54 | except: | ||
self.showtraceback() | ||||
else: | ||||
try: | ||||
|
r292 | f = file(err.filename) | ||
try: | ||||
sys.displayhook(f.read()) | ||||
finally: | ||||
f.close() | ||||
except: | ||||
self.showtraceback() | ||||
|
r54 | |||
|
r0 | def showsyntaxerror(self, filename=None): | ||
"""Display the syntax error that just occurred. | ||||
This doesn't display a stack trace because there isn't one. | ||||
If a filename is given, it is stuffed in the exception instead | ||||
of what was there before (because Python's parser always uses | ||||
"<string>" when reading from a string). | ||||
""" | ||||
|
r69 | etype, value, last_traceback = sys.exc_info() | ||
|
r216 | |||
# See note about these variables in showtraceback() below | ||||
sys.last_type = etype | ||||
sys.last_value = value | ||||
sys.last_traceback = last_traceback | ||||
|
r69 | if filename and etype is SyntaxError: | ||
|
r0 | # Work hard to stuff the correct filename in the exception | ||
try: | ||||
msg, (dummy_filename, lineno, offset, line) = value | ||||
except: | ||||
# Not the format we expect; leave it alone | ||||
pass | ||||
else: | ||||
# Stuff in the right filename | ||||
try: | ||||
# Assume SyntaxError is a class exception | ||||
value = SyntaxError(msg, (filename, lineno, offset, line)) | ||||
except: | ||||
# If that failed, assume SyntaxError is a string | ||||
value = msg, (filename, lineno, offset, line) | ||||
|
r69 | self.SyntaxTB(etype,value,[]) | ||
|
r0 | |||
|
r470 | def debugger(self,force=False): | ||
"""Call the pydb/pdb debugger. | ||||
|
r0 | |||
|
r470 | Keywords: | ||
- force(False): by default, this routine checks the instance call_pdb | ||||
flag and does not actually invoke the debugger if the flag is false. | ||||
The 'force' option forces the debugger to activate even if the flag | ||||
is false. | ||||
""" | ||||
if not (force or self.call_pdb): | ||||
|
r0 | return | ||
|
r470 | |||
|
r491 | if not hasattr(sys,'last_traceback'): | ||
error('No traceback has been produced, nothing to debug.') | ||||
return | ||||
|
r475 | # use pydb if available | ||
|
r587 | if Debugger.has_pydb: | ||
|
r475 | from pydb import pm | ||
|
r587 | else: | ||
|
r470 | # fallback to our internal debugger | ||
pm = lambda : self.InteractiveTB.debugger(force=True) | ||||
|
r408 | self.history_saving_wrapper(pm)() | ||
|
r0 | |||
|
r216 | def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None): | ||
|
r292 | """Display the exception that just occurred. | ||
If nothing is known about the exception, this is the method which | ||||
should be used throughout the code for presenting user tracebacks, | ||||
|
r293 | rather than directly invoking the InteractiveTB object. | ||
|
r292 | |||
A specific showsyntaxerror() also exists, but this method can take | ||||
care of calling it if needed, so unless you are explicitly catching a | ||||
SyntaxError exception, don't try to analyze the stack manually and | ||||
simply call this method.""" | ||||
|
r0 | |||
|
r601 | |||
|
r0 | # Though this won't be called by syntax errors in the input line, | ||
# there may be SyntaxError cases whith imported code. | ||||
|
r601 | |||
|
r0 | if exc_tuple is None: | ||
|
r216 | etype, value, tb = sys.exc_info() | ||
|
r0 | else: | ||
|
r216 | etype, value, tb = exc_tuple | ||
|
r506 | |||
|
r216 | if etype is SyntaxError: | ||
|
r22 | self.showsyntaxerror(filename) | ||
|
r0 | else: | ||
|
r216 | # WARNING: these variables are somewhat deprecated and not | ||
# necessarily safe to use in a threaded environment, but tools | ||||
# like pdb depend on their existence, so let's set them. If we | ||||
# find problems in the field, we'll need to revisit their use. | ||||
sys.last_type = etype | ||||
sys.last_value = value | ||||
sys.last_traceback = tb | ||||
|
r506 | |||
if etype in self.custom_exceptions: | ||||
self.CustomTB(etype,value,tb) | ||||
else: | ||||
self.InteractiveTB(etype,value,tb,tb_offset=tb_offset) | ||||
if self.InteractiveTB.call_pdb and self.has_readline: | ||||
# pdb mucks up readline, fix it back | ||||
|
r593 | self.set_completer() | ||
|
r601 | |||
|
r0 | |||
def mainloop(self,banner=None): | ||||
"""Creates the local namespace and starts the mainloop. | ||||
If an optional banner argument is given, it will override the | ||||
internally created default banner.""" | ||||
|
r296 | |||
|
r0 | if self.rc.c: # Emulate Python's -c option | ||
self.exec_init_cmd() | ||||
if banner is None: | ||||
|
r176 | if not self.rc.banner: | ||
|
r0 | banner = '' | ||
|
r176 | # banner is string? Use it directly! | ||
elif isinstance(self.rc.banner,basestring): | ||||
banner = self.rc.banner | ||||
else: | ||||
banner = self.BANNER+self.banner2 | ||||
|
r0 | self.interact(banner) | ||
def exec_init_cmd(self): | ||||
"""Execute a command given at the command line. | ||||
This emulates Python's -c option.""" | ||||
|
r153 | #sys.argv = ['-c'] | ||
|
r712 | self.push(self.prefilter(self.rc.c, False)) | ||
self.exit_now = True | ||||
|
r0 | |||
def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0): | ||||
"""Embeds IPython into a running python program. | ||||
Input: | ||||
- header: An optional header message can be specified. | ||||
- local_ns, global_ns: working namespaces. If given as None, the | ||||
IPython-initialized one is updated with __main__.__dict__, so that | ||||
program variables become visible but user-specific configuration | ||||
remains possible. | ||||
- stack_depth: specifies how many levels in the stack to go to | ||||
looking for namespaces (when local_ns and global_ns are None). This | ||||
allows an intermediate caller to make sure that this function gets | ||||
the namespace from the intended level in the stack. By default (0) | ||||
it will get its locals and globals from the immediate caller. | ||||
Warning: it's possible to use this in a program which is being run by | ||||
IPython itself (via %run), but some funny things will happen (a few | ||||
globals get overwritten). In the future this will be cleaned up, as | ||||
there is no fundamental reason why it can't work perfectly.""" | ||||
# Get locals and globals from caller | ||||
if local_ns is None or global_ns is None: | ||||
call_frame = sys._getframe(stack_depth).f_back | ||||
if local_ns is None: | ||||
local_ns = call_frame.f_locals | ||||
if global_ns is None: | ||||
global_ns = call_frame.f_globals | ||||
# Update namespaces and fire up interpreter | ||||
|
r82 | |||
# The global one is easy, we can just throw it in | ||||
|
r39 | self.user_global_ns = global_ns | ||
|
r82 | # but the user/local one is tricky: ipython needs it to store internal | ||
# data, but we also need the locals. We'll copy locals in the user | ||||
# one, but will track what got copied so we can delete them at exit. | ||||
# This is so that a later embedded call doesn't see locals from a | ||||
# previous call (which most likely existed in a separate scope). | ||||
local_varnames = local_ns.keys() | ||||
self.user_ns.update(local_ns) | ||||
|
r39 | # Patch for global embedding to make sure that things don't overwrite | ||
# user globals accidentally. Thanks to Richard <rxe@renre-europe.com> | ||||
# FIXME. Test this a bit more carefully (the if.. is new) | ||||
if local_ns is None and global_ns is None: | ||||
self.user_global_ns.update(__main__.__dict__) | ||||
|
r0 | |||
|
r47 | # make sure the tab-completer has the correct frame information, so it | ||
# actually completes using the frame's locals/globals | ||||
|
r89 | self.set_completer_frame() | ||
|
r82 | |||
# before activating the interactive mode, we need to make sure that | ||||
# all names in the builtin namespace needed by ipython point to | ||||
# ourselves, and not to other instances. | ||||
self.add_builtins() | ||||
|
r749 | |||
|
r39 | self.interact(header) | ||
|
r82 | |||
# now, purge out the user namespace from anything we might have added | ||||
# from the caller's local namespace | ||||
delvar = self.user_ns.pop | ||||
for var in local_varnames: | ||||
delvar(var,None) | ||||
# and clean builtins we may have overridden | ||||
self.clean_builtins() | ||||
|
r0 | |||
def interact(self, banner=None): | ||||
"""Closely emulate the interactive Python console. | ||||
The optional banner argument specify the banner to print | ||||
before the first interaction; by default it prints a banner | ||||
similar to the one printed by the real Python interpreter, | ||||
followed by the current class name in parentheses (so as not | ||||
to confuse this with the real interpreter -- since it's so | ||||
close!). | ||||
""" | ||||
|
r325 | |||
if self.exit_now: | ||||
# batch run -> do not interact | ||||
return | ||||
|
r0 | cprt = 'Type "copyright", "credits" or "license" for more information.' | ||
if banner is None: | ||||
self.write("Python %s on %s\n%s\n(%s)\n" % | ||||
(sys.version, sys.platform, cprt, | ||||
self.__class__.__name__)) | ||||
else: | ||||
self.write(banner) | ||||
more = 0 | ||||
|
r46 | |||
|
r0 | # Mark activity in the builtins | ||
__builtin__.__dict__['__IPYTHON__active'] += 1 | ||||
|
r5 | |||
|
r784 | if self.has_readline: | ||
|
r700 | self.readline_startup_hook(self.pre_readline) | ||
|
r5 | # exit_now is set by a call to %Exit or %Quit | ||
|
r700 | |||
|
r5 | while not self.exit_now: | ||
|
r163 | if more: | ||
|
r330 | prompt = self.hooks.generate_prompt(True) | ||
|
r163 | if self.autoindent: | ||
|
r682 | self.rl_do_indent = True | ||
|
r163 | else: | ||
|
r330 | prompt = self.hooks.generate_prompt(False) | ||
|
r0 | try: | ||
|
r163 | line = self.raw_input(prompt,more) | ||
|
r370 | if self.exit_now: | ||
# quick exit on sys.std[in|out] close | ||||
break | ||||
|
r163 | if self.autoindent: | ||
|
r682 | self.rl_do_indent = False | ||
|
r0 | except KeyboardInterrupt: | ||
|
r163 | self.write('\nKeyboardInterrupt\n') | ||
|
r0 | self.resetbuffer() | ||
# keep cache in sync with the prompt counter: | ||||
self.outputcache.prompt_count -= 1 | ||||
if self.autoindent: | ||||
|
r53 | self.indent_current_nsp = 0 | ||
|
r163 | more = 0 | ||
except EOFError: | ||||
if self.autoindent: | ||||
|
r682 | self.rl_do_indent = False | ||
|
r163 | self.readline_startup_hook(None) | ||
self.write('\n') | ||||
self.exit() | ||||
|
r0 | except bdb.BdbQuit: | ||
|
r163 | warn('The Python debugger has exited with a BdbQuit exception.\n' | ||
'Because of how pdb handles the stack, it is impossible\n' | ||||
'for IPython to properly format this particular exception.\n' | ||||
'IPython will resume normal operation.') | ||||
except: | ||||
# exceptions here are VERY RARE, but they can be triggered | ||||
# asynchronously by signal handlers, for example. | ||||
self.showtraceback() | ||||
else: | ||||
more = self.push(line) | ||||
if (self.SyntaxTB.last_syntax_error and | ||||
self.rc.autoedit_syntax): | ||||
self.edit_syntax_error() | ||||
|
r5 | |||
|
r0 | # We are off again... | ||
__builtin__.__dict__['__IPYTHON__active'] -= 1 | ||||
|
r216 | def excepthook(self, etype, value, tb): | ||
|
r0 | """One more defense for GUI apps that call sys.excepthook. | ||
GUI frameworks like wxPython trap exceptions and call | ||||
sys.excepthook themselves. I guess this is a feature that | ||||
enables them to keep running after exceptions that would | ||||
otherwise kill their mainloop. This is a bother for IPython | ||||
which excepts to catch all of the program exceptions with a try: | ||||
except: statement. | ||||
Normally, IPython sets sys.excepthook to a CrashHandler instance, so if | ||||
any app directly invokes sys.excepthook, it will look to the user like | ||||
IPython crashed. In order to work around this, we can disable the | ||||
CrashHandler and replace it with this excepthook instead, which prints a | ||||
regular traceback using our InteractiveTB. In this fashion, apps which | ||||
call sys.excepthook will generate a regular-looking exception from | ||||
IPython, and the CrashHandler will only be triggered by real IPython | ||||
crashes. | ||||
This hook should be used sparingly, only in places which are not likely | ||||
to be true IPython errors. | ||||
""" | ||||
|
r216 | self.showtraceback((etype,value,tb),tb_offset=0) | ||
|
r0 | |||
|
r374 | def expand_aliases(self,fn,rest): | ||
""" Expand multiple levels of aliases: | ||||
if: | ||||
alias foo bar /tmp | ||||
alias baz foo | ||||
then: | ||||
baz huhhahhei -> bar /tmp huhhahhei | ||||
""" | ||||
line = fn + " " + rest | ||||
|
r377 | |||
done = Set() | ||||
|
r374 | while 1: | ||
|
r657 | pre,fn,rest = prefilter.splitUserInput(line, | ||
prefilter.shell_line_split) | ||||
|
r374 | if fn in self.alias_table: | ||
|
r377 | if fn in done: | ||
warn("Cyclic alias definition, repeated '%s'" % fn) | ||||
return "" | ||||
done.add(fn) | ||||
|
r374 | l2 = self.transform_alias(fn,rest) | ||
|
r376 | # dir -> dir | ||
|
r399 | # print "alias",line, "->",l2 #dbg | ||
|
r374 | if l2 == line: | ||
break | ||||
|
r376 | # ls -> ls -F should not recurse forever | ||
if l2.split(None,1)[0] == line.split(None,1)[0]: | ||||
line = l2 | ||||
break | ||||
line=l2 | ||||
|
r374 | # print "al expand to",line #dbg | ||
else: | ||||
break | ||||
return line | ||||
|
r169 | def transform_alias(self, alias,rest=''): | ||
|
r316 | """ Transform alias to system command string. | ||
|
r169 | """ | ||
|
r783 | trg = self.alias_table[alias] | ||
nargs,cmd = trg | ||||
# print trg #dbg | ||||
|
r239 | if ' ' in cmd and os.path.isfile(cmd): | ||
|
r235 | cmd = '"%s"' % cmd | ||
|
r0 | # Expand the %l special to be the user's input line | ||
if cmd.find('%l') >= 0: | ||||
cmd = cmd.replace('%l',rest) | ||||
rest = '' | ||||
if nargs==0: | ||||
# Simple, argument-less aliases | ||||
cmd = '%s %s' % (cmd,rest) | ||||
else: | ||||
# Handle aliases with positional arguments | ||||
args = rest.split(None,nargs) | ||||
if len(args)< nargs: | ||||
error('Alias <%s> requires %s arguments, %s given.' % | ||||
(alias,nargs,len(args))) | ||||
|
r169 | return None | ||
|
r0 | cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:])) | ||
# Now call the macro, evaluating in the user's namespace | ||||
|
r316 | #print 'new command: <%r>' % cmd # dbg | ||
|
r169 | return cmd | ||
def call_alias(self,alias,rest=''): | ||||
"""Call an alias given its name and the rest of the line. | ||||
This is only used to provide backwards compatibility for users of | ||||
ipalias(), use of which is not recommended for anymore.""" | ||||
# Now call the macro, evaluating in the user's namespace | ||||
cmd = self.transform_alias(alias, rest) | ||||
|
r0 | try: | ||
self.system(cmd) | ||||
except: | ||||
self.showtraceback() | ||||
|
r125 | def indent_current_str(self): | ||
"""return the current level of indentation as a string""" | ||||
return self.indent_current_nsp * ' ' | ||||
|
r69 | def autoindent_update(self,line): | ||
"""Keep track of the indent level.""" | ||||
|
r106 | |||
|
r145 | #debugx('line') | ||
#debugx('self.indent_current_nsp') | ||||
|
r69 | if self.autoindent: | ||
if line: | ||||
|
r125 | inisp = num_ini_spaces(line) | ||
if inisp < self.indent_current_nsp: | ||||
self.indent_current_nsp = inisp | ||||
|
r69 | |||
if line[-1] == ':': | ||||
self.indent_current_nsp += 4 | ||||
elif dedent_re.match(line): | ||||
self.indent_current_nsp -= 4 | ||||
else: | ||||
self.indent_current_nsp = 0 | ||||
|
r0 | def runlines(self,lines): | ||
"""Run a string of one or more lines of source. | ||||
This method is capable of running a string containing multiple source | ||||
lines, as if they had been entered at the IPython prompt. Since it | ||||
exposes IPython's processing machinery, the given strings can contain | ||||
magic calls (%magic), special shell access (!cmd), etc.""" | ||||
# We must start with a clean buffer, in case this is run from an | ||||
# interactive IPython session (via a magic, for example). | ||||
self.resetbuffer() | ||||
lines = lines.split('\n') | ||||
more = 0 | ||||
|
r745 | |||
|
r0 | for line in lines: | ||
# skip blank lines so we don't mess up the prompt counter, but do | ||||
# NOT skip even a blank line if we are in a code block (more is | ||||
# true) | ||||
|
r745 | |||
|
r0 | if line or more: | ||
|
r745 | # push to raw history, so hist line numbers stay in sync | ||
self.input_hist_raw.append("# " + line + "\n") | ||||
|
r72 | more = self.push(self.prefilter(line,more)) | ||
|
r0 | # IPython's runsource returns None if there was an error | ||
# compiling the code. This allows us to stop processing right | ||||
# away, so the user gets the error message at the right place. | ||||
if more is None: | ||||
break | ||||
|
r761 | else: | ||
self.input_hist_raw.append("\n") | ||||
|
r0 | # final newline in case the input didn't have it, so that the code | ||
# actually does get executed | ||||
if more: | ||||
self.push('\n') | ||||
|
r53 | def runsource(self, source, filename='<input>', symbol='single'): | ||
|
r0 | """Compile and run some source in the interpreter. | ||
Arguments are as for compile_command(). | ||||
One several things can happen: | ||||
1) The input is incorrect; compile_command() raised an | ||||
exception (SyntaxError or OverflowError). A syntax traceback | ||||
will be printed by calling the showsyntaxerror() method. | ||||
2) The input is incomplete, and more input is required; | ||||
compile_command() returned None. Nothing happens. | ||||
3) The input is complete; compile_command() returned a code | ||||
object. The code is executed by calling self.runcode() (which | ||||
also handles run-time exceptions, except for SystemExit). | ||||
The return value is: | ||||
- True in case 2 | ||||
- False in the other cases, unless an exception is raised, where | ||||
None is returned instead. This can be used by external callers to | ||||
know whether to continue feeding input or not. | ||||
The return value can be used to decide whether to use sys.ps1 or | ||||
sys.ps2 to prompt the next line.""" | ||||
|
r10 | |||
|
r420 | # if the source code has leading blanks, add 'if 1:\n' to it | ||
# this allows execution of indented pasted code. It is tempting | ||||
# to add '\n' at the end of source to run commands like ' a=1' | ||||
# directly, but this fails for more complicated scenarios | ||||
if source[:1] in [' ', '\t']: | ||||
source = 'if 1:\n%s' % source | ||||
|
r0 | try: | ||
|
r53 | code = self.compile(source,filename,symbol) | ||
|
r0 | except (OverflowError, SyntaxError, ValueError): | ||
# Case 1 | ||||
self.showsyntaxerror(filename) | ||||
return None | ||||
if code is None: | ||||
# Case 2 | ||||
return True | ||||
# Case 3 | ||||
|
r10 | # We store the code object so that threaded shells and | ||
|
r0 | # custom exception handlers can access all this info if needed. | ||
|
r10 | # The source corresponding to this can be obtained from the | ||
# buffer attribute as '\n'.join(self.buffer). | ||||
|
r0 | self.code_to_run = code | ||
# now actually execute the code object | ||||
if self.runcode(code) == 0: | ||||
return False | ||||
else: | ||||
return None | ||||
def runcode(self,code_obj): | ||||
"""Execute a code object. | ||||
When an exception occurs, self.showtraceback() is called to display a | ||||
traceback. | ||||
Return value: a flag indicating whether the code to be run completed | ||||
successfully: | ||||
- 0: successful execution. | ||||
- 1: an error occurred. | ||||
""" | ||||
# Set our own excepthook in case the user code tries to call it | ||||
# directly, so that the IPython crash handler doesn't get triggered | ||||
old_excepthook,sys.excepthook = sys.excepthook, self.excepthook | ||||
|
r59 | |||
# we save the original sys.excepthook in the instance, in case config | ||||
# code (such as magics) needs access to it. | ||||
self.sys_excepthook = old_excepthook | ||||
|
r0 | outflag = 1 # happens in more places, so it's easier as default | ||
try: | ||||
try: | ||||
|
r41 | # Embedded instances require separate global/local namespaces | ||
# so they can see both the surrounding (local) namespace and | ||||
# the module-level globals when called inside another function. | ||||
if self.embedded: | ||||
exec code_obj in self.user_global_ns, self.user_ns | ||||
# Normal (non-embedded) instances should only have a single | ||||
# namespace for user code execution, otherwise functions won't | ||||
# see interactive top-level globals. | ||||
else: | ||||
exec code_obj in self.user_ns | ||||
|
r0 | finally: | ||
# Reset our crash handler in place | ||||
sys.excepthook = old_excepthook | ||||
except SystemExit: | ||||
self.resetbuffer() | ||||
self.showtraceback() | ||||
|
r366 | warn("Type %exit or %quit to exit IPython " | ||
|
r51 | "(%Exit or %Quit do so unconditionally).",level=1) | ||
|
r0 | except self.custom_exceptions: | ||
etype,value,tb = sys.exc_info() | ||||
self.CustomTB(etype,value,tb) | ||||
except: | ||||
self.showtraceback() | ||||
else: | ||||
outflag = 0 | ||||
|
r51 | if softspace(sys.stdout, 0): | ||
|
r0 | |||
# Flush out code object which has been run (and source) | ||||
self.code_to_run = None | ||||
return outflag | ||||
|
r51 | |||
def push(self, line): | ||||
"""Push a line to the interpreter. | ||||
The line should not have a trailing newline; it may have | ||||
internal newlines. The line is appended to a buffer and the | ||||
interpreter's runsource() method is called with the | ||||
concatenated contents of the buffer as source. If this | ||||
indicates that the command was executed or invalid, the buffer | ||||
is reset; otherwise, the command is incomplete, and the buffer | ||||
is left as it was after the line was appended. The return | ||||
value is 1 if more input is required, 0 if the line was dealt | ||||
with in some way (this is the same as runsource()). | ||||
""" | ||||
|
r72 | |||
# autoindent management should be done here, and not in the | ||||
# interactive loop, since that one is only seen by keyboard input. We | ||||
# need this done correctly even for code run via runlines (which uses | ||||
# push). | ||||
|
r76 | |||
|
r77 | #print 'push line: <%s>' % line # dbg | ||
|
r353 | for subline in line.splitlines(): | ||
self.autoindent_update(subline) | ||||
|
r51 | self.buffer.append(line) | ||
|
r52 | more = self.runsource('\n'.join(self.buffer), self.filename) | ||
|
r51 | if not more: | ||
self.resetbuffer() | ||||
return more | ||||
|
r666 | def split_user_input(self, line): | ||
# This is really a hold-over to support ipapi and some extensions | ||||
return prefilter.splitUserInput(line) | ||||
|
r51 | def resetbuffer(self): | ||
"""Reset the input buffer.""" | ||||
self.buffer[:] = [] | ||||
|
r125 | |||
|
r50 | def raw_input(self,prompt='',continue_prompt=False): | ||
|
r0 | """Write a prompt and read a line. | ||
The returned line does not include the trailing newline. | ||||
When the user enters the EOF key sequence, EOFError is raised. | ||||
|
r50 | Optional inputs: | ||
- prompt(''): a string to be printed to prompt the user. | ||||
- continue_prompt(False): whether this line is the first one or a | ||||
continuation in a sequence of inputs. | ||||
|
r0 | """ | ||
|
r50 | |||
|
r593 | # Code run by the user may have modified the readline completer state. | ||
# We must ensure that our completer is back in place. | ||||
|
r601 | if self.has_readline: | ||
self.set_completer() | ||||
|
r593 | |||
|
r370 | try: | ||
|
r595 | line = raw_input_original(prompt).decode(self.stdin_encoding) | ||
|
r370 | except ValueError: | ||
|
r593 | warn("\n********\nYou or a %run:ed script called sys.stdin.close()" | ||
" or sys.stdout.close()!\nExiting IPython!") | ||||
|
r370 | self.exit_now = True | ||
return "" | ||||
|
r163 | |||
|
r50 | # Try to be reasonably smart about not re-indenting pasted input more | ||
# than necessary. We do this by trimming out the auto-indent initial | ||||
# spaces, if the user's actual input started itself with whitespace. | ||||
|
r145 | #debugx('self.buffer[-1]') | ||
|
r125 | |||
if self.autoindent: | ||||
if num_ini_spaces(line) > self.indent_current_nsp: | ||||
line = line[self.indent_current_nsp:] | ||||
self.indent_current_nsp = 0 | ||||
|
r145 | # store the unfiltered input before the user has any chance to modify | ||
# it. | ||||
if line.strip(): | ||||
if continue_prompt: | ||||
self.input_hist_raw[-1] += '%s\n' % line | ||||
|
r353 | if self.has_readline: # and some config option is set? | ||
try: | ||||
histlen = self.readline.get_current_history_length() | ||||
newhist = self.input_hist_raw[-1].rstrip() | ||||
self.readline.remove_history_item(histlen-1) | ||||
self.readline.replace_history_item(histlen-2,newhist) | ||||
except AttributeError: | ||||
pass # re{move,place}_history_item are new in 2.4. | ||||
|
r145 | else: | ||
|
r729 | self.input_hist_raw.append('%s\n' % line) | ||
|
r761 | # only entries starting at first column go to shadow history | ||
|
r731 | if line.lstrip() == line: | ||
self.shadowhist.add(line.strip()) | ||||
|
r787 | elif not continue_prompt: | ||
|
r761 | self.input_hist_raw.append('\n') | ||
|
r292 | try: | ||
lineout = self.prefilter(line,continue_prompt) | ||||
except: | ||||
# blanket except, in case a user-defined prefilter crashes, so it | ||||
# can't take all of ipython with it. | ||||
self.showtraceback() | ||||
|
r309 | return '' | ||
else: | ||||
return lineout | ||||
|
r533 | |||
|
r0 | def _prefilter(self, line, continue_prompt): | ||
"""Calls different preprocessors, depending on the form of line.""" | ||||
# All handlers *must* return a value, even if it's blank (''). | ||||
# Lines are NOT logged here. Handlers should process the line as | ||||
# needed, update the cache AND log it (so that the input cache array | ||||
# stays synced). | ||||
#..................................................................... | ||||
# Code begins | ||||
#if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg | ||||
# save the line away in case we crash, so the post-mortem handler can | ||||
# record it | ||||
self._last_input_line = line | ||||
#print '***line: <%s>' % line # dbg | ||||
|
r657 | |||
|
r750 | if not line: | ||
# Return immediately on purely empty lines, so that if the user | ||||
# previously typed some whitespace that started a continuation | ||||
# prompt, he can break out of that loop with just an empty line. | ||||
# This is how the default python prompt works. | ||||
# Only return if the accumulated input buffer was just whitespace! | ||||
if ''.join(self.buffer).isspace(): | ||||
self.buffer[:] = [] | ||||
return '' | ||||
|
r657 | line_info = prefilter.LineInfo(line, continue_prompt) | ||
|
r50 | |||
|
r0 | # the input history needs to track even empty lines | ||
|
r149 | stripped = line.strip() | ||
if not stripped: | ||||
|
r0 | if not continue_prompt: | ||
self.outputcache.prompt_count -= 1 | ||||
|
r657 | return self.handle_normal(line_info) | ||
|
r0 | |||
# print '***cont',continue_prompt # dbg | ||||
# special handlers are only allowed for single line statements | ||||
if continue_prompt and not self.rc.multi_line_specials: | ||||
|
r657 | return self.handle_normal(line_info) | ||
|
r149 | |||
|
r657 | # See whether any pre-existing handler can take care of it | ||
|
r149 | rewritten = self.hooks.input_prefilter(stripped) | ||
if rewritten != stripped: # ok, some prefilter did something | ||||
|
r657 | rewritten = line_info.pre + rewritten # add indentation | ||
return self.handle_normal(prefilter.LineInfo(rewritten, | ||||
continue_prompt)) | ||||
|
r149 | |||
|
r0 | #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg | ||
|
r570 | |||
|
r657 | return prefilter.prefilter(line_info, self) | ||
|
r0 | |||
def _prefilter_dumb(self, line, continue_prompt): | ||||
"""simple prefilter function, for debugging""" | ||||
return self.handle_normal(line,continue_prompt) | ||||
|
r367 | |||
def multiline_prefilter(self, line, continue_prompt): | ||||
""" Run _prefilter for each line of input | ||||
Covers cases where there are multiple lines in the user entry, | ||||
which is the case when the user goes back to a multiline history | ||||
entry and presses enter. | ||||
""" | ||||
out = [] | ||||
for l in line.rstrip('\n').split('\n'): | ||||
out.append(self._prefilter(l, continue_prompt)) | ||||
return '\n'.join(out) | ||||
|
r0 | # Set the default prefilter() function (this can be user-overridden) | ||
|
r367 | prefilter = multiline_prefilter | ||
|
r0 | |||
|
r657 | def handle_normal(self,line_info): | ||
|
r0 | """Handle normal input lines. Use as a template for handlers.""" | ||
|
r53 | # With autoindent on, we need some way to exit the input loop, and I | ||
# don't want to force the user to have to backspace all the way to | ||||
# clear the line. The rule will be in this case, that either two | ||||
# lines of pure whitespace in a row, or a line of pure whitespace but | ||||
# of a size different to the indent level, will exit the input loop. | ||||
|
r657 | line = line_info.line | ||
continue_prompt = line_info.continue_prompt | ||||
|
r72 | |||
|
r106 | if (continue_prompt and self.autoindent and line.isspace() and | ||
|
r136 | (0 < abs(len(line) - self.indent_current_nsp) <= 2 or | ||
|
r125 | (self.buffer[-1]).isspace() )): | ||
|
r53 | line = '' | ||
|
r309 | self.log(line,line,continue_prompt) | ||
|
r0 | return line | ||
|
r657 | def handle_alias(self,line_info): | ||
|
r737 | """Handle alias input lines. """ | ||
tgt = self.alias_table[line_info.iFun] | ||||
# print "=>",tgt #dbg | ||||
if callable(tgt): | ||||
|
r773 | line_out = "_sh." + line_info.iFun + '(r"""' + line_info.line + '""")' | ||
|
r737 | else: | ||
transformed = self.expand_aliases(line_info.iFun,line_info.theRest) | ||||
|
r0 | |||
|
r737 | # pre is needed, because it carries the leading whitespace. Otherwise | ||
# aliases won't work in indented sections. | ||||
line_out = '%s_ip.system(%s)' % (line_info.preWhitespace, | ||||
make_quoted_expr( transformed )) | ||||
|
r657 | |||
self.log(line_info.line,line_out,line_info.continue_prompt) | ||||
|
r316 | #print 'line out:',line_out # dbg | ||
|
r72 | return line_out | ||
|
r0 | |||
|
r657 | def handle_shell_escape(self, line_info): | ||
|
r0 | """Execute the line in a shell, empty return value""" | ||
|
r10 | #print 'line in :', `line` # dbg | ||
|
r657 | line = line_info.line | ||
|
r105 | if line.lstrip().startswith('!!'): | ||
|
r657 | # rewrite LineInfo's line, iFun and theRest to properly hold the | ||
# call to %sx and the actual command to be executed, so | ||||
# handle_magic can work correctly. Note that this works even if | ||||
# the line is indented, so it handles multi_line_specials | ||||
# properly. | ||||
new_rest = line.lstrip()[2:] | ||||
line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest) | ||||
line_info.iFun = 'sx' | ||||
line_info.theRest = new_rest | ||||
return self.handle_magic(line_info) | ||||
|
r100 | else: | ||
|
r657 | cmd = line.lstrip().lstrip('!') | ||
line_out = '%s_ip.system(%s)' % (line_info.preWhitespace, | ||||
make_quoted_expr(cmd)) | ||||
|
r0 | # update cache/log and return | ||
|
r657 | self.log(line,line_out,line_info.continue_prompt) | ||
|
r0 | return line_out | ||
|
r657 | def handle_magic(self, line_info): | ||
|
r100 | """Execute magic functions.""" | ||
|
r657 | iFun = line_info.iFun | ||
theRest = line_info.theRest | ||||
cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace, | ||||
make_quoted_expr(iFun + " " + theRest)) | ||||
self.log(line_info.line,cmd,line_info.continue_prompt) | ||||
|
r48 | #print 'in handle_magic, cmd=<%s>' % cmd # dbg | ||
|
r0 | return cmd | ||
|
r657 | def handle_auto(self, line_info): | ||
|
r0 | """Hande lines which can be auto-executed, quoting if requested.""" | ||
#print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg | ||||
|
r657 | line = line_info.line | ||
iFun = line_info.iFun | ||||
theRest = line_info.theRest | ||||
pre = line_info.pre | ||||
continue_prompt = line_info.continue_prompt | ||||
obj = line_info.ofind(self)['obj'] | ||||
|
r0 | |||
# This should only be active for single-line input! | ||||
if continue_prompt: | ||||
|
r305 | self.log(line,line,continue_prompt) | ||
|
r0 | return line | ||
|
r654 | force_auto = isinstance(obj, IPython.ipapi.IPyAutocall) | ||
|
r84 | auto_rewrite = True | ||
|
r155 | |||
|
r0 | if pre == self.ESC_QUOTE: | ||
# Auto-quote splitting on whitespace | ||||
|
r19 | newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) ) | ||
|
r0 | elif pre == self.ESC_QUOTE2: | ||
# Auto-quote whole string | ||||
|
r19 | newcmd = '%s("%s")' % (iFun,theRest) | ||
|
r155 | elif pre == self.ESC_PAREN: | ||
newcmd = '%s(%s)' % (iFun,",".join(theRest.split())) | ||||
|
r0 | else: | ||
|
r84 | # Auto-paren. | ||
# We only apply it to argument-less calls if the autocall | ||||
# parameter is set to 2. We only need to check that autocall is < | ||||
# 2, since this function isn't called unless it's at least 1. | ||||
|
r654 | if not theRest and (self.rc.autocall < 2) and not force_auto: | ||
|
r87 | newcmd = '%s %s' % (iFun,theRest) | ||
auto_rewrite = False | ||||
|
r0 | else: | ||
|
r654 | if not force_auto and theRest.startswith('['): | ||
|
r84 | if hasattr(obj,'__getitem__'): | ||
# Don't autocall in this case: item access for an object | ||||
# which is BOTH callable and implements __getitem__. | ||||
newcmd = '%s %s' % (iFun,theRest) | ||||
auto_rewrite = False | ||||
else: | ||||
# if the object doesn't support [] access, go ahead and | ||||
# autocall | ||||
|
r179 | newcmd = '%s(%s)' % (iFun.rstrip(),theRest) | ||
|
r84 | elif theRest.endswith(';'): | ||
newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1]) | ||||
else: | ||||
|
r179 | newcmd = '%s(%s)' % (iFun.rstrip(), theRest) | ||
|
r0 | |||
|
r84 | if auto_rewrite: | ||
|
r719 | rw = self.outputcache.prompt1.auto_rewrite() + newcmd | ||
try: | ||||
# plain ascii works better w/ pyreadline, on some machines, so | ||||
# we use it and only print uncolored rewrite if we have unicode | ||||
rw = str(rw) | ||||
print >>Term.cout, rw | ||||
except UnicodeEncodeError: | ||||
print "-------------->" + newcmd | ||||
|
r0 | # log what is now valid Python, not the actual user input (without the | ||
# final newline) | ||||
|
r305 | self.log(line,newcmd,continue_prompt) | ||
|
r0 | return newcmd | ||
|
r657 | def handle_help(self, line_info): | ||
|
r0 | """Try to get some help for the object. | ||
obj? or ?obj -> basic information. | ||||
obj?? or ??obj -> more details. | ||||
""" | ||||
|
r657 | |||
line = line_info.line | ||||
|
r0 | # We need to make sure that we don't process lines which would be | ||
# otherwise valid python, such as "x=1 # what?" | ||||
try: | ||||
|
r51 | codeop.compile_command(line) | ||
|
r0 | except SyntaxError: | ||
# We should only handle as help stuff which is NOT valid syntax | ||||
if line[0]==self.ESC_HELP: | ||||
line = line[1:] | ||||
elif line[-1]==self.ESC_HELP: | ||||
line = line[:-1] | ||||
|
r657 | self.log(line,'#?'+line,line_info.continue_prompt) | ||
|
r0 | if line: | ||
|
r576 | #print 'line:<%r>' % line # dbg | ||
|
r0 | self.magic_pinfo(line) | ||
else: | ||||
page(self.usage,screen_lines=self.rc.screen_length) | ||||
return '' # Empty string is needed here! | ||||
except: | ||||
# Pass any other exceptions through to the normal handler | ||||
|
r657 | return self.handle_normal(line_info) | ||
|
r0 | else: | ||
# If the code compiles ok, we should handle it normally | ||||
|
r657 | return self.handle_normal(line_info) | ||
|
r0 | |||
|
r152 | def getapi(self): | ||
""" Get an IPApi object for this shell instance | ||||
Getting an IPApi object is always preferable to accessing the shell | ||||
directly, but this holds true especially for extensions. | ||||
It should always be possible to implement an extension with IPApi | ||||
alone. If not, contact maintainer to request an addition. | ||||
""" | ||||
return self.api | ||||
|
r657 | |||
def handle_emacs(self, line_info): | ||||
|
r0 | """Handle input lines marked by python-mode.""" | ||
# Currently, nothing is done. Later more functionality can be added | ||||
# here if needed. | ||||
# The input cache shouldn't be updated | ||||
|
r657 | return line_info.line | ||
|
r0 | |||
|
r82 | def mktempfile(self,data=None): | ||
"""Make a new tempfile and return its filename. | ||||
This makes a call to tempfile.mktemp, but it registers the created | ||||
filename internally so ipython cleans it up at exit time. | ||||
Optional inputs: | ||||
- data(None): if data is given, it gets written out to the temp file | ||||
immediately, and the file is closed again.""" | ||||
|
r93 | filename = tempfile.mktemp('.py','ipython_edit_') | ||
|
r82 | self.tempfiles.append(filename) | ||
if data: | ||||
tmp_file = open(filename,'w') | ||||
tmp_file.write(data) | ||||
tmp_file.close() | ||||
return filename | ||||
|
r0 | def write(self,data): | ||
"""Write a string to the default output""" | ||||
Term.cout.write(data) | ||||
def write_err(self,data): | ||||
"""Write a string to the default error output""" | ||||
Term.cerr.write(data) | ||||
|
r51 | def exit(self): | ||
"""Handle interactive exit. | ||||
This method sets the exit_now attribute.""" | ||||
if self.rc.confirm_exit: | ||||
|
r323 | if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'): | ||
|
r51 | self.exit_now = True | ||
else: | ||||
self.exit_now = True | ||||
|
r0 | def safe_execfile(self,fname,*where,**kw): | ||
|
r420 | """A safe version of the builtin execfile(). | ||
This version will never throw an exception, and knows how to handle | ||||
ipython logs as well.""" | ||||
def syspath_cleanup(): | ||||
"""Internal cleanup routine for sys.path.""" | ||||
if add_dname: | ||||
try: | ||||
sys.path.remove(dname) | ||||
except ValueError: | ||||
# For some reason the user has already removed it, ignore. | ||||
pass | ||||
|
r0 | fname = os.path.expanduser(fname) | ||
|
r420 | # Find things also in current directory. This is needed to mimic the | ||
# behavior of running a script from the system command line, where | ||||
# Python inserts the script's directory into sys.path | ||||
dname = os.path.dirname(os.path.abspath(fname)) | ||||
add_dname = False | ||||
if dname not in sys.path: | ||||
sys.path.insert(0,dname) | ||||
add_dname = True | ||||
|
r0 | try: | ||
xfile = open(fname) | ||||
except: | ||||
print >> Term.cerr, \ | ||||
'Could not open file <%s> for safe execution.' % fname | ||||
|
r420 | syspath_cleanup() | ||
|
r0 | return None | ||
kw.setdefault('islog',0) | ||||
kw.setdefault('quiet',1) | ||||
kw.setdefault('exit_ignore',0) | ||||
first = xfile.readline() | ||||
|
r60 | loghead = str(self.loghead_tpl).split('\n',1)[0].strip() | ||
|
r0 | xfile.close() | ||
# line by line execution | ||||
|
r60 | if first.startswith(loghead) or kw['islog']: | ||
|
r0 | print 'Loading log file <%s> one line at a time...' % fname | ||
if kw['quiet']: | ||||
stdout_save = sys.stdout | ||||
sys.stdout = StringIO.StringIO() | ||||
try: | ||||
globs,locs = where[0:2] | ||||
except: | ||||
try: | ||||
globs = locs = where[0] | ||||
except: | ||||
globs = locs = globals() | ||||
badblocks = [] | ||||
# we also need to identify indented blocks of code when replaying | ||||
# logs and put them together before passing them to an exec | ||||
# statement. This takes a bit of regexp and look-ahead work in the | ||||
# file. It's easiest if we swallow the whole thing in memory | ||||
# first, and manually walk through the lines list moving the | ||||
# counter ourselves. | ||||
indent_re = re.compile('\s+\S') | ||||
xfile = open(fname) | ||||
filelines = xfile.readlines() | ||||
xfile.close() | ||||
nlines = len(filelines) | ||||
lnum = 0 | ||||
while lnum < nlines: | ||||
line = filelines[lnum] | ||||
lnum += 1 | ||||
# don't re-insert logger status info into cache | ||||
if line.startswith('#log#'): | ||||
continue | ||||
else: | ||||
# build a block of code (maybe a single line) for execution | ||||
block = line | ||||
try: | ||||
next = filelines[lnum] # lnum has already incremented | ||||
except: | ||||
next = None | ||||
while next and indent_re.match(next): | ||||
block += next | ||||
lnum += 1 | ||||
try: | ||||
next = filelines[lnum] | ||||
except: | ||||
next = None | ||||
# now execute the block of one or more lines | ||||
try: | ||||
exec block in globs,locs | ||||
except SystemExit: | ||||
pass | ||||
except: | ||||
badblocks.append(block.rstrip()) | ||||
if kw['quiet']: # restore stdout | ||||
sys.stdout.close() | ||||
sys.stdout = stdout_save | ||||
print 'Finished replaying log file <%s>' % fname | ||||
if badblocks: | ||||
|
r51 | print >> sys.stderr, ('\nThe following lines/blocks in file ' | ||
'<%s> reported errors:' % fname) | ||||
|
r0 | for badline in badblocks: | ||
print >> sys.stderr, badline | ||||
else: # regular file execution | ||||
try: | ||||
|
r603 | if sys.platform == 'win32' and sys.version_info < (2,5,1): | ||
|
r582 | # Work around a bug in Python for Windows. The bug was | ||
# fixed in in Python 2.5 r54159 and 54158, but that's still | ||||
# SVN Python as of March/07. For details, see: | ||||
# http://projects.scipy.org/ipython/ipython/ticket/123 | ||||
|
r619 | try: | ||
globs,locs = where[0:2] | ||||
except: | ||||
try: | ||||
globs = locs = where[0] | ||||
except: | ||||
globs = locs = globals() | ||||
exec file(fname) in globs,locs | ||||
|
r582 | else: | ||
execfile(fname,*where) | ||||
|
r0 | except SyntaxError: | ||
|
r216 | self.showsyntaxerror() | ||
|
r0 | warn('Failure executing file: <%s>' % fname) | ||
except SystemExit,status: | ||||
|
r779 | # Code that correctly sets the exit status flag to success (0) | ||
# shouldn't be bothered with a traceback. Note that a plain | ||||
# sys.exit() does NOT set the message to 0 (it's empty) so that | ||||
# will still get a traceback. Note that the structure of the | ||||
# SystemExit exception changed between Python 2.4 and 2.5, so | ||||
# the checks must be done in a version-dependent way. | ||||
show = False | ||||
if sys.version_info[:2] > (2,5): | ||||
if status.message!=0 and not kw['exit_ignore']: | ||||
show = True | ||||
else: | ||||
if status.code and not kw['exit_ignore']: | ||||
show = True | ||||
if show: | ||||
|
r216 | self.showtraceback() | ||
|
r0 | warn('Failure executing file: <%s>' % fname) | ||
except: | ||||
|
r216 | self.showtraceback() | ||
|
r0 | warn('Failure executing file: <%s>' % fname) | ||
|
r420 | syspath_cleanup() | ||
|
r0 | #************************* end of file <iplib.py> ***************************** | ||