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