|
@@
-1,3489
+1,3489
|
|
1
|
# encoding: utf-8
|
|
1
|
# encoding: utf-8
|
|
2
|
"""Magic functions for InteractiveShell.
|
|
2
|
"""Magic functions for InteractiveShell.
|
|
3
|
"""
|
|
3
|
"""
|
|
4
|
|
|
4
|
|
|
5
|
#-----------------------------------------------------------------------------
|
|
5
|
#-----------------------------------------------------------------------------
|
|
6
|
# Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
|
|
6
|
# Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
|
|
7
|
# Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
|
|
7
|
# Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
|
|
8
|
# Copyright (C) 2008-2009 The IPython Development Team
|
|
8
|
# Copyright (C) 2008-2009 The IPython Development Team
|
|
9
|
|
|
9
|
|
|
10
|
# Distributed under the terms of the BSD License. The full license is in
|
|
10
|
# Distributed under the terms of the BSD License. The full license is in
|
|
11
|
# the file COPYING, distributed as part of this software.
|
|
11
|
# the file COPYING, distributed as part of this software.
|
|
12
|
#-----------------------------------------------------------------------------
|
|
12
|
#-----------------------------------------------------------------------------
|
|
13
|
|
|
13
|
|
|
14
|
#-----------------------------------------------------------------------------
|
|
14
|
#-----------------------------------------------------------------------------
|
|
15
|
# Imports
|
|
15
|
# Imports
|
|
16
|
#-----------------------------------------------------------------------------
|
|
16
|
#-----------------------------------------------------------------------------
|
|
17
|
|
|
17
|
|
|
18
|
import __builtin__
|
|
18
|
import __builtin__
|
|
19
|
import __future__
|
|
19
|
import __future__
|
|
20
|
import bdb
|
|
20
|
import bdb
|
|
21
|
import inspect
|
|
21
|
import inspect
|
|
22
|
import os
|
|
22
|
import os
|
|
23
|
import sys
|
|
23
|
import sys
|
|
24
|
import shutil
|
|
24
|
import shutil
|
|
25
|
import re
|
|
25
|
import re
|
|
26
|
import time
|
|
26
|
import time
|
|
27
|
import textwrap
|
|
27
|
import textwrap
|
|
28
|
import types
|
|
28
|
import types
|
|
29
|
from cStringIO import StringIO
|
|
29
|
from cStringIO import StringIO
|
|
30
|
from getopt import getopt,GetoptError
|
|
30
|
from getopt import getopt,GetoptError
|
|
31
|
from pprint import pformat
|
|
31
|
from pprint import pformat
|
|
32
|
|
|
32
|
|
|
33
|
# cProfile was added in Python2.5
|
|
33
|
# cProfile was added in Python2.5
|
|
34
|
try:
|
|
34
|
try:
|
|
35
|
import cProfile as profile
|
|
35
|
import cProfile as profile
|
|
36
|
import pstats
|
|
36
|
import pstats
|
|
37
|
except ImportError:
|
|
37
|
except ImportError:
|
|
38
|
# profile isn't bundled by default in Debian for license reasons
|
|
38
|
# profile isn't bundled by default in Debian for license reasons
|
|
39
|
try:
|
|
39
|
try:
|
|
40
|
import profile,pstats
|
|
40
|
import profile,pstats
|
|
41
|
except ImportError:
|
|
41
|
except ImportError:
|
|
42
|
profile = pstats = None
|
|
42
|
profile = pstats = None
|
|
43
|
|
|
43
|
|
|
44
|
import IPython
|
|
44
|
import IPython
|
|
45
|
from IPython.core import debugger, oinspect
|
|
45
|
from IPython.core import debugger, oinspect
|
|
46
|
from IPython.core.error import TryNext
|
|
46
|
from IPython.core.error import TryNext
|
|
47
|
from IPython.core.error import UsageError
|
|
47
|
from IPython.core.error import UsageError
|
|
48
|
from IPython.core.fakemodule import FakeModule
|
|
48
|
from IPython.core.fakemodule import FakeModule
|
|
49
|
from IPython.core.macro import Macro
|
|
49
|
from IPython.core.macro import Macro
|
|
50
|
from IPython.core import page
|
|
50
|
from IPython.core import page
|
|
51
|
from IPython.core.prefilter import ESC_MAGIC
|
|
51
|
from IPython.core.prefilter import ESC_MAGIC
|
|
52
|
from IPython.lib.pylabtools import mpl_runner
|
|
52
|
from IPython.lib.pylabtools import mpl_runner
|
|
53
|
from IPython.external.Itpl import itpl, printpl
|
|
53
|
from IPython.external.Itpl import itpl, printpl
|
|
54
|
from IPython.testing import decorators as testdec
|
|
54
|
from IPython.testing import decorators as testdec
|
|
55
|
from IPython.utils.io import file_read, nlprint
|
|
55
|
from IPython.utils.io import file_read, nlprint
|
|
56
|
import IPython.utils.io
|
|
56
|
import IPython.utils.io
|
|
57
|
from IPython.utils.path import get_py_filename
|
|
57
|
from IPython.utils.path import get_py_filename
|
|
58
|
from IPython.utils.process import arg_split, abbrev_cwd
|
|
58
|
from IPython.utils.process import arg_split, abbrev_cwd
|
|
59
|
from IPython.utils.terminal import set_term_title
|
|
59
|
from IPython.utils.terminal import set_term_title
|
|
60
|
from IPython.utils.text import LSString, SList, format_screen
|
|
60
|
from IPython.utils.text import LSString, SList, format_screen
|
|
61
|
from IPython.utils.timing import clock, clock2
|
|
61
|
from IPython.utils.timing import clock, clock2
|
|
62
|
from IPython.utils.warn import warn, error
|
|
62
|
from IPython.utils.warn import warn, error
|
|
63
|
from IPython.utils.ipstruct import Struct
|
|
63
|
from IPython.utils.ipstruct import Struct
|
|
64
|
import IPython.utils.generics
|
|
64
|
import IPython.utils.generics
|
|
65
|
|
|
65
|
|
|
66
|
#-----------------------------------------------------------------------------
|
|
66
|
#-----------------------------------------------------------------------------
|
|
67
|
# Utility functions
|
|
67
|
# Utility functions
|
|
68
|
#-----------------------------------------------------------------------------
|
|
68
|
#-----------------------------------------------------------------------------
|
|
69
|
|
|
69
|
|
|
70
|
def on_off(tag):
|
|
70
|
def on_off(tag):
|
|
71
|
"""Return an ON/OFF string for a 1/0 input. Simple utility function."""
|
|
71
|
"""Return an ON/OFF string for a 1/0 input. Simple utility function."""
|
|
72
|
return ['OFF','ON'][tag]
|
|
72
|
return ['OFF','ON'][tag]
|
|
73
|
|
|
73
|
|
|
74
|
class Bunch: pass
|
|
74
|
class Bunch: pass
|
|
75
|
|
|
75
|
|
|
76
|
def compress_dhist(dh):
|
|
76
|
def compress_dhist(dh):
|
|
77
|
head, tail = dh[:-10], dh[-10:]
|
|
77
|
head, tail = dh[:-10], dh[-10:]
|
|
78
|
|
|
78
|
|
|
79
|
newhead = []
|
|
79
|
newhead = []
|
|
80
|
done = set()
|
|
80
|
done = set()
|
|
81
|
for h in head:
|
|
81
|
for h in head:
|
|
82
|
if h in done:
|
|
82
|
if h in done:
|
|
83
|
continue
|
|
83
|
continue
|
|
84
|
newhead.append(h)
|
|
84
|
newhead.append(h)
|
|
85
|
done.add(h)
|
|
85
|
done.add(h)
|
|
86
|
|
|
86
|
|
|
87
|
return newhead + tail
|
|
87
|
return newhead + tail
|
|
88
|
|
|
88
|
|
|
89
|
|
|
89
|
|
|
90
|
#***************************************************************************
|
|
90
|
#***************************************************************************
|
|
91
|
# Main class implementing Magic functionality
|
|
91
|
# Main class implementing Magic functionality
|
|
92
|
|
|
92
|
|
|
93
|
# XXX - for some odd reason, if Magic is made a new-style class, we get errors
|
|
93
|
# XXX - for some odd reason, if Magic is made a new-style class, we get errors
|
|
94
|
# on construction of the main InteractiveShell object. Something odd is going
|
|
94
|
# on construction of the main InteractiveShell object. Something odd is going
|
|
95
|
# on with super() calls, Configurable and the MRO... For now leave it as-is, but
|
|
95
|
# on with super() calls, Configurable and the MRO... For now leave it as-is, but
|
|
96
|
# eventually this needs to be clarified.
|
|
96
|
# eventually this needs to be clarified.
|
|
97
|
# BG: This is because InteractiveShell inherits from this, but is itself a
|
|
97
|
# BG: This is because InteractiveShell inherits from this, but is itself a
|
|
98
|
# Configurable. This messes up the MRO in some way. The fix is that we need to
|
|
98
|
# Configurable. This messes up the MRO in some way. The fix is that we need to
|
|
99
|
# make Magic a configurable that InteractiveShell does not subclass.
|
|
99
|
# make Magic a configurable that InteractiveShell does not subclass.
|
|
100
|
|
|
100
|
|
|
101
|
class Magic:
|
|
101
|
class Magic:
|
|
102
|
"""Magic functions for InteractiveShell.
|
|
102
|
"""Magic functions for InteractiveShell.
|
|
103
|
|
|
103
|
|
|
104
|
Shell functions which can be reached as %function_name. All magic
|
|
104
|
Shell functions which can be reached as %function_name. All magic
|
|
105
|
functions should accept a string, which they can parse for their own
|
|
105
|
functions should accept a string, which they can parse for their own
|
|
106
|
needs. This can make some functions easier to type, eg `%cd ../`
|
|
106
|
needs. This can make some functions easier to type, eg `%cd ../`
|
|
107
|
vs. `%cd("../")`
|
|
107
|
vs. `%cd("../")`
|
|
108
|
|
|
108
|
|
|
109
|
ALL definitions MUST begin with the prefix magic_. The user won't need it
|
|
109
|
ALL definitions MUST begin with the prefix magic_. The user won't need it
|
|
110
|
at the command line, but it is is needed in the definition. """
|
|
110
|
at the command line, but it is is needed in the definition. """
|
|
111
|
|
|
111
|
|
|
112
|
# class globals
|
|
112
|
# class globals
|
|
113
|
auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
|
|
113
|
auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
|
|
114
|
'Automagic is ON, % prefix NOT needed for magic functions.']
|
|
114
|
'Automagic is ON, % prefix NOT needed for magic functions.']
|
|
115
|
|
|
115
|
|
|
116
|
#......................................................................
|
|
116
|
#......................................................................
|
|
117
|
# some utility functions
|
|
117
|
# some utility functions
|
|
118
|
|
|
118
|
|
|
119
|
def __init__(self,shell):
|
|
119
|
def __init__(self,shell):
|
|
120
|
|
|
120
|
|
|
121
|
self.options_table = {}
|
|
121
|
self.options_table = {}
|
|
122
|
if profile is None:
|
|
122
|
if profile is None:
|
|
123
|
self.magic_prun = self.profile_missing_notice
|
|
123
|
self.magic_prun = self.profile_missing_notice
|
|
124
|
self.shell = shell
|
|
124
|
self.shell = shell
|
|
125
|
|
|
125
|
|
|
126
|
# namespace for holding state we may need
|
|
126
|
# namespace for holding state we may need
|
|
127
|
self._magic_state = Bunch()
|
|
127
|
self._magic_state = Bunch()
|
|
128
|
|
|
128
|
|
|
129
|
def profile_missing_notice(self, *args, **kwargs):
|
|
129
|
def profile_missing_notice(self, *args, **kwargs):
|
|
130
|
error("""\
|
|
130
|
error("""\
|
|
131
|
The profile module could not be found. It has been removed from the standard
|
|
131
|
The profile module could not be found. It has been removed from the standard
|
|
132
|
python packages because of its non-free license. To use profiling, install the
|
|
132
|
python packages because of its non-free license. To use profiling, install the
|
|
133
|
python-profiler package from non-free.""")
|
|
133
|
python-profiler package from non-free.""")
|
|
134
|
|
|
134
|
|
|
135
|
def default_option(self,fn,optstr):
|
|
135
|
def default_option(self,fn,optstr):
|
|
136
|
"""Make an entry in the options_table for fn, with value optstr"""
|
|
136
|
"""Make an entry in the options_table for fn, with value optstr"""
|
|
137
|
|
|
137
|
|
|
138
|
if fn not in self.lsmagic():
|
|
138
|
if fn not in self.lsmagic():
|
|
139
|
error("%s is not a magic function" % fn)
|
|
139
|
error("%s is not a magic function" % fn)
|
|
140
|
self.options_table[fn] = optstr
|
|
140
|
self.options_table[fn] = optstr
|
|
141
|
|
|
141
|
|
|
142
|
def lsmagic(self):
|
|
142
|
def lsmagic(self):
|
|
143
|
"""Return a list of currently available magic functions.
|
|
143
|
"""Return a list of currently available magic functions.
|
|
144
|
|
|
144
|
|
|
145
|
Gives a list of the bare names after mangling (['ls','cd', ...], not
|
|
145
|
Gives a list of the bare names after mangling (['ls','cd', ...], not
|
|
146
|
['magic_ls','magic_cd',...]"""
|
|
146
|
['magic_ls','magic_cd',...]"""
|
|
147
|
|
|
147
|
|
|
148
|
# FIXME. This needs a cleanup, in the way the magics list is built.
|
|
148
|
# FIXME. This needs a cleanup, in the way the magics list is built.
|
|
149
|
|
|
149
|
|
|
150
|
# magics in class definition
|
|
150
|
# magics in class definition
|
|
151
|
class_magic = lambda fn: fn.startswith('magic_') and \
|
|
151
|
class_magic = lambda fn: fn.startswith('magic_') and \
|
|
152
|
callable(Magic.__dict__[fn])
|
|
152
|
callable(Magic.__dict__[fn])
|
|
153
|
# in instance namespace (run-time user additions)
|
|
153
|
# in instance namespace (run-time user additions)
|
|
154
|
inst_magic = lambda fn: fn.startswith('magic_') and \
|
|
154
|
inst_magic = lambda fn: fn.startswith('magic_') and \
|
|
155
|
callable(self.__dict__[fn])
|
|
155
|
callable(self.__dict__[fn])
|
|
156
|
# and bound magics by user (so they can access self):
|
|
156
|
# and bound magics by user (so they can access self):
|
|
157
|
inst_bound_magic = lambda fn: fn.startswith('magic_') and \
|
|
157
|
inst_bound_magic = lambda fn: fn.startswith('magic_') and \
|
|
158
|
callable(self.__class__.__dict__[fn])
|
|
158
|
callable(self.__class__.__dict__[fn])
|
|
159
|
magics = filter(class_magic,Magic.__dict__.keys()) + \
|
|
159
|
magics = filter(class_magic,Magic.__dict__.keys()) + \
|
|
160
|
filter(inst_magic,self.__dict__.keys()) + \
|
|
160
|
filter(inst_magic,self.__dict__.keys()) + \
|
|
161
|
filter(inst_bound_magic,self.__class__.__dict__.keys())
|
|
161
|
filter(inst_bound_magic,self.__class__.__dict__.keys())
|
|
162
|
out = []
|
|
162
|
out = []
|
|
163
|
for fn in set(magics):
|
|
163
|
for fn in set(magics):
|
|
164
|
out.append(fn.replace('magic_','',1))
|
|
164
|
out.append(fn.replace('magic_','',1))
|
|
165
|
out.sort()
|
|
165
|
out.sort()
|
|
166
|
return out
|
|
166
|
return out
|
|
167
|
|
|
167
|
|
|
168
|
def extract_input_lines(self, range_str, raw=False):
|
|
168
|
def extract_input_lines(self, range_str, raw=False):
|
|
169
|
"""Return as a string a set of input history slices.
|
|
169
|
"""Return as a string a set of input history slices.
|
|
170
|
|
|
170
|
|
|
171
|
Inputs:
|
|
171
|
Inputs:
|
|
172
|
|
|
172
|
|
|
173
|
- range_str: the set of slices is given as a string, like
|
|
173
|
- range_str: the set of slices is given as a string, like
|
|
174
|
"~5#6-~4#2 4:8 9", since this function is for use by magic functions
|
|
174
|
"~5#6-~4#2 4:8 9", since this function is for use by magic functions
|
|
175
|
which get their arguments as strings. The number before the # is the
|
|
175
|
which get their arguments as strings. The number before the # is the
|
|
176
|
session number: ~n goes n back from the current session.
|
|
176
|
session number: ~n goes n back from the current session.
|
|
177
|
|
|
177
|
|
|
178
|
Optional inputs:
|
|
178
|
Optional inputs:
|
|
179
|
|
|
179
|
|
|
180
|
- raw(False): by default, the processed input is used. If this is
|
|
180
|
- raw(False): by default, the processed input is used. If this is
|
|
181
|
true, the raw input history is used instead.
|
|
181
|
true, the raw input history is used instead.
|
|
182
|
|
|
182
|
|
|
183
|
Note that slices can be called with two notations:
|
|
183
|
Note that slices can be called with two notations:
|
|
184
|
|
|
184
|
|
|
185
|
N:M -> standard python form, means including items N...(M-1).
|
|
185
|
N:M -> standard python form, means including items N...(M-1).
|
|
186
|
|
|
186
|
|
|
187
|
N-M -> include items N..M (closed endpoint)."""
|
|
187
|
N-M -> include items N..M (closed endpoint)."""
|
|
188
|
lines = self.shell.history_manager.\
|
|
188
|
lines = self.shell.history_manager.\
|
|
189
|
get_hist_from_rangestr(range_str, raw=raw)
|
|
189
|
get_hist_from_rangestr(range_str, raw=raw)
|
|
190
|
return "\n".join(x for _, _, x in lines)
|
|
190
|
return "\n".join(x for _, _, x in lines)
|
|
191
|
|
|
191
|
|
|
192
|
def arg_err(self,func):
|
|
192
|
def arg_err(self,func):
|
|
193
|
"""Print docstring if incorrect arguments were passed"""
|
|
193
|
"""Print docstring if incorrect arguments were passed"""
|
|
194
|
print 'Error in arguments:'
|
|
194
|
print 'Error in arguments:'
|
|
195
|
print oinspect.getdoc(func)
|
|
195
|
print oinspect.getdoc(func)
|
|
196
|
|
|
196
|
|
|
197
|
def format_latex(self,strng):
|
|
197
|
def format_latex(self,strng):
|
|
198
|
"""Format a string for latex inclusion."""
|
|
198
|
"""Format a string for latex inclusion."""
|
|
199
|
|
|
199
|
|
|
200
|
# Characters that need to be escaped for latex:
|
|
200
|
# Characters that need to be escaped for latex:
|
|
201
|
escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
|
|
201
|
escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
|
|
202
|
# Magic command names as headers:
|
|
202
|
# Magic command names as headers:
|
|
203
|
cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
|
|
203
|
cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
|
|
204
|
re.MULTILINE)
|
|
204
|
re.MULTILINE)
|
|
205
|
# Magic commands
|
|
205
|
# Magic commands
|
|
206
|
cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
|
|
206
|
cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
|
|
207
|
re.MULTILINE)
|
|
207
|
re.MULTILINE)
|
|
208
|
# Paragraph continue
|
|
208
|
# Paragraph continue
|
|
209
|
par_re = re.compile(r'\\$',re.MULTILINE)
|
|
209
|
par_re = re.compile(r'\\$',re.MULTILINE)
|
|
210
|
|
|
210
|
|
|
211
|
# The "\n" symbol
|
|
211
|
# The "\n" symbol
|
|
212
|
newline_re = re.compile(r'\\n')
|
|
212
|
newline_re = re.compile(r'\\n')
|
|
213
|
|
|
213
|
|
|
214
|
# Now build the string for output:
|
|
214
|
# Now build the string for output:
|
|
215
|
#strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
|
|
215
|
#strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
|
|
216
|
strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
|
|
216
|
strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
|
|
217
|
strng)
|
|
217
|
strng)
|
|
218
|
strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
|
|
218
|
strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
|
|
219
|
strng = par_re.sub(r'\\\\',strng)
|
|
219
|
strng = par_re.sub(r'\\\\',strng)
|
|
220
|
strng = escape_re.sub(r'\\\1',strng)
|
|
220
|
strng = escape_re.sub(r'\\\1',strng)
|
|
221
|
strng = newline_re.sub(r'\\textbackslash{}n',strng)
|
|
221
|
strng = newline_re.sub(r'\\textbackslash{}n',strng)
|
|
222
|
return strng
|
|
222
|
return strng
|
|
223
|
|
|
223
|
|
|
224
|
def parse_options(self,arg_str,opt_str,*long_opts,**kw):
|
|
224
|
def parse_options(self,arg_str,opt_str,*long_opts,**kw):
|
|
225
|
"""Parse options passed to an argument string.
|
|
225
|
"""Parse options passed to an argument string.
|
|
226
|
|
|
226
|
|
|
227
|
The interface is similar to that of getopt(), but it returns back a
|
|
227
|
The interface is similar to that of getopt(), but it returns back a
|
|
228
|
Struct with the options as keys and the stripped argument string still
|
|
228
|
Struct with the options as keys and the stripped argument string still
|
|
229
|
as a string.
|
|
229
|
as a string.
|
|
230
|
|
|
230
|
|
|
231
|
arg_str is quoted as a true sys.argv vector by using shlex.split.
|
|
231
|
arg_str is quoted as a true sys.argv vector by using shlex.split.
|
|
232
|
This allows us to easily expand variables, glob files, quote
|
|
232
|
This allows us to easily expand variables, glob files, quote
|
|
233
|
arguments, etc.
|
|
233
|
arguments, etc.
|
|
234
|
|
|
234
|
|
|
235
|
Options:
|
|
235
|
Options:
|
|
236
|
-mode: default 'string'. If given as 'list', the argument string is
|
|
236
|
-mode: default 'string'. If given as 'list', the argument string is
|
|
237
|
returned as a list (split on whitespace) instead of a string.
|
|
237
|
returned as a list (split on whitespace) instead of a string.
|
|
238
|
|
|
238
|
|
|
239
|
-list_all: put all option values in lists. Normally only options
|
|
239
|
-list_all: put all option values in lists. Normally only options
|
|
240
|
appearing more than once are put in a list.
|
|
240
|
appearing more than once are put in a list.
|
|
241
|
|
|
241
|
|
|
242
|
-posix (True): whether to split the input line in POSIX mode or not,
|
|
242
|
-posix (True): whether to split the input line in POSIX mode or not,
|
|
243
|
as per the conventions outlined in the shlex module from the
|
|
243
|
as per the conventions outlined in the shlex module from the
|
|
244
|
standard library."""
|
|
244
|
standard library."""
|
|
245
|
|
|
245
|
|
|
246
|
# inject default options at the beginning of the input line
|
|
246
|
# inject default options at the beginning of the input line
|
|
247
|
caller = sys._getframe(1).f_code.co_name.replace('magic_','')
|
|
247
|
caller = sys._getframe(1).f_code.co_name.replace('magic_','')
|
|
248
|
arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
|
|
248
|
arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
|
|
249
|
|
|
249
|
|
|
250
|
mode = kw.get('mode','string')
|
|
250
|
mode = kw.get('mode','string')
|
|
251
|
if mode not in ['string','list']:
|
|
251
|
if mode not in ['string','list']:
|
|
252
|
raise ValueError,'incorrect mode given: %s' % mode
|
|
252
|
raise ValueError,'incorrect mode given: %s' % mode
|
|
253
|
# Get options
|
|
253
|
# Get options
|
|
254
|
list_all = kw.get('list_all',0)
|
|
254
|
list_all = kw.get('list_all',0)
|
|
255
|
posix = kw.get('posix', os.name == 'posix')
|
|
255
|
posix = kw.get('posix', os.name == 'posix')
|
|
256
|
|
|
256
|
|
|
257
|
# Check if we have more than one argument to warrant extra processing:
|
|
257
|
# Check if we have more than one argument to warrant extra processing:
|
|
258
|
odict = {} # Dictionary with options
|
|
258
|
odict = {} # Dictionary with options
|
|
259
|
args = arg_str.split()
|
|
259
|
args = arg_str.split()
|
|
260
|
if len(args) >= 1:
|
|
260
|
if len(args) >= 1:
|
|
261
|
# If the list of inputs only has 0 or 1 thing in it, there's no
|
|
261
|
# If the list of inputs only has 0 or 1 thing in it, there's no
|
|
262
|
# need to look for options
|
|
262
|
# need to look for options
|
|
263
|
argv = arg_split(arg_str,posix)
|
|
263
|
argv = arg_split(arg_str,posix)
|
|
264
|
# Do regular option processing
|
|
264
|
# Do regular option processing
|
|
265
|
try:
|
|
265
|
try:
|
|
266
|
opts,args = getopt(argv,opt_str,*long_opts)
|
|
266
|
opts,args = getopt(argv,opt_str,*long_opts)
|
|
267
|
except GetoptError,e:
|
|
267
|
except GetoptError,e:
|
|
268
|
raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
|
|
268
|
raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
|
|
269
|
" ".join(long_opts)))
|
|
269
|
" ".join(long_opts)))
|
|
270
|
for o,a in opts:
|
|
270
|
for o,a in opts:
|
|
271
|
if o.startswith('--'):
|
|
271
|
if o.startswith('--'):
|
|
272
|
o = o[2:]
|
|
272
|
o = o[2:]
|
|
273
|
else:
|
|
273
|
else:
|
|
274
|
o = o[1:]
|
|
274
|
o = o[1:]
|
|
275
|
try:
|
|
275
|
try:
|
|
276
|
odict[o].append(a)
|
|
276
|
odict[o].append(a)
|
|
277
|
except AttributeError:
|
|
277
|
except AttributeError:
|
|
278
|
odict[o] = [odict[o],a]
|
|
278
|
odict[o] = [odict[o],a]
|
|
279
|
except KeyError:
|
|
279
|
except KeyError:
|
|
280
|
if list_all:
|
|
280
|
if list_all:
|
|
281
|
odict[o] = [a]
|
|
281
|
odict[o] = [a]
|
|
282
|
else:
|
|
282
|
else:
|
|
283
|
odict[o] = a
|
|
283
|
odict[o] = a
|
|
284
|
|
|
284
|
|
|
285
|
# Prepare opts,args for return
|
|
285
|
# Prepare opts,args for return
|
|
286
|
opts = Struct(odict)
|
|
286
|
opts = Struct(odict)
|
|
287
|
if mode == 'string':
|
|
287
|
if mode == 'string':
|
|
288
|
args = ' '.join(args)
|
|
288
|
args = ' '.join(args)
|
|
289
|
|
|
289
|
|
|
290
|
return opts,args
|
|
290
|
return opts,args
|
|
291
|
|
|
291
|
|
|
292
|
#......................................................................
|
|
292
|
#......................................................................
|
|
293
|
# And now the actual magic functions
|
|
293
|
# And now the actual magic functions
|
|
294
|
|
|
294
|
|
|
295
|
# Functions for IPython shell work (vars,funcs, config, etc)
|
|
295
|
# Functions for IPython shell work (vars,funcs, config, etc)
|
|
296
|
def magic_lsmagic(self, parameter_s = ''):
|
|
296
|
def magic_lsmagic(self, parameter_s = ''):
|
|
297
|
"""List currently available magic functions."""
|
|
297
|
"""List currently available magic functions."""
|
|
298
|
mesc = ESC_MAGIC
|
|
298
|
mesc = ESC_MAGIC
|
|
299
|
print 'Available magic functions:\n'+mesc+\
|
|
299
|
print 'Available magic functions:\n'+mesc+\
|
|
300
|
(' '+mesc).join(self.lsmagic())
|
|
300
|
(' '+mesc).join(self.lsmagic())
|
|
301
|
print '\n' + Magic.auto_status[self.shell.automagic]
|
|
301
|
print '\n' + Magic.auto_status[self.shell.automagic]
|
|
302
|
return None
|
|
302
|
return None
|
|
303
|
|
|
303
|
|
|
304
|
def magic_magic(self, parameter_s = ''):
|
|
304
|
def magic_magic(self, parameter_s = ''):
|
|
305
|
"""Print information about the magic function system.
|
|
305
|
"""Print information about the magic function system.
|
|
306
|
|
|
306
|
|
|
307
|
Supported formats: -latex, -brief, -rest
|
|
307
|
Supported formats: -latex, -brief, -rest
|
|
308
|
"""
|
|
308
|
"""
|
|
309
|
|
|
309
|
|
|
310
|
mode = ''
|
|
310
|
mode = ''
|
|
311
|
try:
|
|
311
|
try:
|
|
312
|
if parameter_s.split()[0] == '-latex':
|
|
312
|
if parameter_s.split()[0] == '-latex':
|
|
313
|
mode = 'latex'
|
|
313
|
mode = 'latex'
|
|
314
|
if parameter_s.split()[0] == '-brief':
|
|
314
|
if parameter_s.split()[0] == '-brief':
|
|
315
|
mode = 'brief'
|
|
315
|
mode = 'brief'
|
|
316
|
if parameter_s.split()[0] == '-rest':
|
|
316
|
if parameter_s.split()[0] == '-rest':
|
|
317
|
mode = 'rest'
|
|
317
|
mode = 'rest'
|
|
318
|
rest_docs = []
|
|
318
|
rest_docs = []
|
|
319
|
except:
|
|
319
|
except:
|
|
320
|
pass
|
|
320
|
pass
|
|
321
|
|
|
321
|
|
|
322
|
magic_docs = []
|
|
322
|
magic_docs = []
|
|
323
|
for fname in self.lsmagic():
|
|
323
|
for fname in self.lsmagic():
|
|
324
|
mname = 'magic_' + fname
|
|
324
|
mname = 'magic_' + fname
|
|
325
|
for space in (Magic,self,self.__class__):
|
|
325
|
for space in (Magic,self,self.__class__):
|
|
326
|
try:
|
|
326
|
try:
|
|
327
|
fn = space.__dict__[mname]
|
|
327
|
fn = space.__dict__[mname]
|
|
328
|
except KeyError:
|
|
328
|
except KeyError:
|
|
329
|
pass
|
|
329
|
pass
|
|
330
|
else:
|
|
330
|
else:
|
|
331
|
break
|
|
331
|
break
|
|
332
|
if mode == 'brief':
|
|
332
|
if mode == 'brief':
|
|
333
|
# only first line
|
|
333
|
# only first line
|
|
334
|
if fn.__doc__:
|
|
334
|
if fn.__doc__:
|
|
335
|
fndoc = fn.__doc__.split('\n',1)[0]
|
|
335
|
fndoc = fn.__doc__.split('\n',1)[0]
|
|
336
|
else:
|
|
336
|
else:
|
|
337
|
fndoc = 'No documentation'
|
|
337
|
fndoc = 'No documentation'
|
|
338
|
else:
|
|
338
|
else:
|
|
339
|
if fn.__doc__:
|
|
339
|
if fn.__doc__:
|
|
340
|
fndoc = fn.__doc__.rstrip()
|
|
340
|
fndoc = fn.__doc__.rstrip()
|
|
341
|
else:
|
|
341
|
else:
|
|
342
|
fndoc = 'No documentation'
|
|
342
|
fndoc = 'No documentation'
|
|
343
|
|
|
343
|
|
|
344
|
|
|
344
|
|
|
345
|
if mode == 'rest':
|
|
345
|
if mode == 'rest':
|
|
346
|
rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,
|
|
346
|
rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,
|
|
347
|
fname,fndoc))
|
|
347
|
fname,fndoc))
|
|
348
|
|
|
348
|
|
|
349
|
else:
|
|
349
|
else:
|
|
350
|
magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,
|
|
350
|
magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,
|
|
351
|
fname,fndoc))
|
|
351
|
fname,fndoc))
|
|
352
|
|
|
352
|
|
|
353
|
magic_docs = ''.join(magic_docs)
|
|
353
|
magic_docs = ''.join(magic_docs)
|
|
354
|
|
|
354
|
|
|
355
|
if mode == 'rest':
|
|
355
|
if mode == 'rest':
|
|
356
|
return "".join(rest_docs)
|
|
356
|
return "".join(rest_docs)
|
|
357
|
|
|
357
|
|
|
358
|
if mode == 'latex':
|
|
358
|
if mode == 'latex':
|
|
359
|
print self.format_latex(magic_docs)
|
|
359
|
print self.format_latex(magic_docs)
|
|
360
|
return
|
|
360
|
return
|
|
361
|
else:
|
|
361
|
else:
|
|
362
|
magic_docs = format_screen(magic_docs)
|
|
362
|
magic_docs = format_screen(magic_docs)
|
|
363
|
if mode == 'brief':
|
|
363
|
if mode == 'brief':
|
|
364
|
return magic_docs
|
|
364
|
return magic_docs
|
|
365
|
|
|
365
|
|
|
366
|
outmsg = """
|
|
366
|
outmsg = """
|
|
367
|
IPython's 'magic' functions
|
|
367
|
IPython's 'magic' functions
|
|
368
|
===========================
|
|
368
|
===========================
|
|
369
|
|
|
369
|
|
|
370
|
The magic function system provides a series of functions which allow you to
|
|
370
|
The magic function system provides a series of functions which allow you to
|
|
371
|
control the behavior of IPython itself, plus a lot of system-type
|
|
371
|
control the behavior of IPython itself, plus a lot of system-type
|
|
372
|
features. All these functions are prefixed with a % character, but parameters
|
|
372
|
features. All these functions are prefixed with a % character, but parameters
|
|
373
|
are given without parentheses or quotes.
|
|
373
|
are given without parentheses or quotes.
|
|
374
|
|
|
374
|
|
|
375
|
NOTE: If you have 'automagic' enabled (via the command line option or with the
|
|
375
|
NOTE: If you have 'automagic' enabled (via the command line option or with the
|
|
376
|
%automagic function), you don't need to type in the % explicitly. By default,
|
|
376
|
%automagic function), you don't need to type in the % explicitly. By default,
|
|
377
|
IPython ships with automagic on, so you should only rarely need the % escape.
|
|
377
|
IPython ships with automagic on, so you should only rarely need the % escape.
|
|
378
|
|
|
378
|
|
|
379
|
Example: typing '%cd mydir' (without the quotes) changes you working directory
|
|
379
|
Example: typing '%cd mydir' (without the quotes) changes you working directory
|
|
380
|
to 'mydir', if it exists.
|
|
380
|
to 'mydir', if it exists.
|
|
381
|
|
|
381
|
|
|
382
|
You can define your own magic functions to extend the system. See the supplied
|
|
382
|
You can define your own magic functions to extend the system. See the supplied
|
|
383
|
ipythonrc and example-magic.py files for details (in your ipython
|
|
383
|
ipythonrc and example-magic.py files for details (in your ipython
|
|
384
|
configuration directory, typically $HOME/.config/ipython on Linux or $HOME/.ipython elsewhere).
|
|
384
|
configuration directory, typically $HOME/.config/ipython on Linux or $HOME/.ipython elsewhere).
|
|
385
|
|
|
385
|
|
|
386
|
You can also define your own aliased names for magic functions. In your
|
|
386
|
You can also define your own aliased names for magic functions. In your
|
|
387
|
ipythonrc file, placing a line like:
|
|
387
|
ipythonrc file, placing a line like:
|
|
388
|
|
|
388
|
|
|
389
|
execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
|
|
389
|
execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
|
|
390
|
|
|
390
|
|
|
391
|
will define %pf as a new name for %profile.
|
|
391
|
will define %pf as a new name for %profile.
|
|
392
|
|
|
392
|
|
|
393
|
You can also call magics in code using the magic() function, which IPython
|
|
393
|
You can also call magics in code using the magic() function, which IPython
|
|
394
|
automatically adds to the builtin namespace. Type 'magic?' for details.
|
|
394
|
automatically adds to the builtin namespace. Type 'magic?' for details.
|
|
395
|
|
|
395
|
|
|
396
|
For a list of the available magic functions, use %lsmagic. For a description
|
|
396
|
For a list of the available magic functions, use %lsmagic. For a description
|
|
397
|
of any of them, type %magic_name?, e.g. '%cd?'.
|
|
397
|
of any of them, type %magic_name?, e.g. '%cd?'.
|
|
398
|
|
|
398
|
|
|
399
|
Currently the magic system has the following functions:\n"""
|
|
399
|
Currently the magic system has the following functions:\n"""
|
|
400
|
|
|
400
|
|
|
401
|
mesc = ESC_MAGIC
|
|
401
|
mesc = ESC_MAGIC
|
|
402
|
outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
|
|
402
|
outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
|
|
403
|
"\n\n%s%s\n\n%s" % (outmsg,
|
|
403
|
"\n\n%s%s\n\n%s" % (outmsg,
|
|
404
|
magic_docs,mesc,mesc,
|
|
404
|
magic_docs,mesc,mesc,
|
|
405
|
(' '+mesc).join(self.lsmagic()),
|
|
405
|
(' '+mesc).join(self.lsmagic()),
|
|
406
|
Magic.auto_status[self.shell.automagic] ) )
|
|
406
|
Magic.auto_status[self.shell.automagic] ) )
|
|
407
|
page.page(outmsg)
|
|
407
|
page.page(outmsg)
|
|
408
|
|
|
408
|
|
|
409
|
def magic_automagic(self, parameter_s = ''):
|
|
409
|
def magic_automagic(self, parameter_s = ''):
|
|
410
|
"""Make magic functions callable without having to type the initial %.
|
|
410
|
"""Make magic functions callable without having to type the initial %.
|
|
411
|
|
|
411
|
|
|
412
|
Without argumentsl toggles on/off (when off, you must call it as
|
|
412
|
Without argumentsl toggles on/off (when off, you must call it as
|
|
413
|
%automagic, of course). With arguments it sets the value, and you can
|
|
413
|
%automagic, of course). With arguments it sets the value, and you can
|
|
414
|
use any of (case insensitive):
|
|
414
|
use any of (case insensitive):
|
|
415
|
|
|
415
|
|
|
416
|
- on,1,True: to activate
|
|
416
|
- on,1,True: to activate
|
|
417
|
|
|
417
|
|
|
418
|
- off,0,False: to deactivate.
|
|
418
|
- off,0,False: to deactivate.
|
|
419
|
|
|
419
|
|
|
420
|
Note that magic functions have lowest priority, so if there's a
|
|
420
|
Note that magic functions have lowest priority, so if there's a
|
|
421
|
variable whose name collides with that of a magic fn, automagic won't
|
|
421
|
variable whose name collides with that of a magic fn, automagic won't
|
|
422
|
work for that function (you get the variable instead). However, if you
|
|
422
|
work for that function (you get the variable instead). However, if you
|
|
423
|
delete the variable (del var), the previously shadowed magic function
|
|
423
|
delete the variable (del var), the previously shadowed magic function
|
|
424
|
becomes visible to automagic again."""
|
|
424
|
becomes visible to automagic again."""
|
|
425
|
|
|
425
|
|
|
426
|
arg = parameter_s.lower()
|
|
426
|
arg = parameter_s.lower()
|
|
427
|
if parameter_s in ('on','1','true'):
|
|
427
|
if parameter_s in ('on','1','true'):
|
|
428
|
self.shell.automagic = True
|
|
428
|
self.shell.automagic = True
|
|
429
|
elif parameter_s in ('off','0','false'):
|
|
429
|
elif parameter_s in ('off','0','false'):
|
|
430
|
self.shell.automagic = False
|
|
430
|
self.shell.automagic = False
|
|
431
|
else:
|
|
431
|
else:
|
|
432
|
self.shell.automagic = not self.shell.automagic
|
|
432
|
self.shell.automagic = not self.shell.automagic
|
|
433
|
print '\n' + Magic.auto_status[self.shell.automagic]
|
|
433
|
print '\n' + Magic.auto_status[self.shell.automagic]
|
|
434
|
|
|
434
|
|
|
435
|
@testdec.skip_doctest
|
|
435
|
@testdec.skip_doctest
|
|
436
|
def magic_autocall(self, parameter_s = ''):
|
|
436
|
def magic_autocall(self, parameter_s = ''):
|
|
437
|
"""Make functions callable without having to type parentheses.
|
|
437
|
"""Make functions callable without having to type parentheses.
|
|
438
|
|
|
438
|
|
|
439
|
Usage:
|
|
439
|
Usage:
|
|
440
|
|
|
440
|
|
|
441
|
%autocall [mode]
|
|
441
|
%autocall [mode]
|
|
442
|
|
|
442
|
|
|
443
|
The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
|
|
443
|
The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
|
|
444
|
value is toggled on and off (remembering the previous state).
|
|
444
|
value is toggled on and off (remembering the previous state).
|
|
445
|
|
|
445
|
|
|
446
|
In more detail, these values mean:
|
|
446
|
In more detail, these values mean:
|
|
447
|
|
|
447
|
|
|
448
|
0 -> fully disabled
|
|
448
|
0 -> fully disabled
|
|
449
|
|
|
449
|
|
|
450
|
1 -> active, but do not apply if there are no arguments on the line.
|
|
450
|
1 -> active, but do not apply if there are no arguments on the line.
|
|
451
|
|
|
451
|
|
|
452
|
In this mode, you get:
|
|
452
|
In this mode, you get:
|
|
453
|
|
|
453
|
|
|
454
|
In [1]: callable
|
|
454
|
In [1]: callable
|
|
455
|
Out[1]: <built-in function callable>
|
|
455
|
Out[1]: <built-in function callable>
|
|
456
|
|
|
456
|
|
|
457
|
In [2]: callable 'hello'
|
|
457
|
In [2]: callable 'hello'
|
|
458
|
------> callable('hello')
|
|
458
|
------> callable('hello')
|
|
459
|
Out[2]: False
|
|
459
|
Out[2]: False
|
|
460
|
|
|
460
|
|
|
461
|
2 -> Active always. Even if no arguments are present, the callable
|
|
461
|
2 -> Active always. Even if no arguments are present, the callable
|
|
462
|
object is called:
|
|
462
|
object is called:
|
|
463
|
|
|
463
|
|
|
464
|
In [2]: float
|
|
464
|
In [2]: float
|
|
465
|
------> float()
|
|
465
|
------> float()
|
|
466
|
Out[2]: 0.0
|
|
466
|
Out[2]: 0.0
|
|
467
|
|
|
467
|
|
|
468
|
Note that even with autocall off, you can still use '/' at the start of
|
|
468
|
Note that even with autocall off, you can still use '/' at the start of
|
|
469
|
a line to treat the first argument on the command line as a function
|
|
469
|
a line to treat the first argument on the command line as a function
|
|
470
|
and add parentheses to it:
|
|
470
|
and add parentheses to it:
|
|
471
|
|
|
471
|
|
|
472
|
In [8]: /str 43
|
|
472
|
In [8]: /str 43
|
|
473
|
------> str(43)
|
|
473
|
------> str(43)
|
|
474
|
Out[8]: '43'
|
|
474
|
Out[8]: '43'
|
|
475
|
|
|
475
|
|
|
476
|
# all-random (note for auto-testing)
|
|
476
|
# all-random (note for auto-testing)
|
|
477
|
"""
|
|
477
|
"""
|
|
478
|
|
|
478
|
|
|
479
|
if parameter_s:
|
|
479
|
if parameter_s:
|
|
480
|
arg = int(parameter_s)
|
|
480
|
arg = int(parameter_s)
|
|
481
|
else:
|
|
481
|
else:
|
|
482
|
arg = 'toggle'
|
|
482
|
arg = 'toggle'
|
|
483
|
|
|
483
|
|
|
484
|
if not arg in (0,1,2,'toggle'):
|
|
484
|
if not arg in (0,1,2,'toggle'):
|
|
485
|
error('Valid modes: (0->Off, 1->Smart, 2->Full')
|
|
485
|
error('Valid modes: (0->Off, 1->Smart, 2->Full')
|
|
486
|
return
|
|
486
|
return
|
|
487
|
|
|
487
|
|
|
488
|
if arg in (0,1,2):
|
|
488
|
if arg in (0,1,2):
|
|
489
|
self.shell.autocall = arg
|
|
489
|
self.shell.autocall = arg
|
|
490
|
else: # toggle
|
|
490
|
else: # toggle
|
|
491
|
if self.shell.autocall:
|
|
491
|
if self.shell.autocall:
|
|
492
|
self._magic_state.autocall_save = self.shell.autocall
|
|
492
|
self._magic_state.autocall_save = self.shell.autocall
|
|
493
|
self.shell.autocall = 0
|
|
493
|
self.shell.autocall = 0
|
|
494
|
else:
|
|
494
|
else:
|
|
495
|
try:
|
|
495
|
try:
|
|
496
|
self.shell.autocall = self._magic_state.autocall_save
|
|
496
|
self.shell.autocall = self._magic_state.autocall_save
|
|
497
|
except AttributeError:
|
|
497
|
except AttributeError:
|
|
498
|
self.shell.autocall = self._magic_state.autocall_save = 1
|
|
498
|
self.shell.autocall = self._magic_state.autocall_save = 1
|
|
499
|
|
|
499
|
|
|
500
|
print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
|
|
500
|
print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
|
|
501
|
|
|
501
|
|
|
502
|
|
|
502
|
|
|
503
|
def magic_page(self, parameter_s=''):
|
|
503
|
def magic_page(self, parameter_s=''):
|
|
504
|
"""Pretty print the object and display it through a pager.
|
|
504
|
"""Pretty print the object and display it through a pager.
|
|
505
|
|
|
505
|
|
|
506
|
%page [options] OBJECT
|
|
506
|
%page [options] OBJECT
|
|
507
|
|
|
507
|
|
|
508
|
If no object is given, use _ (last output).
|
|
508
|
If no object is given, use _ (last output).
|
|
509
|
|
|
509
|
|
|
510
|
Options:
|
|
510
|
Options:
|
|
511
|
|
|
511
|
|
|
512
|
-r: page str(object), don't pretty-print it."""
|
|
512
|
-r: page str(object), don't pretty-print it."""
|
|
513
|
|
|
513
|
|
|
514
|
# After a function contributed by Olivier Aubert, slightly modified.
|
|
514
|
# After a function contributed by Olivier Aubert, slightly modified.
|
|
515
|
|
|
515
|
|
|
516
|
# Process options/args
|
|
516
|
# Process options/args
|
|
517
|
opts,args = self.parse_options(parameter_s,'r')
|
|
517
|
opts,args = self.parse_options(parameter_s,'r')
|
|
518
|
raw = 'r' in opts
|
|
518
|
raw = 'r' in opts
|
|
519
|
|
|
519
|
|
|
520
|
oname = args and args or '_'
|
|
520
|
oname = args and args or '_'
|
|
521
|
info = self._ofind(oname)
|
|
521
|
info = self._ofind(oname)
|
|
522
|
if info['found']:
|
|
522
|
if info['found']:
|
|
523
|
txt = (raw and str or pformat)( info['obj'] )
|
|
523
|
txt = (raw and str or pformat)( info['obj'] )
|
|
524
|
page.page(txt)
|
|
524
|
page.page(txt)
|
|
525
|
else:
|
|
525
|
else:
|
|
526
|
print 'Object `%s` not found' % oname
|
|
526
|
print 'Object `%s` not found' % oname
|
|
527
|
|
|
527
|
|
|
528
|
def magic_profile(self, parameter_s=''):
|
|
528
|
def magic_profile(self, parameter_s=''):
|
|
529
|
"""Print your currently active IPython profile."""
|
|
529
|
"""Print your currently active IPython profile."""
|
|
530
|
if self.shell.profile:
|
|
530
|
if self.shell.profile:
|
|
531
|
printpl('Current IPython profile: $self.shell.profile.')
|
|
531
|
printpl('Current IPython profile: $self.shell.profile.')
|
|
532
|
else:
|
|
532
|
else:
|
|
533
|
print 'No profile active.'
|
|
533
|
print 'No profile active.'
|
|
534
|
|
|
534
|
|
|
535
|
def magic_pinfo(self, parameter_s='', namespaces=None):
|
|
535
|
def magic_pinfo(self, parameter_s='', namespaces=None):
|
|
536
|
"""Provide detailed information about an object.
|
|
536
|
"""Provide detailed information about an object.
|
|
537
|
|
|
537
|
|
|
538
|
'%pinfo object' is just a synonym for object? or ?object."""
|
|
538
|
'%pinfo object' is just a synonym for object? or ?object."""
|
|
539
|
|
|
539
|
|
|
540
|
#print 'pinfo par: <%s>' % parameter_s # dbg
|
|
540
|
#print 'pinfo par: <%s>' % parameter_s # dbg
|
|
541
|
|
|
541
|
|
|
542
|
|
|
542
|
|
|
543
|
# detail_level: 0 -> obj? , 1 -> obj??
|
|
543
|
# detail_level: 0 -> obj? , 1 -> obj??
|
|
544
|
detail_level = 0
|
|
544
|
detail_level = 0
|
|
545
|
# We need to detect if we got called as 'pinfo pinfo foo', which can
|
|
545
|
# We need to detect if we got called as 'pinfo pinfo foo', which can
|
|
546
|
# happen if the user types 'pinfo foo?' at the cmd line.
|
|
546
|
# happen if the user types 'pinfo foo?' at the cmd line.
|
|
547
|
pinfo,qmark1,oname,qmark2 = \
|
|
547
|
pinfo,qmark1,oname,qmark2 = \
|
|
548
|
re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
|
|
548
|
re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
|
|
549
|
if pinfo or qmark1 or qmark2:
|
|
549
|
if pinfo or qmark1 or qmark2:
|
|
550
|
detail_level = 1
|
|
550
|
detail_level = 1
|
|
551
|
if "*" in oname:
|
|
551
|
if "*" in oname:
|
|
552
|
self.magic_psearch(oname)
|
|
552
|
self.magic_psearch(oname)
|
|
553
|
else:
|
|
553
|
else:
|
|
554
|
self.shell._inspect('pinfo', oname, detail_level=detail_level,
|
|
554
|
self.shell._inspect('pinfo', oname, detail_level=detail_level,
|
|
555
|
namespaces=namespaces)
|
|
555
|
namespaces=namespaces)
|
|
556
|
|
|
556
|
|
|
557
|
def magic_pinfo2(self, parameter_s='', namespaces=None):
|
|
557
|
def magic_pinfo2(self, parameter_s='', namespaces=None):
|
|
558
|
"""Provide extra detailed information about an object.
|
|
558
|
"""Provide extra detailed information about an object.
|
|
559
|
|
|
559
|
|
|
560
|
'%pinfo2 object' is just a synonym for object?? or ??object."""
|
|
560
|
'%pinfo2 object' is just a synonym for object?? or ??object."""
|
|
561
|
self.shell._inspect('pinfo', parameter_s, detail_level=1,
|
|
561
|
self.shell._inspect('pinfo', parameter_s, detail_level=1,
|
|
562
|
namespaces=namespaces)
|
|
562
|
namespaces=namespaces)
|
|
563
|
|
|
563
|
|
|
564
|
@testdec.skip_doctest
|
|
564
|
@testdec.skip_doctest
|
|
565
|
def magic_pdef(self, parameter_s='', namespaces=None):
|
|
565
|
def magic_pdef(self, parameter_s='', namespaces=None):
|
|
566
|
"""Print the definition header for any callable object.
|
|
566
|
"""Print the definition header for any callable object.
|
|
567
|
|
|
567
|
|
|
568
|
If the object is a class, print the constructor information.
|
|
568
|
If the object is a class, print the constructor information.
|
|
569
|
|
|
569
|
|
|
570
|
Examples
|
|
570
|
Examples
|
|
571
|
--------
|
|
571
|
--------
|
|
572
|
::
|
|
572
|
::
|
|
573
|
|
|
573
|
|
|
574
|
In [3]: %pdef urllib.urlopen
|
|
574
|
In [3]: %pdef urllib.urlopen
|
|
575
|
urllib.urlopen(url, data=None, proxies=None)
|
|
575
|
urllib.urlopen(url, data=None, proxies=None)
|
|
576
|
"""
|
|
576
|
"""
|
|
577
|
self._inspect('pdef',parameter_s, namespaces)
|
|
577
|
self._inspect('pdef',parameter_s, namespaces)
|
|
578
|
|
|
578
|
|
|
579
|
def magic_pdoc(self, parameter_s='', namespaces=None):
|
|
579
|
def magic_pdoc(self, parameter_s='', namespaces=None):
|
|
580
|
"""Print the docstring for an object.
|
|
580
|
"""Print the docstring for an object.
|
|
581
|
|
|
581
|
|
|
582
|
If the given object is a class, it will print both the class and the
|
|
582
|
If the given object is a class, it will print both the class and the
|
|
583
|
constructor docstrings."""
|
|
583
|
constructor docstrings."""
|
|
584
|
self._inspect('pdoc',parameter_s, namespaces)
|
|
584
|
self._inspect('pdoc',parameter_s, namespaces)
|
|
585
|
|
|
585
|
|
|
586
|
def magic_psource(self, parameter_s='', namespaces=None):
|
|
586
|
def magic_psource(self, parameter_s='', namespaces=None):
|
|
587
|
"""Print (or run through pager) the source code for an object."""
|
|
587
|
"""Print (or run through pager) the source code for an object."""
|
|
588
|
self._inspect('psource',parameter_s, namespaces)
|
|
588
|
self._inspect('psource',parameter_s, namespaces)
|
|
589
|
|
|
589
|
|
|
590
|
def magic_pfile(self, parameter_s=''):
|
|
590
|
def magic_pfile(self, parameter_s=''):
|
|
591
|
"""Print (or run through pager) the file where an object is defined.
|
|
591
|
"""Print (or run through pager) the file where an object is defined.
|
|
592
|
|
|
592
|
|
|
593
|
The file opens at the line where the object definition begins. IPython
|
|
593
|
The file opens at the line where the object definition begins. IPython
|
|
594
|
will honor the environment variable PAGER if set, and otherwise will
|
|
594
|
will honor the environment variable PAGER if set, and otherwise will
|
|
595
|
do its best to print the file in a convenient form.
|
|
595
|
do its best to print the file in a convenient form.
|
|
596
|
|
|
596
|
|
|
597
|
If the given argument is not an object currently defined, IPython will
|
|
597
|
If the given argument is not an object currently defined, IPython will
|
|
598
|
try to interpret it as a filename (automatically adding a .py extension
|
|
598
|
try to interpret it as a filename (automatically adding a .py extension
|
|
599
|
if needed). You can thus use %pfile as a syntax highlighting code
|
|
599
|
if needed). You can thus use %pfile as a syntax highlighting code
|
|
600
|
viewer."""
|
|
600
|
viewer."""
|
|
601
|
|
|
601
|
|
|
602
|
# first interpret argument as an object name
|
|
602
|
# first interpret argument as an object name
|
|
603
|
out = self._inspect('pfile',parameter_s)
|
|
603
|
out = self._inspect('pfile',parameter_s)
|
|
604
|
# if not, try the input as a filename
|
|
604
|
# if not, try the input as a filename
|
|
605
|
if out == 'not found':
|
|
605
|
if out == 'not found':
|
|
606
|
try:
|
|
606
|
try:
|
|
607
|
filename = get_py_filename(parameter_s)
|
|
607
|
filename = get_py_filename(parameter_s)
|
|
608
|
except IOError,msg:
|
|
608
|
except IOError,msg:
|
|
609
|
print msg
|
|
609
|
print msg
|
|
610
|
return
|
|
610
|
return
|
|
611
|
page.page(self.shell.inspector.format(file(filename).read()))
|
|
611
|
page.page(self.shell.inspector.format(file(filename).read()))
|
|
612
|
|
|
612
|
|
|
613
|
def magic_psearch(self, parameter_s=''):
|
|
613
|
def magic_psearch(self, parameter_s=''):
|
|
614
|
"""Search for object in namespaces by wildcard.
|
|
614
|
"""Search for object in namespaces by wildcard.
|
|
615
|
|
|
615
|
|
|
616
|
%psearch [options] PATTERN [OBJECT TYPE]
|
|
616
|
%psearch [options] PATTERN [OBJECT TYPE]
|
|
617
|
|
|
617
|
|
|
618
|
Note: ? can be used as a synonym for %psearch, at the beginning or at
|
|
618
|
Note: ? can be used as a synonym for %psearch, at the beginning or at
|
|
619
|
the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
|
|
619
|
the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
|
|
620
|
rest of the command line must be unchanged (options come first), so
|
|
620
|
rest of the command line must be unchanged (options come first), so
|
|
621
|
for example the following forms are equivalent
|
|
621
|
for example the following forms are equivalent
|
|
622
|
|
|
622
|
|
|
623
|
%psearch -i a* function
|
|
623
|
%psearch -i a* function
|
|
624
|
-i a* function?
|
|
624
|
-i a* function?
|
|
625
|
?-i a* function
|
|
625
|
?-i a* function
|
|
626
|
|
|
626
|
|
|
627
|
Arguments:
|
|
627
|
Arguments:
|
|
628
|
|
|
628
|
|
|
629
|
PATTERN
|
|
629
|
PATTERN
|
|
630
|
|
|
630
|
|
|
631
|
where PATTERN is a string containing * as a wildcard similar to its
|
|
631
|
where PATTERN is a string containing * as a wildcard similar to its
|
|
632
|
use in a shell. The pattern is matched in all namespaces on the
|
|
632
|
use in a shell. The pattern is matched in all namespaces on the
|
|
633
|
search path. By default objects starting with a single _ are not
|
|
633
|
search path. By default objects starting with a single _ are not
|
|
634
|
matched, many IPython generated objects have a single
|
|
634
|
matched, many IPython generated objects have a single
|
|
635
|
underscore. The default is case insensitive matching. Matching is
|
|
635
|
underscore. The default is case insensitive matching. Matching is
|
|
636
|
also done on the attributes of objects and not only on the objects
|
|
636
|
also done on the attributes of objects and not only on the objects
|
|
637
|
in a module.
|
|
637
|
in a module.
|
|
638
|
|
|
638
|
|
|
639
|
[OBJECT TYPE]
|
|
639
|
[OBJECT TYPE]
|
|
640
|
|
|
640
|
|
|
641
|
Is the name of a python type from the types module. The name is
|
|
641
|
Is the name of a python type from the types module. The name is
|
|
642
|
given in lowercase without the ending type, ex. StringType is
|
|
642
|
given in lowercase without the ending type, ex. StringType is
|
|
643
|
written string. By adding a type here only objects matching the
|
|
643
|
written string. By adding a type here only objects matching the
|
|
644
|
given type are matched. Using all here makes the pattern match all
|
|
644
|
given type are matched. Using all here makes the pattern match all
|
|
645
|
types (this is the default).
|
|
645
|
types (this is the default).
|
|
646
|
|
|
646
|
|
|
647
|
Options:
|
|
647
|
Options:
|
|
648
|
|
|
648
|
|
|
649
|
-a: makes the pattern match even objects whose names start with a
|
|
649
|
-a: makes the pattern match even objects whose names start with a
|
|
650
|
single underscore. These names are normally ommitted from the
|
|
650
|
single underscore. These names are normally ommitted from the
|
|
651
|
search.
|
|
651
|
search.
|
|
652
|
|
|
652
|
|
|
653
|
-i/-c: make the pattern case insensitive/sensitive. If neither of
|
|
653
|
-i/-c: make the pattern case insensitive/sensitive. If neither of
|
|
654
|
these options is given, the default is read from your ipythonrc
|
|
654
|
these options is given, the default is read from your ipythonrc
|
|
655
|
file. The option name which sets this value is
|
|
655
|
file. The option name which sets this value is
|
|
656
|
'wildcards_case_sensitive'. If this option is not specified in your
|
|
656
|
'wildcards_case_sensitive'. If this option is not specified in your
|
|
657
|
ipythonrc file, IPython's internal default is to do a case sensitive
|
|
657
|
ipythonrc file, IPython's internal default is to do a case sensitive
|
|
658
|
search.
|
|
658
|
search.
|
|
659
|
|
|
659
|
|
|
660
|
-e/-s NAMESPACE: exclude/search a given namespace. The pattern you
|
|
660
|
-e/-s NAMESPACE: exclude/search a given namespace. The pattern you
|
|
661
|
specifiy can be searched in any of the following namespaces:
|
|
661
|
specifiy can be searched in any of the following namespaces:
|
|
662
|
'builtin', 'user', 'user_global','internal', 'alias', where
|
|
662
|
'builtin', 'user', 'user_global','internal', 'alias', where
|
|
663
|
'builtin' and 'user' are the search defaults. Note that you should
|
|
663
|
'builtin' and 'user' are the search defaults. Note that you should
|
|
664
|
not use quotes when specifying namespaces.
|
|
664
|
not use quotes when specifying namespaces.
|
|
665
|
|
|
665
|
|
|
666
|
'Builtin' contains the python module builtin, 'user' contains all
|
|
666
|
'Builtin' contains the python module builtin, 'user' contains all
|
|
667
|
user data, 'alias' only contain the shell aliases and no python
|
|
667
|
user data, 'alias' only contain the shell aliases and no python
|
|
668
|
objects, 'internal' contains objects used by IPython. The
|
|
668
|
objects, 'internal' contains objects used by IPython. The
|
|
669
|
'user_global' namespace is only used by embedded IPython instances,
|
|
669
|
'user_global' namespace is only used by embedded IPython instances,
|
|
670
|
and it contains module-level globals. You can add namespaces to the
|
|
670
|
and it contains module-level globals. You can add namespaces to the
|
|
671
|
search with -s or exclude them with -e (these options can be given
|
|
671
|
search with -s or exclude them with -e (these options can be given
|
|
672
|
more than once).
|
|
672
|
more than once).
|
|
673
|
|
|
673
|
|
|
674
|
Examples:
|
|
674
|
Examples:
|
|
675
|
|
|
675
|
|
|
676
|
%psearch a* -> objects beginning with an a
|
|
676
|
%psearch a* -> objects beginning with an a
|
|
677
|
%psearch -e builtin a* -> objects NOT in the builtin space starting in a
|
|
677
|
%psearch -e builtin a* -> objects NOT in the builtin space starting in a
|
|
678
|
%psearch a* function -> all functions beginning with an a
|
|
678
|
%psearch a* function -> all functions beginning with an a
|
|
679
|
%psearch re.e* -> objects beginning with an e in module re
|
|
679
|
%psearch re.e* -> objects beginning with an e in module re
|
|
680
|
%psearch r*.e* -> objects that start with e in modules starting in r
|
|
680
|
%psearch r*.e* -> objects that start with e in modules starting in r
|
|
681
|
%psearch r*.* string -> all strings in modules beginning with r
|
|
681
|
%psearch r*.* string -> all strings in modules beginning with r
|
|
682
|
|
|
682
|
|
|
683
|
Case sensitve search:
|
|
683
|
Case sensitve search:
|
|
684
|
|
|
684
|
|
|
685
|
%psearch -c a* list all object beginning with lower case a
|
|
685
|
%psearch -c a* list all object beginning with lower case a
|
|
686
|
|
|
686
|
|
|
687
|
Show objects beginning with a single _:
|
|
687
|
Show objects beginning with a single _:
|
|
688
|
|
|
688
|
|
|
689
|
%psearch -a _* list objects beginning with a single underscore"""
|
|
689
|
%psearch -a _* list objects beginning with a single underscore"""
|
|
690
|
try:
|
|
690
|
try:
|
|
691
|
parameter_s = parameter_s.encode('ascii')
|
|
691
|
parameter_s = parameter_s.encode('ascii')
|
|
692
|
except UnicodeEncodeError:
|
|
692
|
except UnicodeEncodeError:
|
|
693
|
print 'Python identifiers can only contain ascii characters.'
|
|
693
|
print 'Python identifiers can only contain ascii characters.'
|
|
694
|
return
|
|
694
|
return
|
|
695
|
|
|
695
|
|
|
696
|
# default namespaces to be searched
|
|
696
|
# default namespaces to be searched
|
|
697
|
def_search = ['user','builtin']
|
|
697
|
def_search = ['user','builtin']
|
|
698
|
|
|
698
|
|
|
699
|
# Process options/args
|
|
699
|
# Process options/args
|
|
700
|
opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
|
|
700
|
opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
|
|
701
|
opt = opts.get
|
|
701
|
opt = opts.get
|
|
702
|
shell = self.shell
|
|
702
|
shell = self.shell
|
|
703
|
psearch = shell.inspector.psearch
|
|
703
|
psearch = shell.inspector.psearch
|
|
704
|
|
|
704
|
|
|
705
|
# select case options
|
|
705
|
# select case options
|
|
706
|
if opts.has_key('i'):
|
|
706
|
if opts.has_key('i'):
|
|
707
|
ignore_case = True
|
|
707
|
ignore_case = True
|
|
708
|
elif opts.has_key('c'):
|
|
708
|
elif opts.has_key('c'):
|
|
709
|
ignore_case = False
|
|
709
|
ignore_case = False
|
|
710
|
else:
|
|
710
|
else:
|
|
711
|
ignore_case = not shell.wildcards_case_sensitive
|
|
711
|
ignore_case = not shell.wildcards_case_sensitive
|
|
712
|
|
|
712
|
|
|
713
|
# Build list of namespaces to search from user options
|
|
713
|
# Build list of namespaces to search from user options
|
|
714
|
def_search.extend(opt('s',[]))
|
|
714
|
def_search.extend(opt('s',[]))
|
|
715
|
ns_exclude = ns_exclude=opt('e',[])
|
|
715
|
ns_exclude = ns_exclude=opt('e',[])
|
|
716
|
ns_search = [nm for nm in def_search if nm not in ns_exclude]
|
|
716
|
ns_search = [nm for nm in def_search if nm not in ns_exclude]
|
|
717
|
|
|
717
|
|
|
718
|
# Call the actual search
|
|
718
|
# Call the actual search
|
|
719
|
try:
|
|
719
|
try:
|
|
720
|
psearch(args,shell.ns_table,ns_search,
|
|
720
|
psearch(args,shell.ns_table,ns_search,
|
|
721
|
show_all=opt('a'),ignore_case=ignore_case)
|
|
721
|
show_all=opt('a'),ignore_case=ignore_case)
|
|
722
|
except:
|
|
722
|
except:
|
|
723
|
shell.showtraceback()
|
|
723
|
shell.showtraceback()
|
|
724
|
|
|
724
|
|
|
725
|
@testdec.skip_doctest
|
|
725
|
@testdec.skip_doctest
|
|
726
|
def magic_who_ls(self, parameter_s=''):
|
|
726
|
def magic_who_ls(self, parameter_s=''):
|
|
727
|
"""Return a sorted list of all interactive variables.
|
|
727
|
"""Return a sorted list of all interactive variables.
|
|
728
|
|
|
728
|
|
|
729
|
If arguments are given, only variables of types matching these
|
|
729
|
If arguments are given, only variables of types matching these
|
|
730
|
arguments are returned.
|
|
730
|
arguments are returned.
|
|
731
|
|
|
731
|
|
|
732
|
Examples
|
|
732
|
Examples
|
|
733
|
--------
|
|
733
|
--------
|
|
734
|
|
|
734
|
|
|
735
|
Define two variables and list them with who_ls::
|
|
735
|
Define two variables and list them with who_ls::
|
|
736
|
|
|
736
|
|
|
737
|
In [1]: alpha = 123
|
|
737
|
In [1]: alpha = 123
|
|
738
|
|
|
738
|
|
|
739
|
In [2]: beta = 'test'
|
|
739
|
In [2]: beta = 'test'
|
|
740
|
|
|
740
|
|
|
741
|
In [3]: %who_ls
|
|
741
|
In [3]: %who_ls
|
|
742
|
Out[3]: ['alpha', 'beta']
|
|
742
|
Out[3]: ['alpha', 'beta']
|
|
743
|
|
|
743
|
|
|
744
|
In [4]: %who_ls int
|
|
744
|
In [4]: %who_ls int
|
|
745
|
Out[4]: ['alpha']
|
|
745
|
Out[4]: ['alpha']
|
|
746
|
|
|
746
|
|
|
747
|
In [5]: %who_ls str
|
|
747
|
In [5]: %who_ls str
|
|
748
|
Out[5]: ['beta']
|
|
748
|
Out[5]: ['beta']
|
|
749
|
"""
|
|
749
|
"""
|
|
750
|
|
|
750
|
|
|
751
|
user_ns = self.shell.user_ns
|
|
751
|
user_ns = self.shell.user_ns
|
|
752
|
internal_ns = self.shell.internal_ns
|
|
752
|
internal_ns = self.shell.internal_ns
|
|
753
|
user_ns_hidden = self.shell.user_ns_hidden
|
|
753
|
user_ns_hidden = self.shell.user_ns_hidden
|
|
754
|
out = [ i for i in user_ns
|
|
754
|
out = [ i for i in user_ns
|
|
755
|
if not i.startswith('_') \
|
|
755
|
if not i.startswith('_') \
|
|
756
|
and not (i in internal_ns or i in user_ns_hidden) ]
|
|
756
|
and not (i in internal_ns or i in user_ns_hidden) ]
|
|
757
|
|
|
757
|
|
|
758
|
typelist = parameter_s.split()
|
|
758
|
typelist = parameter_s.split()
|
|
759
|
if typelist:
|
|
759
|
if typelist:
|
|
760
|
typeset = set(typelist)
|
|
760
|
typeset = set(typelist)
|
|
761
|
out = [i for i in out if type(user_ns[i]).__name__ in typeset]
|
|
761
|
out = [i for i in out if type(user_ns[i]).__name__ in typeset]
|
|
762
|
|
|
762
|
|
|
763
|
out.sort()
|
|
763
|
out.sort()
|
|
764
|
return out
|
|
764
|
return out
|
|
765
|
|
|
765
|
|
|
766
|
@testdec.skip_doctest
|
|
766
|
@testdec.skip_doctest
|
|
767
|
def magic_who(self, parameter_s=''):
|
|
767
|
def magic_who(self, parameter_s=''):
|
|
768
|
"""Print all interactive variables, with some minimal formatting.
|
|
768
|
"""Print all interactive variables, with some minimal formatting.
|
|
769
|
|
|
769
|
|
|
770
|
If any arguments are given, only variables whose type matches one of
|
|
770
|
If any arguments are given, only variables whose type matches one of
|
|
771
|
these are printed. For example:
|
|
771
|
these are printed. For example:
|
|
772
|
|
|
772
|
|
|
773
|
%who function str
|
|
773
|
%who function str
|
|
774
|
|
|
774
|
|
|
775
|
will only list functions and strings, excluding all other types of
|
|
775
|
will only list functions and strings, excluding all other types of
|
|
776
|
variables. To find the proper type names, simply use type(var) at a
|
|
776
|
variables. To find the proper type names, simply use type(var) at a
|
|
777
|
command line to see how python prints type names. For example:
|
|
777
|
command line to see how python prints type names. For example:
|
|
778
|
|
|
778
|
|
|
779
|
In [1]: type('hello')\\
|
|
779
|
In [1]: type('hello')\\
|
|
780
|
Out[1]: <type 'str'>
|
|
780
|
Out[1]: <type 'str'>
|
|
781
|
|
|
781
|
|
|
782
|
indicates that the type name for strings is 'str'.
|
|
782
|
indicates that the type name for strings is 'str'.
|
|
783
|
|
|
783
|
|
|
784
|
%who always excludes executed names loaded through your configuration
|
|
784
|
%who always excludes executed names loaded through your configuration
|
|
785
|
file and things which are internal to IPython.
|
|
785
|
file and things which are internal to IPython.
|
|
786
|
|
|
786
|
|
|
787
|
This is deliberate, as typically you may load many modules and the
|
|
787
|
This is deliberate, as typically you may load many modules and the
|
|
788
|
purpose of %who is to show you only what you've manually defined.
|
|
788
|
purpose of %who is to show you only what you've manually defined.
|
|
789
|
|
|
789
|
|
|
790
|
Examples
|
|
790
|
Examples
|
|
791
|
--------
|
|
791
|
--------
|
|
792
|
|
|
792
|
|
|
793
|
Define two variables and list them with who::
|
|
793
|
Define two variables and list them with who::
|
|
794
|
|
|
794
|
|
|
795
|
In [1]: alpha = 123
|
|
795
|
In [1]: alpha = 123
|
|
796
|
|
|
796
|
|
|
797
|
In [2]: beta = 'test'
|
|
797
|
In [2]: beta = 'test'
|
|
798
|
|
|
798
|
|
|
799
|
In [3]: %who
|
|
799
|
In [3]: %who
|
|
800
|
alpha beta
|
|
800
|
alpha beta
|
|
801
|
|
|
801
|
|
|
802
|
In [4]: %who int
|
|
802
|
In [4]: %who int
|
|
803
|
alpha
|
|
803
|
alpha
|
|
804
|
|
|
804
|
|
|
805
|
In [5]: %who str
|
|
805
|
In [5]: %who str
|
|
806
|
beta
|
|
806
|
beta
|
|
807
|
"""
|
|
807
|
"""
|
|
808
|
|
|
808
|
|
|
809
|
varlist = self.magic_who_ls(parameter_s)
|
|
809
|
varlist = self.magic_who_ls(parameter_s)
|
|
810
|
if not varlist:
|
|
810
|
if not varlist:
|
|
811
|
if parameter_s:
|
|
811
|
if parameter_s:
|
|
812
|
print 'No variables match your requested type.'
|
|
812
|
print 'No variables match your requested type.'
|
|
813
|
else:
|
|
813
|
else:
|
|
814
|
print 'Interactive namespace is empty.'
|
|
814
|
print 'Interactive namespace is empty.'
|
|
815
|
return
|
|
815
|
return
|
|
816
|
|
|
816
|
|
|
817
|
# if we have variables, move on...
|
|
817
|
# if we have variables, move on...
|
|
818
|
count = 0
|
|
818
|
count = 0
|
|
819
|
for i in varlist:
|
|
819
|
for i in varlist:
|
|
820
|
print i+'\t',
|
|
820
|
print i+'\t',
|
|
821
|
count += 1
|
|
821
|
count += 1
|
|
822
|
if count > 8:
|
|
822
|
if count > 8:
|
|
823
|
count = 0
|
|
823
|
count = 0
|
|
824
|
print
|
|
824
|
print
|
|
825
|
print
|
|
825
|
print
|
|
826
|
|
|
826
|
|
|
827
|
@testdec.skip_doctest
|
|
827
|
@testdec.skip_doctest
|
|
828
|
def magic_whos(self, parameter_s=''):
|
|
828
|
def magic_whos(self, parameter_s=''):
|
|
829
|
"""Like %who, but gives some extra information about each variable.
|
|
829
|
"""Like %who, but gives some extra information about each variable.
|
|
830
|
|
|
830
|
|
|
831
|
The same type filtering of %who can be applied here.
|
|
831
|
The same type filtering of %who can be applied here.
|
|
832
|
|
|
832
|
|
|
833
|
For all variables, the type is printed. Additionally it prints:
|
|
833
|
For all variables, the type is printed. Additionally it prints:
|
|
834
|
|
|
834
|
|
|
835
|
- For {},[],(): their length.
|
|
835
|
- For {},[],(): their length.
|
|
836
|
|
|
836
|
|
|
837
|
- For numpy and Numeric arrays, a summary with shape, number of
|
|
837
|
- For numpy and Numeric arrays, a summary with shape, number of
|
|
838
|
elements, typecode and size in memory.
|
|
838
|
elements, typecode and size in memory.
|
|
839
|
|
|
839
|
|
|
840
|
- Everything else: a string representation, snipping their middle if
|
|
840
|
- Everything else: a string representation, snipping their middle if
|
|
841
|
too long.
|
|
841
|
too long.
|
|
842
|
|
|
842
|
|
|
843
|
Examples
|
|
843
|
Examples
|
|
844
|
--------
|
|
844
|
--------
|
|
845
|
|
|
845
|
|
|
846
|
Define two variables and list them with whos::
|
|
846
|
Define two variables and list them with whos::
|
|
847
|
|
|
847
|
|
|
848
|
In [1]: alpha = 123
|
|
848
|
In [1]: alpha = 123
|
|
849
|
|
|
849
|
|
|
850
|
In [2]: beta = 'test'
|
|
850
|
In [2]: beta = 'test'
|
|
851
|
|
|
851
|
|
|
852
|
In [3]: %whos
|
|
852
|
In [3]: %whos
|
|
853
|
Variable Type Data/Info
|
|
853
|
Variable Type Data/Info
|
|
854
|
--------------------------------
|
|
854
|
--------------------------------
|
|
855
|
alpha int 123
|
|
855
|
alpha int 123
|
|
856
|
beta str test
|
|
856
|
beta str test
|
|
857
|
"""
|
|
857
|
"""
|
|
858
|
|
|
858
|
|
|
859
|
varnames = self.magic_who_ls(parameter_s)
|
|
859
|
varnames = self.magic_who_ls(parameter_s)
|
|
860
|
if not varnames:
|
|
860
|
if not varnames:
|
|
861
|
if parameter_s:
|
|
861
|
if parameter_s:
|
|
862
|
print 'No variables match your requested type.'
|
|
862
|
print 'No variables match your requested type.'
|
|
863
|
else:
|
|
863
|
else:
|
|
864
|
print 'Interactive namespace is empty.'
|
|
864
|
print 'Interactive namespace is empty.'
|
|
865
|
return
|
|
865
|
return
|
|
866
|
|
|
866
|
|
|
867
|
# if we have variables, move on...
|
|
867
|
# if we have variables, move on...
|
|
868
|
|
|
868
|
|
|
869
|
# for these types, show len() instead of data:
|
|
869
|
# for these types, show len() instead of data:
|
|
870
|
seq_types = [types.DictType,types.ListType,types.TupleType]
|
|
870
|
seq_types = [types.DictType,types.ListType,types.TupleType]
|
|
871
|
|
|
871
|
|
|
872
|
# for numpy/Numeric arrays, display summary info
|
|
872
|
# for numpy/Numeric arrays, display summary info
|
|
873
|
try:
|
|
873
|
try:
|
|
874
|
import numpy
|
|
874
|
import numpy
|
|
875
|
except ImportError:
|
|
875
|
except ImportError:
|
|
876
|
ndarray_type = None
|
|
876
|
ndarray_type = None
|
|
877
|
else:
|
|
877
|
else:
|
|
878
|
ndarray_type = numpy.ndarray.__name__
|
|
878
|
ndarray_type = numpy.ndarray.__name__
|
|
879
|
try:
|
|
879
|
try:
|
|
880
|
import Numeric
|
|
880
|
import Numeric
|
|
881
|
except ImportError:
|
|
881
|
except ImportError:
|
|
882
|
array_type = None
|
|
882
|
array_type = None
|
|
883
|
else:
|
|
883
|
else:
|
|
884
|
array_type = Numeric.ArrayType.__name__
|
|
884
|
array_type = Numeric.ArrayType.__name__
|
|
885
|
|
|
885
|
|
|
886
|
# Find all variable names and types so we can figure out column sizes
|
|
886
|
# Find all variable names and types so we can figure out column sizes
|
|
887
|
def get_vars(i):
|
|
887
|
def get_vars(i):
|
|
888
|
return self.shell.user_ns[i]
|
|
888
|
return self.shell.user_ns[i]
|
|
889
|
|
|
889
|
|
|
890
|
# some types are well known and can be shorter
|
|
890
|
# some types are well known and can be shorter
|
|
891
|
abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
|
|
891
|
abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
|
|
892
|
def type_name(v):
|
|
892
|
def type_name(v):
|
|
893
|
tn = type(v).__name__
|
|
893
|
tn = type(v).__name__
|
|
894
|
return abbrevs.get(tn,tn)
|
|
894
|
return abbrevs.get(tn,tn)
|
|
895
|
|
|
895
|
|
|
896
|
varlist = map(get_vars,varnames)
|
|
896
|
varlist = map(get_vars,varnames)
|
|
897
|
|
|
897
|
|
|
898
|
typelist = []
|
|
898
|
typelist = []
|
|
899
|
for vv in varlist:
|
|
899
|
for vv in varlist:
|
|
900
|
tt = type_name(vv)
|
|
900
|
tt = type_name(vv)
|
|
901
|
|
|
901
|
|
|
902
|
if tt=='instance':
|
|
902
|
if tt=='instance':
|
|
903
|
typelist.append( abbrevs.get(str(vv.__class__),
|
|
903
|
typelist.append( abbrevs.get(str(vv.__class__),
|
|
904
|
str(vv.__class__)))
|
|
904
|
str(vv.__class__)))
|
|
905
|
else:
|
|
905
|
else:
|
|
906
|
typelist.append(tt)
|
|
906
|
typelist.append(tt)
|
|
907
|
|
|
907
|
|
|
908
|
# column labels and # of spaces as separator
|
|
908
|
# column labels and # of spaces as separator
|
|
909
|
varlabel = 'Variable'
|
|
909
|
varlabel = 'Variable'
|
|
910
|
typelabel = 'Type'
|
|
910
|
typelabel = 'Type'
|
|
911
|
datalabel = 'Data/Info'
|
|
911
|
datalabel = 'Data/Info'
|
|
912
|
colsep = 3
|
|
912
|
colsep = 3
|
|
913
|
# variable format strings
|
|
913
|
# variable format strings
|
|
914
|
vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
|
|
914
|
vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
|
|
915
|
vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
|
|
915
|
vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
|
|
916
|
aformat = "%s: %s elems, type `%s`, %s bytes"
|
|
916
|
aformat = "%s: %s elems, type `%s`, %s bytes"
|
|
917
|
# find the size of the columns to format the output nicely
|
|
917
|
# find the size of the columns to format the output nicely
|
|
918
|
varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
|
|
918
|
varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
|
|
919
|
typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
|
|
919
|
typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
|
|
920
|
# table header
|
|
920
|
# table header
|
|
921
|
print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
|
|
921
|
print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
|
|
922
|
' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
|
|
922
|
' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
|
|
923
|
# and the table itself
|
|
923
|
# and the table itself
|
|
924
|
kb = 1024
|
|
924
|
kb = 1024
|
|
925
|
Mb = 1048576 # kb**2
|
|
925
|
Mb = 1048576 # kb**2
|
|
926
|
for vname,var,vtype in zip(varnames,varlist,typelist):
|
|
926
|
for vname,var,vtype in zip(varnames,varlist,typelist):
|
|
927
|
print itpl(vformat),
|
|
927
|
print itpl(vformat),
|
|
928
|
if vtype in seq_types:
|
|
928
|
if vtype in seq_types:
|
|
929
|
print len(var)
|
|
929
|
print len(var)
|
|
930
|
elif vtype in [array_type,ndarray_type]:
|
|
930
|
elif vtype in [array_type,ndarray_type]:
|
|
931
|
vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
|
|
931
|
vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
|
|
932
|
if vtype==ndarray_type:
|
|
932
|
if vtype==ndarray_type:
|
|
933
|
# numpy
|
|
933
|
# numpy
|
|
934
|
vsize = var.size
|
|
934
|
vsize = var.size
|
|
935
|
vbytes = vsize*var.itemsize
|
|
935
|
vbytes = vsize*var.itemsize
|
|
936
|
vdtype = var.dtype
|
|
936
|
vdtype = var.dtype
|
|
937
|
else:
|
|
937
|
else:
|
|
938
|
# Numeric
|
|
938
|
# Numeric
|
|
939
|
vsize = Numeric.size(var)
|
|
939
|
vsize = Numeric.size(var)
|
|
940
|
vbytes = vsize*var.itemsize()
|
|
940
|
vbytes = vsize*var.itemsize()
|
|
941
|
vdtype = var.typecode()
|
|
941
|
vdtype = var.typecode()
|
|
942
|
|
|
942
|
|
|
943
|
if vbytes < 100000:
|
|
943
|
if vbytes < 100000:
|
|
944
|
print aformat % (vshape,vsize,vdtype,vbytes)
|
|
944
|
print aformat % (vshape,vsize,vdtype,vbytes)
|
|
945
|
else:
|
|
945
|
else:
|
|
946
|
print aformat % (vshape,vsize,vdtype,vbytes),
|
|
946
|
print aformat % (vshape,vsize,vdtype,vbytes),
|
|
947
|
if vbytes < Mb:
|
|
947
|
if vbytes < Mb:
|
|
948
|
print '(%s kb)' % (vbytes/kb,)
|
|
948
|
print '(%s kb)' % (vbytes/kb,)
|
|
949
|
else:
|
|
949
|
else:
|
|
950
|
print '(%s Mb)' % (vbytes/Mb,)
|
|
950
|
print '(%s Mb)' % (vbytes/Mb,)
|
|
951
|
else:
|
|
951
|
else:
|
|
952
|
try:
|
|
952
|
try:
|
|
953
|
vstr = str(var)
|
|
953
|
vstr = str(var)
|
|
954
|
except UnicodeEncodeError:
|
|
954
|
except UnicodeEncodeError:
|
|
955
|
vstr = unicode(var).encode(sys.getdefaultencoding(),
|
|
955
|
vstr = unicode(var).encode(sys.getdefaultencoding(),
|
|
956
|
'backslashreplace')
|
|
956
|
'backslashreplace')
|
|
957
|
vstr = vstr.replace('\n','\\n')
|
|
957
|
vstr = vstr.replace('\n','\\n')
|
|
958
|
if len(vstr) < 50:
|
|
958
|
if len(vstr) < 50:
|
|
959
|
print vstr
|
|
959
|
print vstr
|
|
960
|
else:
|
|
960
|
else:
|
|
961
|
printpl(vfmt_short)
|
|
961
|
printpl(vfmt_short)
|
|
962
|
|
|
962
|
|
|
963
|
def magic_reset(self, parameter_s=''):
|
|
963
|
def magic_reset(self, parameter_s=''):
|
|
964
|
"""Resets the namespace by removing all names defined by the user.
|
|
964
|
"""Resets the namespace by removing all names defined by the user.
|
|
965
|
|
|
965
|
|
|
966
|
Input/Output history are left around in case you need them.
|
|
966
|
Input/Output history are left around in case you need them.
|
|
967
|
|
|
967
|
|
|
968
|
Parameters
|
|
968
|
Parameters
|
|
969
|
----------
|
|
969
|
----------
|
|
970
|
-y : force reset without asking for confirmation.
|
|
970
|
-y : force reset without asking for confirmation.
|
|
971
|
|
|
971
|
|
|
972
|
Examples
|
|
972
|
Examples
|
|
973
|
--------
|
|
973
|
--------
|
|
974
|
In [6]: a = 1
|
|
974
|
In [6]: a = 1
|
|
975
|
|
|
975
|
|
|
976
|
In [7]: a
|
|
976
|
In [7]: a
|
|
977
|
Out[7]: 1
|
|
977
|
Out[7]: 1
|
|
978
|
|
|
978
|
|
|
979
|
In [8]: 'a' in _ip.user_ns
|
|
979
|
In [8]: 'a' in _ip.user_ns
|
|
980
|
Out[8]: True
|
|
980
|
Out[8]: True
|
|
981
|
|
|
981
|
|
|
982
|
In [9]: %reset -f
|
|
982
|
In [9]: %reset -f
|
|
983
|
|
|
983
|
|
|
984
|
In [10]: 'a' in _ip.user_ns
|
|
984
|
In [10]: 'a' in _ip.user_ns
|
|
985
|
Out[10]: False
|
|
985
|
Out[10]: False
|
|
986
|
"""
|
|
986
|
"""
|
|
987
|
|
|
987
|
|
|
988
|
if parameter_s == '-f':
|
|
988
|
if parameter_s == '-f':
|
|
989
|
ans = True
|
|
989
|
ans = True
|
|
990
|
else:
|
|
990
|
else:
|
|
991
|
ans = self.shell.ask_yes_no(
|
|
991
|
ans = self.shell.ask_yes_no(
|
|
992
|
"Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
|
|
992
|
"Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
|
|
993
|
if not ans:
|
|
993
|
if not ans:
|
|
994
|
print 'Nothing done.'
|
|
994
|
print 'Nothing done.'
|
|
995
|
return
|
|
995
|
return
|
|
996
|
user_ns = self.shell.user_ns
|
|
996
|
user_ns = self.shell.user_ns
|
|
997
|
for i in self.magic_who_ls():
|
|
997
|
for i in self.magic_who_ls():
|
|
998
|
del(user_ns[i])
|
|
998
|
del(user_ns[i])
|
|
999
|
|
|
999
|
|
|
1000
|
# Also flush the private list of module references kept for script
|
|
1000
|
# Also flush the private list of module references kept for script
|
|
1001
|
# execution protection
|
|
1001
|
# execution protection
|
|
1002
|
self.shell.clear_main_mod_cache()
|
|
1002
|
self.shell.clear_main_mod_cache()
|
|
1003
|
|
|
1003
|
|
|
1004
|
def magic_reset_selective(self, parameter_s=''):
|
|
1004
|
def magic_reset_selective(self, parameter_s=''):
|
|
1005
|
"""Resets the namespace by removing names defined by the user.
|
|
1005
|
"""Resets the namespace by removing names defined by the user.
|
|
1006
|
|
|
1006
|
|
|
1007
|
Input/Output history are left around in case you need them.
|
|
1007
|
Input/Output history are left around in case you need them.
|
|
1008
|
|
|
1008
|
|
|
1009
|
%reset_selective [-f] regex
|
|
1009
|
%reset_selective [-f] regex
|
|
1010
|
|
|
1010
|
|
|
1011
|
No action is taken if regex is not included
|
|
1011
|
No action is taken if regex is not included
|
|
1012
|
|
|
1012
|
|
|
1013
|
Options
|
|
1013
|
Options
|
|
1014
|
-f : force reset without asking for confirmation.
|
|
1014
|
-f : force reset without asking for confirmation.
|
|
1015
|
|
|
1015
|
|
|
1016
|
Examples
|
|
1016
|
Examples
|
|
1017
|
--------
|
|
1017
|
--------
|
|
1018
|
|
|
1018
|
|
|
1019
|
We first fully reset the namespace so your output looks identical to
|
|
1019
|
We first fully reset the namespace so your output looks identical to
|
|
1020
|
this example for pedagogical reasons; in practice you do not need a
|
|
1020
|
this example for pedagogical reasons; in practice you do not need a
|
|
1021
|
full reset.
|
|
1021
|
full reset.
|
|
1022
|
|
|
1022
|
|
|
1023
|
In [1]: %reset -f
|
|
1023
|
In [1]: %reset -f
|
|
1024
|
|
|
1024
|
|
|
1025
|
Now, with a clean namespace we can make a few variables and use
|
|
1025
|
Now, with a clean namespace we can make a few variables and use
|
|
1026
|
%reset_selective to only delete names that match our regexp:
|
|
1026
|
%reset_selective to only delete names that match our regexp:
|
|
1027
|
|
|
1027
|
|
|
1028
|
In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
|
|
1028
|
In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
|
|
1029
|
|
|
1029
|
|
|
1030
|
In [3]: who_ls
|
|
1030
|
In [3]: who_ls
|
|
1031
|
Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
|
|
1031
|
Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
|
|
1032
|
|
|
1032
|
|
|
1033
|
In [4]: %reset_selective -f b[2-3]m
|
|
1033
|
In [4]: %reset_selective -f b[2-3]m
|
|
1034
|
|
|
1034
|
|
|
1035
|
In [5]: who_ls
|
|
1035
|
In [5]: who_ls
|
|
1036
|
Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
|
|
1036
|
Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
|
|
1037
|
|
|
1037
|
|
|
1038
|
In [6]: %reset_selective -f d
|
|
1038
|
In [6]: %reset_selective -f d
|
|
1039
|
|
|
1039
|
|
|
1040
|
In [7]: who_ls
|
|
1040
|
In [7]: who_ls
|
|
1041
|
Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
|
|
1041
|
Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
|
|
1042
|
|
|
1042
|
|
|
1043
|
In [8]: %reset_selective -f c
|
|
1043
|
In [8]: %reset_selective -f c
|
|
1044
|
|
|
1044
|
|
|
1045
|
In [9]: who_ls
|
|
1045
|
In [9]: who_ls
|
|
1046
|
Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
|
|
1046
|
Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
|
|
1047
|
|
|
1047
|
|
|
1048
|
In [10]: %reset_selective -f b
|
|
1048
|
In [10]: %reset_selective -f b
|
|
1049
|
|
|
1049
|
|
|
1050
|
In [11]: who_ls
|
|
1050
|
In [11]: who_ls
|
|
1051
|
Out[11]: ['a']
|
|
1051
|
Out[11]: ['a']
|
|
1052
|
"""
|
|
1052
|
"""
|
|
1053
|
|
|
1053
|
|
|
1054
|
opts, regex = self.parse_options(parameter_s,'f')
|
|
1054
|
opts, regex = self.parse_options(parameter_s,'f')
|
|
1055
|
|
|
1055
|
|
|
1056
|
if opts.has_key('f'):
|
|
1056
|
if opts.has_key('f'):
|
|
1057
|
ans = True
|
|
1057
|
ans = True
|
|
1058
|
else:
|
|
1058
|
else:
|
|
1059
|
ans = self.shell.ask_yes_no(
|
|
1059
|
ans = self.shell.ask_yes_no(
|
|
1060
|
"Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
|
|
1060
|
"Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
|
|
1061
|
if not ans:
|
|
1061
|
if not ans:
|
|
1062
|
print 'Nothing done.'
|
|
1062
|
print 'Nothing done.'
|
|
1063
|
return
|
|
1063
|
return
|
|
1064
|
user_ns = self.shell.user_ns
|
|
1064
|
user_ns = self.shell.user_ns
|
|
1065
|
if not regex:
|
|
1065
|
if not regex:
|
|
1066
|
print 'No regex pattern specified. Nothing done.'
|
|
1066
|
print 'No regex pattern specified. Nothing done.'
|
|
1067
|
return
|
|
1067
|
return
|
|
1068
|
else:
|
|
1068
|
else:
|
|
1069
|
try:
|
|
1069
|
try:
|
|
1070
|
m = re.compile(regex)
|
|
1070
|
m = re.compile(regex)
|
|
1071
|
except TypeError:
|
|
1071
|
except TypeError:
|
|
1072
|
raise TypeError('regex must be a string or compiled pattern')
|
|
1072
|
raise TypeError('regex must be a string or compiled pattern')
|
|
1073
|
for i in self.magic_who_ls():
|
|
1073
|
for i in self.magic_who_ls():
|
|
1074
|
if m.search(i):
|
|
1074
|
if m.search(i):
|
|
1075
|
del(user_ns[i])
|
|
1075
|
del(user_ns[i])
|
|
1076
|
|
|
1076
|
|
|
1077
|
def magic_logstart(self,parameter_s=''):
|
|
1077
|
def magic_logstart(self,parameter_s=''):
|
|
1078
|
"""Start logging anywhere in a session.
|
|
1078
|
"""Start logging anywhere in a session.
|
|
1079
|
|
|
1079
|
|
|
1080
|
%logstart [-o|-r|-t] [log_name [log_mode]]
|
|
1080
|
%logstart [-o|-r|-t] [log_name [log_mode]]
|
|
1081
|
|
|
1081
|
|
|
1082
|
If no name is given, it defaults to a file named 'ipython_log.py' in your
|
|
1082
|
If no name is given, it defaults to a file named 'ipython_log.py' in your
|
|
1083
|
current directory, in 'rotate' mode (see below).
|
|
1083
|
current directory, in 'rotate' mode (see below).
|
|
1084
|
|
|
1084
|
|
|
1085
|
'%logstart name' saves to file 'name' in 'backup' mode. It saves your
|
|
1085
|
'%logstart name' saves to file 'name' in 'backup' mode. It saves your
|
|
1086
|
history up to that point and then continues logging.
|
|
1086
|
history up to that point and then continues logging.
|
|
1087
|
|
|
1087
|
|
|
1088
|
%logstart takes a second optional parameter: logging mode. This can be one
|
|
1088
|
%logstart takes a second optional parameter: logging mode. This can be one
|
|
1089
|
of (note that the modes are given unquoted):\\
|
|
1089
|
of (note that the modes are given unquoted):\\
|
|
1090
|
append: well, that says it.\\
|
|
1090
|
append: well, that says it.\\
|
|
1091
|
backup: rename (if exists) to name~ and start name.\\
|
|
1091
|
backup: rename (if exists) to name~ and start name.\\
|
|
1092
|
global: single logfile in your home dir, appended to.\\
|
|
1092
|
global: single logfile in your home dir, appended to.\\
|
|
1093
|
over : overwrite existing log.\\
|
|
1093
|
over : overwrite existing log.\\
|
|
1094
|
rotate: create rotating logs name.1~, name.2~, etc.
|
|
1094
|
rotate: create rotating logs name.1~, name.2~, etc.
|
|
1095
|
|
|
1095
|
|
|
1096
|
Options:
|
|
1096
|
Options:
|
|
1097
|
|
|
1097
|
|
|
1098
|
-o: log also IPython's output. In this mode, all commands which
|
|
1098
|
-o: log also IPython's output. In this mode, all commands which
|
|
1099
|
generate an Out[NN] prompt are recorded to the logfile, right after
|
|
1099
|
generate an Out[NN] prompt are recorded to the logfile, right after
|
|
1100
|
their corresponding input line. The output lines are always
|
|
1100
|
their corresponding input line. The output lines are always
|
|
1101
|
prepended with a '#[Out]# ' marker, so that the log remains valid
|
|
1101
|
prepended with a '#[Out]# ' marker, so that the log remains valid
|
|
1102
|
Python code.
|
|
1102
|
Python code.
|
|
1103
|
|
|
1103
|
|
|
1104
|
Since this marker is always the same, filtering only the output from
|
|
1104
|
Since this marker is always the same, filtering only the output from
|
|
1105
|
a log is very easy, using for example a simple awk call:
|
|
1105
|
a log is very easy, using for example a simple awk call:
|
|
1106
|
|
|
1106
|
|
|
1107
|
awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
|
|
1107
|
awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
|
|
1108
|
|
|
1108
|
|
|
1109
|
-r: log 'raw' input. Normally, IPython's logs contain the processed
|
|
1109
|
-r: log 'raw' input. Normally, IPython's logs contain the processed
|
|
1110
|
input, so that user lines are logged in their final form, converted
|
|
1110
|
input, so that user lines are logged in their final form, converted
|
|
1111
|
into valid Python. For example, %Exit is logged as
|
|
1111
|
into valid Python. For example, %Exit is logged as
|
|
1112
|
'_ip.magic("Exit"). If the -r flag is given, all input is logged
|
|
1112
|
'_ip.magic("Exit"). If the -r flag is given, all input is logged
|
|
1113
|
exactly as typed, with no transformations applied.
|
|
1113
|
exactly as typed, with no transformations applied.
|
|
1114
|
|
|
1114
|
|
|
1115
|
-t: put timestamps before each input line logged (these are put in
|
|
1115
|
-t: put timestamps before each input line logged (these are put in
|
|
1116
|
comments)."""
|
|
1116
|
comments)."""
|
|
1117
|
|
|
1117
|
|
|
1118
|
opts,par = self.parse_options(parameter_s,'ort')
|
|
1118
|
opts,par = self.parse_options(parameter_s,'ort')
|
|
1119
|
log_output = 'o' in opts
|
|
1119
|
log_output = 'o' in opts
|
|
1120
|
log_raw_input = 'r' in opts
|
|
1120
|
log_raw_input = 'r' in opts
|
|
1121
|
timestamp = 't' in opts
|
|
1121
|
timestamp = 't' in opts
|
|
1122
|
|
|
1122
|
|
|
1123
|
logger = self.shell.logger
|
|
1123
|
logger = self.shell.logger
|
|
1124
|
|
|
1124
|
|
|
1125
|
# if no args are given, the defaults set in the logger constructor by
|
|
1125
|
# if no args are given, the defaults set in the logger constructor by
|
|
1126
|
# ipytohn remain valid
|
|
1126
|
# ipytohn remain valid
|
|
1127
|
if par:
|
|
1127
|
if par:
|
|
1128
|
try:
|
|
1128
|
try:
|
|
1129
|
logfname,logmode = par.split()
|
|
1129
|
logfname,logmode = par.split()
|
|
1130
|
except:
|
|
1130
|
except:
|
|
1131
|
logfname = par
|
|
1131
|
logfname = par
|
|
1132
|
logmode = 'backup'
|
|
1132
|
logmode = 'backup'
|
|
1133
|
else:
|
|
1133
|
else:
|
|
1134
|
logfname = logger.logfname
|
|
1134
|
logfname = logger.logfname
|
|
1135
|
logmode = logger.logmode
|
|
1135
|
logmode = logger.logmode
|
|
1136
|
# put logfname into rc struct as if it had been called on the command
|
|
1136
|
# put logfname into rc struct as if it had been called on the command
|
|
1137
|
# line, so it ends up saved in the log header Save it in case we need
|
|
1137
|
# line, so it ends up saved in the log header Save it in case we need
|
|
1138
|
# to restore it...
|
|
1138
|
# to restore it...
|
|
1139
|
old_logfile = self.shell.logfile
|
|
1139
|
old_logfile = self.shell.logfile
|
|
1140
|
if logfname:
|
|
1140
|
if logfname:
|
|
1141
|
logfname = os.path.expanduser(logfname)
|
|
1141
|
logfname = os.path.expanduser(logfname)
|
|
1142
|
self.shell.logfile = logfname
|
|
1142
|
self.shell.logfile = logfname
|
|
1143
|
|
|
1143
|
|
|
1144
|
loghead = '# IPython log file\n\n'
|
|
1144
|
loghead = '# IPython log file\n\n'
|
|
1145
|
try:
|
|
1145
|
try:
|
|
1146
|
started = logger.logstart(logfname,loghead,logmode,
|
|
1146
|
started = logger.logstart(logfname,loghead,logmode,
|
|
1147
|
log_output,timestamp,log_raw_input)
|
|
1147
|
log_output,timestamp,log_raw_input)
|
|
1148
|
except:
|
|
1148
|
except:
|
|
1149
|
self.shell.logfile = old_logfile
|
|
1149
|
self.shell.logfile = old_logfile
|
|
1150
|
warn("Couldn't start log: %s" % sys.exc_info()[1])
|
|
1150
|
warn("Couldn't start log: %s" % sys.exc_info()[1])
|
|
1151
|
else:
|
|
1151
|
else:
|
|
1152
|
# log input history up to this point, optionally interleaving
|
|
1152
|
# log input history up to this point, optionally interleaving
|
|
1153
|
# output if requested
|
|
1153
|
# output if requested
|
|
1154
|
|
|
1154
|
|
|
1155
|
if timestamp:
|
|
1155
|
if timestamp:
|
|
1156
|
# disable timestamping for the previous history, since we've
|
|
1156
|
# disable timestamping for the previous history, since we've
|
|
1157
|
# lost those already (no time machine here).
|
|
1157
|
# lost those already (no time machine here).
|
|
1158
|
logger.timestamp = False
|
|
1158
|
logger.timestamp = False
|
|
1159
|
|
|
1159
|
|
|
1160
|
if log_raw_input:
|
|
1160
|
if log_raw_input:
|
|
1161
|
input_hist = self.shell.history_manager.input_hist_raw
|
|
1161
|
input_hist = self.shell.history_manager.input_hist_raw
|
|
1162
|
else:
|
|
1162
|
else:
|
|
1163
|
input_hist = self.shell.history_manager.input_hist_parsed
|
|
1163
|
input_hist = self.shell.history_manager.input_hist_parsed
|
|
1164
|
|
|
1164
|
|
|
1165
|
if log_output:
|
|
1165
|
if log_output:
|
|
1166
|
log_write = logger.log_write
|
|
1166
|
log_write = logger.log_write
|
|
1167
|
output_hist = self.shell.history_manager.output_hist
|
|
1167
|
output_hist = self.shell.history_manager.output_hist
|
|
1168
|
for n in range(1,len(input_hist)-1):
|
|
1168
|
for n in range(1,len(input_hist)-1):
|
|
1169
|
log_write(input_hist[n].rstrip())
|
|
1169
|
log_write(input_hist[n].rstrip())
|
|
1170
|
if n in output_hist:
|
|
1170
|
if n in output_hist:
|
|
1171
|
log_write(repr(output_hist[n]),'output')
|
|
1171
|
log_write(repr(output_hist[n]),'output')
|
|
1172
|
else:
|
|
1172
|
else:
|
|
1173
|
logger.log_write(''.join(input_hist[1:]))
|
|
1173
|
logger.log_write(''.join(input_hist[1:]))
|
|
1174
|
if timestamp:
|
|
1174
|
if timestamp:
|
|
1175
|
# re-enable timestamping
|
|
1175
|
# re-enable timestamping
|
|
1176
|
logger.timestamp = True
|
|
1176
|
logger.timestamp = True
|
|
1177
|
|
|
1177
|
|
|
1178
|
print ('Activating auto-logging. '
|
|
1178
|
print ('Activating auto-logging. '
|
|
1179
|
'Current session state plus future input saved.')
|
|
1179
|
'Current session state plus future input saved.')
|
|
1180
|
logger.logstate()
|
|
1180
|
logger.logstate()
|
|
1181
|
|
|
1181
|
|
|
1182
|
def magic_logstop(self,parameter_s=''):
|
|
1182
|
def magic_logstop(self,parameter_s=''):
|
|
1183
|
"""Fully stop logging and close log file.
|
|
1183
|
"""Fully stop logging and close log file.
|
|
1184
|
|
|
1184
|
|
|
1185
|
In order to start logging again, a new %logstart call needs to be made,
|
|
1185
|
In order to start logging again, a new %logstart call needs to be made,
|
|
1186
|
possibly (though not necessarily) with a new filename, mode and other
|
|
1186
|
possibly (though not necessarily) with a new filename, mode and other
|
|
1187
|
options."""
|
|
1187
|
options."""
|
|
1188
|
self.logger.logstop()
|
|
1188
|
self.logger.logstop()
|
|
1189
|
|
|
1189
|
|
|
1190
|
def magic_logoff(self,parameter_s=''):
|
|
1190
|
def magic_logoff(self,parameter_s=''):
|
|
1191
|
"""Temporarily stop logging.
|
|
1191
|
"""Temporarily stop logging.
|
|
1192
|
|
|
1192
|
|
|
1193
|
You must have previously started logging."""
|
|
1193
|
You must have previously started logging."""
|
|
1194
|
self.shell.logger.switch_log(0)
|
|
1194
|
self.shell.logger.switch_log(0)
|
|
1195
|
|
|
1195
|
|
|
1196
|
def magic_logon(self,parameter_s=''):
|
|
1196
|
def magic_logon(self,parameter_s=''):
|
|
1197
|
"""Restart logging.
|
|
1197
|
"""Restart logging.
|
|
1198
|
|
|
1198
|
|
|
1199
|
This function is for restarting logging which you've temporarily
|
|
1199
|
This function is for restarting logging which you've temporarily
|
|
1200
|
stopped with %logoff. For starting logging for the first time, you
|
|
1200
|
stopped with %logoff. For starting logging for the first time, you
|
|
1201
|
must use the %logstart function, which allows you to specify an
|
|
1201
|
must use the %logstart function, which allows you to specify an
|
|
1202
|
optional log filename."""
|
|
1202
|
optional log filename."""
|
|
1203
|
|
|
1203
|
|
|
1204
|
self.shell.logger.switch_log(1)
|
|
1204
|
self.shell.logger.switch_log(1)
|
|
1205
|
|
|
1205
|
|
|
1206
|
def magic_logstate(self,parameter_s=''):
|
|
1206
|
def magic_logstate(self,parameter_s=''):
|
|
1207
|
"""Print the status of the logging system."""
|
|
1207
|
"""Print the status of the logging system."""
|
|
1208
|
|
|
1208
|
|
|
1209
|
self.shell.logger.logstate()
|
|
1209
|
self.shell.logger.logstate()
|
|
1210
|
|
|
1210
|
|
|
1211
|
def magic_pdb(self, parameter_s=''):
|
|
1211
|
def magic_pdb(self, parameter_s=''):
|
|
1212
|
"""Control the automatic calling of the pdb interactive debugger.
|
|
1212
|
"""Control the automatic calling of the pdb interactive debugger.
|
|
1213
|
|
|
1213
|
|
|
1214
|
Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
|
|
1214
|
Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
|
|
1215
|
argument it works as a toggle.
|
|
1215
|
argument it works as a toggle.
|
|
1216
|
|
|
1216
|
|
|
1217
|
When an exception is triggered, IPython can optionally call the
|
|
1217
|
When an exception is triggered, IPython can optionally call the
|
|
1218
|
interactive pdb debugger after the traceback printout. %pdb toggles
|
|
1218
|
interactive pdb debugger after the traceback printout. %pdb toggles
|
|
1219
|
this feature on and off.
|
|
1219
|
this feature on and off.
|
|
1220
|
|
|
1220
|
|
|
1221
|
The initial state of this feature is set in your ipythonrc
|
|
1221
|
The initial state of this feature is set in your ipythonrc
|
|
1222
|
configuration file (the variable is called 'pdb').
|
|
1222
|
configuration file (the variable is called 'pdb').
|
|
1223
|
|
|
1223
|
|
|
1224
|
If you want to just activate the debugger AFTER an exception has fired,
|
|
1224
|
If you want to just activate the debugger AFTER an exception has fired,
|
|
1225
|
without having to type '%pdb on' and rerunning your code, you can use
|
|
1225
|
without having to type '%pdb on' and rerunning your code, you can use
|
|
1226
|
the %debug magic."""
|
|
1226
|
the %debug magic."""
|
|
1227
|
|
|
1227
|
|
|
1228
|
par = parameter_s.strip().lower()
|
|
1228
|
par = parameter_s.strip().lower()
|
|
1229
|
|
|
1229
|
|
|
1230
|
if par:
|
|
1230
|
if par:
|
|
1231
|
try:
|
|
1231
|
try:
|
|
1232
|
new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
|
|
1232
|
new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
|
|
1233
|
except KeyError:
|
|
1233
|
except KeyError:
|
|
1234
|
print ('Incorrect argument. Use on/1, off/0, '
|
|
1234
|
print ('Incorrect argument. Use on/1, off/0, '
|
|
1235
|
'or nothing for a toggle.')
|
|
1235
|
'or nothing for a toggle.')
|
|
1236
|
return
|
|
1236
|
return
|
|
1237
|
else:
|
|
1237
|
else:
|
|
1238
|
# toggle
|
|
1238
|
# toggle
|
|
1239
|
new_pdb = not self.shell.call_pdb
|
|
1239
|
new_pdb = not self.shell.call_pdb
|
|
1240
|
|
|
1240
|
|
|
1241
|
# set on the shell
|
|
1241
|
# set on the shell
|
|
1242
|
self.shell.call_pdb = new_pdb
|
|
1242
|
self.shell.call_pdb = new_pdb
|
|
1243
|
print 'Automatic pdb calling has been turned',on_off(new_pdb)
|
|
1243
|
print 'Automatic pdb calling has been turned',on_off(new_pdb)
|
|
1244
|
|
|
1244
|
|
|
1245
|
def magic_debug(self, parameter_s=''):
|
|
1245
|
def magic_debug(self, parameter_s=''):
|
|
1246
|
"""Activate the interactive debugger in post-mortem mode.
|
|
1246
|
"""Activate the interactive debugger in post-mortem mode.
|
|
1247
|
|
|
1247
|
|
|
1248
|
If an exception has just occurred, this lets you inspect its stack
|
|
1248
|
If an exception has just occurred, this lets you inspect its stack
|
|
1249
|
frames interactively. Note that this will always work only on the last
|
|
1249
|
frames interactively. Note that this will always work only on the last
|
|
1250
|
traceback that occurred, so you must call this quickly after an
|
|
1250
|
traceback that occurred, so you must call this quickly after an
|
|
1251
|
exception that you wish to inspect has fired, because if another one
|
|
1251
|
exception that you wish to inspect has fired, because if another one
|
|
1252
|
occurs, it clobbers the previous one.
|
|
1252
|
occurs, it clobbers the previous one.
|
|
1253
|
|
|
1253
|
|
|
1254
|
If you want IPython to automatically do this on every exception, see
|
|
1254
|
If you want IPython to automatically do this on every exception, see
|
|
1255
|
the %pdb magic for more details.
|
|
1255
|
the %pdb magic for more details.
|
|
1256
|
"""
|
|
1256
|
"""
|
|
1257
|
self.shell.debugger(force=True)
|
|
1257
|
self.shell.debugger(force=True)
|
|
1258
|
|
|
1258
|
|
|
1259
|
@testdec.skip_doctest
|
|
1259
|
@testdec.skip_doctest
|
|
1260
|
def magic_prun(self, parameter_s ='',user_mode=1,
|
|
1260
|
def magic_prun(self, parameter_s ='',user_mode=1,
|
|
1261
|
opts=None,arg_lst=None,prog_ns=None):
|
|
1261
|
opts=None,arg_lst=None,prog_ns=None):
|
|
1262
|
|
|
1262
|
|
|
1263
|
"""Run a statement through the python code profiler.
|
|
1263
|
"""Run a statement through the python code profiler.
|
|
1264
|
|
|
1264
|
|
|
1265
|
Usage:
|
|
1265
|
Usage:
|
|
1266
|
%prun [options] statement
|
|
1266
|
%prun [options] statement
|
|
1267
|
|
|
1267
|
|
|
1268
|
The given statement (which doesn't require quote marks) is run via the
|
|
1268
|
The given statement (which doesn't require quote marks) is run via the
|
|
1269
|
python profiler in a manner similar to the profile.run() function.
|
|
1269
|
python profiler in a manner similar to the profile.run() function.
|
|
1270
|
Namespaces are internally managed to work correctly; profile.run
|
|
1270
|
Namespaces are internally managed to work correctly; profile.run
|
|
1271
|
cannot be used in IPython because it makes certain assumptions about
|
|
1271
|
cannot be used in IPython because it makes certain assumptions about
|
|
1272
|
namespaces which do not hold under IPython.
|
|
1272
|
namespaces which do not hold under IPython.
|
|
1273
|
|
|
1273
|
|
|
1274
|
Options:
|
|
1274
|
Options:
|
|
1275
|
|
|
1275
|
|
|
1276
|
-l <limit>: you can place restrictions on what or how much of the
|
|
1276
|
-l <limit>: you can place restrictions on what or how much of the
|
|
1277
|
profile gets printed. The limit value can be:
|
|
1277
|
profile gets printed. The limit value can be:
|
|
1278
|
|
|
1278
|
|
|
1279
|
* A string: only information for function names containing this string
|
|
1279
|
* A string: only information for function names containing this string
|
|
1280
|
is printed.
|
|
1280
|
is printed.
|
|
1281
|
|
|
1281
|
|
|
1282
|
* An integer: only these many lines are printed.
|
|
1282
|
* An integer: only these many lines are printed.
|
|
1283
|
|
|
1283
|
|
|
1284
|
* A float (between 0 and 1): this fraction of the report is printed
|
|
1284
|
* A float (between 0 and 1): this fraction of the report is printed
|
|
1285
|
(for example, use a limit of 0.4 to see the topmost 40% only).
|
|
1285
|
(for example, use a limit of 0.4 to see the topmost 40% only).
|
|
1286
|
|
|
1286
|
|
|
1287
|
You can combine several limits with repeated use of the option. For
|
|
1287
|
You can combine several limits with repeated use of the option. For
|
|
1288
|
example, '-l __init__ -l 5' will print only the topmost 5 lines of
|
|
1288
|
example, '-l __init__ -l 5' will print only the topmost 5 lines of
|
|
1289
|
information about class constructors.
|
|
1289
|
information about class constructors.
|
|
1290
|
|
|
1290
|
|
|
1291
|
-r: return the pstats.Stats object generated by the profiling. This
|
|
1291
|
-r: return the pstats.Stats object generated by the profiling. This
|
|
1292
|
object has all the information about the profile in it, and you can
|
|
1292
|
object has all the information about the profile in it, and you can
|
|
1293
|
later use it for further analysis or in other functions.
|
|
1293
|
later use it for further analysis or in other functions.
|
|
1294
|
|
|
1294
|
|
|
1295
|
-s <key>: sort profile by given key. You can provide more than one key
|
|
1295
|
-s <key>: sort profile by given key. You can provide more than one key
|
|
1296
|
by using the option several times: '-s key1 -s key2 -s key3...'. The
|
|
1296
|
by using the option several times: '-s key1 -s key2 -s key3...'. The
|
|
1297
|
default sorting key is 'time'.
|
|
1297
|
default sorting key is 'time'.
|
|
1298
|
|
|
1298
|
|
|
1299
|
The following is copied verbatim from the profile documentation
|
|
1299
|
The following is copied verbatim from the profile documentation
|
|
1300
|
referenced below:
|
|
1300
|
referenced below:
|
|
1301
|
|
|
1301
|
|
|
1302
|
When more than one key is provided, additional keys are used as
|
|
1302
|
When more than one key is provided, additional keys are used as
|
|
1303
|
secondary criteria when the there is equality in all keys selected
|
|
1303
|
secondary criteria when the there is equality in all keys selected
|
|
1304
|
before them.
|
|
1304
|
before them.
|
|
1305
|
|
|
1305
|
|
|
1306
|
Abbreviations can be used for any key names, as long as the
|
|
1306
|
Abbreviations can be used for any key names, as long as the
|
|
1307
|
abbreviation is unambiguous. The following are the keys currently
|
|
1307
|
abbreviation is unambiguous. The following are the keys currently
|
|
1308
|
defined:
|
|
1308
|
defined:
|
|
1309
|
|
|
1309
|
|
|
1310
|
Valid Arg Meaning
|
|
1310
|
Valid Arg Meaning
|
|
1311
|
"calls" call count
|
|
1311
|
"calls" call count
|
|
1312
|
"cumulative" cumulative time
|
|
1312
|
"cumulative" cumulative time
|
|
1313
|
"file" file name
|
|
1313
|
"file" file name
|
|
1314
|
"module" file name
|
|
1314
|
"module" file name
|
|
1315
|
"pcalls" primitive call count
|
|
1315
|
"pcalls" primitive call count
|
|
1316
|
"line" line number
|
|
1316
|
"line" line number
|
|
1317
|
"name" function name
|
|
1317
|
"name" function name
|
|
1318
|
"nfl" name/file/line
|
|
1318
|
"nfl" name/file/line
|
|
1319
|
"stdname" standard name
|
|
1319
|
"stdname" standard name
|
|
1320
|
"time" internal time
|
|
1320
|
"time" internal time
|
|
1321
|
|
|
1321
|
|
|
1322
|
Note that all sorts on statistics are in descending order (placing
|
|
1322
|
Note that all sorts on statistics are in descending order (placing
|
|
1323
|
most time consuming items first), where as name, file, and line number
|
|
1323
|
most time consuming items first), where as name, file, and line number
|
|
1324
|
searches are in ascending order (i.e., alphabetical). The subtle
|
|
1324
|
searches are in ascending order (i.e., alphabetical). The subtle
|
|
1325
|
distinction between "nfl" and "stdname" is that the standard name is a
|
|
1325
|
distinction between "nfl" and "stdname" is that the standard name is a
|
|
1326
|
sort of the name as printed, which means that the embedded line
|
|
1326
|
sort of the name as printed, which means that the embedded line
|
|
1327
|
numbers get compared in an odd way. For example, lines 3, 20, and 40
|
|
1327
|
numbers get compared in an odd way. For example, lines 3, 20, and 40
|
|
1328
|
would (if the file names were the same) appear in the string order
|
|
1328
|
would (if the file names were the same) appear in the string order
|
|
1329
|
"20" "3" and "40". In contrast, "nfl" does a numeric compare of the
|
|
1329
|
"20" "3" and "40". In contrast, "nfl" does a numeric compare of the
|
|
1330
|
line numbers. In fact, sort_stats("nfl") is the same as
|
|
1330
|
line numbers. In fact, sort_stats("nfl") is the same as
|
|
1331
|
sort_stats("name", "file", "line").
|
|
1331
|
sort_stats("name", "file", "line").
|
|
1332
|
|
|
1332
|
|
|
1333
|
-T <filename>: save profile results as shown on screen to a text
|
|
1333
|
-T <filename>: save profile results as shown on screen to a text
|
|
1334
|
file. The profile is still shown on screen.
|
|
1334
|
file. The profile is still shown on screen.
|
|
1335
|
|
|
1335
|
|
|
1336
|
-D <filename>: save (via dump_stats) profile statistics to given
|
|
1336
|
-D <filename>: save (via dump_stats) profile statistics to given
|
|
1337
|
filename. This data is in a format understod by the pstats module, and
|
|
1337
|
filename. This data is in a format understod by the pstats module, and
|
|
1338
|
is generated by a call to the dump_stats() method of profile
|
|
1338
|
is generated by a call to the dump_stats() method of profile
|
|
1339
|
objects. The profile is still shown on screen.
|
|
1339
|
objects. The profile is still shown on screen.
|
|
1340
|
|
|
1340
|
|
|
1341
|
If you want to run complete programs under the profiler's control, use
|
|
1341
|
If you want to run complete programs under the profiler's control, use
|
|
1342
|
'%run -p [prof_opts] filename.py [args to program]' where prof_opts
|
|
1342
|
'%run -p [prof_opts] filename.py [args to program]' where prof_opts
|
|
1343
|
contains profiler specific options as described here.
|
|
1343
|
contains profiler specific options as described here.
|
|
1344
|
|
|
1344
|
|
|
1345
|
You can read the complete documentation for the profile module with::
|
|
1345
|
You can read the complete documentation for the profile module with::
|
|
1346
|
|
|
1346
|
|
|
1347
|
In [1]: import profile; profile.help()
|
|
1347
|
In [1]: import profile; profile.help()
|
|
1348
|
"""
|
|
1348
|
"""
|
|
1349
|
|
|
1349
|
|
|
1350
|
opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
|
|
1350
|
opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
|
|
1351
|
# protect user quote marks
|
|
1351
|
# protect user quote marks
|
|
1352
|
parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
|
|
1352
|
parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
|
|
1353
|
|
|
1353
|
|
|
1354
|
if user_mode: # regular user call
|
|
1354
|
if user_mode: # regular user call
|
|
1355
|
opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
|
|
1355
|
opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
|
|
1356
|
list_all=1)
|
|
1356
|
list_all=1)
|
|
1357
|
namespace = self.shell.user_ns
|
|
1357
|
namespace = self.shell.user_ns
|
|
1358
|
else: # called to run a program by %run -p
|
|
1358
|
else: # called to run a program by %run -p
|
|
1359
|
try:
|
|
1359
|
try:
|
|
1360
|
filename = get_py_filename(arg_lst[0])
|
|
1360
|
filename = get_py_filename(arg_lst[0])
|
|
1361
|
except IOError,msg:
|
|
1361
|
except IOError,msg:
|
|
1362
|
error(msg)
|
|
1362
|
error(msg)
|
|
1363
|
return
|
|
1363
|
return
|
|
1364
|
|
|
1364
|
|
|
1365
|
arg_str = 'execfile(filename,prog_ns)'
|
|
1365
|
arg_str = 'execfile(filename,prog_ns)'
|
|
1366
|
namespace = locals()
|
|
1366
|
namespace = locals()
|
|
1367
|
|
|
1367
|
|
|
1368
|
opts.merge(opts_def)
|
|
1368
|
opts.merge(opts_def)
|
|
1369
|
|
|
1369
|
|
|
1370
|
prof = profile.Profile()
|
|
1370
|
prof = profile.Profile()
|
|
1371
|
try:
|
|
1371
|
try:
|
|
1372
|
prof = prof.runctx(arg_str,namespace,namespace)
|
|
1372
|
prof = prof.runctx(arg_str,namespace,namespace)
|
|
1373
|
sys_exit = ''
|
|
1373
|
sys_exit = ''
|
|
1374
|
except SystemExit:
|
|
1374
|
except SystemExit:
|
|
1375
|
sys_exit = """*** SystemExit exception caught in code being profiled."""
|
|
1375
|
sys_exit = """*** SystemExit exception caught in code being profiled."""
|
|
1376
|
|
|
1376
|
|
|
1377
|
stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
|
|
1377
|
stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
|
|
1378
|
|
|
1378
|
|
|
1379
|
lims = opts.l
|
|
1379
|
lims = opts.l
|
|
1380
|
if lims:
|
|
1380
|
if lims:
|
|
1381
|
lims = [] # rebuild lims with ints/floats/strings
|
|
1381
|
lims = [] # rebuild lims with ints/floats/strings
|
|
1382
|
for lim in opts.l:
|
|
1382
|
for lim in opts.l:
|
|
1383
|
try:
|
|
1383
|
try:
|
|
1384
|
lims.append(int(lim))
|
|
1384
|
lims.append(int(lim))
|
|
1385
|
except ValueError:
|
|
1385
|
except ValueError:
|
|
1386
|
try:
|
|
1386
|
try:
|
|
1387
|
lims.append(float(lim))
|
|
1387
|
lims.append(float(lim))
|
|
1388
|
except ValueError:
|
|
1388
|
except ValueError:
|
|
1389
|
lims.append(lim)
|
|
1389
|
lims.append(lim)
|
|
1390
|
|
|
1390
|
|
|
1391
|
# Trap output.
|
|
1391
|
# Trap output.
|
|
1392
|
stdout_trap = StringIO()
|
|
1392
|
stdout_trap = StringIO()
|
|
1393
|
|
|
1393
|
|
|
1394
|
if hasattr(stats,'stream'):
|
|
1394
|
if hasattr(stats,'stream'):
|
|
1395
|
# In newer versions of python, the stats object has a 'stream'
|
|
1395
|
# In newer versions of python, the stats object has a 'stream'
|
|
1396
|
# attribute to write into.
|
|
1396
|
# attribute to write into.
|
|
1397
|
stats.stream = stdout_trap
|
|
1397
|
stats.stream = stdout_trap
|
|
1398
|
stats.print_stats(*lims)
|
|
1398
|
stats.print_stats(*lims)
|
|
1399
|
else:
|
|
1399
|
else:
|
|
1400
|
# For older versions, we manually redirect stdout during printing
|
|
1400
|
# For older versions, we manually redirect stdout during printing
|
|
1401
|
sys_stdout = sys.stdout
|
|
1401
|
sys_stdout = sys.stdout
|
|
1402
|
try:
|
|
1402
|
try:
|
|
1403
|
sys.stdout = stdout_trap
|
|
1403
|
sys.stdout = stdout_trap
|
|
1404
|
stats.print_stats(*lims)
|
|
1404
|
stats.print_stats(*lims)
|
|
1405
|
finally:
|
|
1405
|
finally:
|
|
1406
|
sys.stdout = sys_stdout
|
|
1406
|
sys.stdout = sys_stdout
|
|
1407
|
|
|
1407
|
|
|
1408
|
output = stdout_trap.getvalue()
|
|
1408
|
output = stdout_trap.getvalue()
|
|
1409
|
output = output.rstrip()
|
|
1409
|
output = output.rstrip()
|
|
1410
|
|
|
1410
|
|
|
1411
|
page.page(output)
|
|
1411
|
page.page(output)
|
|
1412
|
print sys_exit,
|
|
1412
|
print sys_exit,
|
|
1413
|
|
|
1413
|
|
|
1414
|
dump_file = opts.D[0]
|
|
1414
|
dump_file = opts.D[0]
|
|
1415
|
text_file = opts.T[0]
|
|
1415
|
text_file = opts.T[0]
|
|
1416
|
if dump_file:
|
|
1416
|
if dump_file:
|
|
1417
|
prof.dump_stats(dump_file)
|
|
1417
|
prof.dump_stats(dump_file)
|
|
1418
|
print '\n*** Profile stats marshalled to file',\
|
|
1418
|
print '\n*** Profile stats marshalled to file',\
|
|
1419
|
`dump_file`+'.',sys_exit
|
|
1419
|
`dump_file`+'.',sys_exit
|
|
1420
|
if text_file:
|
|
1420
|
if text_file:
|
|
1421
|
pfile = file(text_file,'w')
|
|
1421
|
pfile = file(text_file,'w')
|
|
1422
|
pfile.write(output)
|
|
1422
|
pfile.write(output)
|
|
1423
|
pfile.close()
|
|
1423
|
pfile.close()
|
|
1424
|
print '\n*** Profile printout saved to text file',\
|
|
1424
|
print '\n*** Profile printout saved to text file',\
|
|
1425
|
`text_file`+'.',sys_exit
|
|
1425
|
`text_file`+'.',sys_exit
|
|
1426
|
|
|
1426
|
|
|
1427
|
if opts.has_key('r'):
|
|
1427
|
if opts.has_key('r'):
|
|
1428
|
return stats
|
|
1428
|
return stats
|
|
1429
|
else:
|
|
1429
|
else:
|
|
1430
|
return None
|
|
1430
|
return None
|
|
1431
|
|
|
1431
|
|
|
1432
|
@testdec.skip_doctest
|
|
1432
|
@testdec.skip_doctest
|
|
1433
|
def magic_run(self, parameter_s ='',runner=None,
|
|
1433
|
def magic_run(self, parameter_s ='',runner=None,
|
|
1434
|
file_finder=get_py_filename):
|
|
1434
|
file_finder=get_py_filename):
|
|
1435
|
"""Run the named file inside IPython as a program.
|
|
1435
|
"""Run the named file inside IPython as a program.
|
|
1436
|
|
|
1436
|
|
|
1437
|
Usage:\\
|
|
1437
|
Usage:\\
|
|
1438
|
%run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
|
|
1438
|
%run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
|
|
1439
|
|
|
1439
|
|
|
1440
|
Parameters after the filename are passed as command-line arguments to
|
|
1440
|
Parameters after the filename are passed as command-line arguments to
|
|
1441
|
the program (put in sys.argv). Then, control returns to IPython's
|
|
1441
|
the program (put in sys.argv). Then, control returns to IPython's
|
|
1442
|
prompt.
|
|
1442
|
prompt.
|
|
1443
|
|
|
1443
|
|
|
1444
|
This is similar to running at a system prompt:\\
|
|
1444
|
This is similar to running at a system prompt:\\
|
|
1445
|
$ python file args\\
|
|
1445
|
$ python file args\\
|
|
1446
|
but with the advantage of giving you IPython's tracebacks, and of
|
|
1446
|
but with the advantage of giving you IPython's tracebacks, and of
|
|
1447
|
loading all variables into your interactive namespace for further use
|
|
1447
|
loading all variables into your interactive namespace for further use
|
|
1448
|
(unless -p is used, see below).
|
|
1448
|
(unless -p is used, see below).
|
|
1449
|
|
|
1449
|
|
|
1450
|
The file is executed in a namespace initially consisting only of
|
|
1450
|
The file is executed in a namespace initially consisting only of
|
|
1451
|
__name__=='__main__' and sys.argv constructed as indicated. It thus
|
|
1451
|
__name__=='__main__' and sys.argv constructed as indicated. It thus
|
|
1452
|
sees its environment as if it were being run as a stand-alone program
|
|
1452
|
sees its environment as if it were being run as a stand-alone program
|
|
1453
|
(except for sharing global objects such as previously imported
|
|
1453
|
(except for sharing global objects such as previously imported
|
|
1454
|
modules). But after execution, the IPython interactive namespace gets
|
|
1454
|
modules). But after execution, the IPython interactive namespace gets
|
|
1455
|
updated with all variables defined in the program (except for __name__
|
|
1455
|
updated with all variables defined in the program (except for __name__
|
|
1456
|
and sys.argv). This allows for very convenient loading of code for
|
|
1456
|
and sys.argv). This allows for very convenient loading of code for
|
|
1457
|
interactive work, while giving each program a 'clean sheet' to run in.
|
|
1457
|
interactive work, while giving each program a 'clean sheet' to run in.
|
|
1458
|
|
|
1458
|
|
|
1459
|
Options:
|
|
1459
|
Options:
|
|
1460
|
|
|
1460
|
|
|
1461
|
-n: __name__ is NOT set to '__main__', but to the running file's name
|
|
1461
|
-n: __name__ is NOT set to '__main__', but to the running file's name
|
|
1462
|
without extension (as python does under import). This allows running
|
|
1462
|
without extension (as python does under import). This allows running
|
|
1463
|
scripts and reloading the definitions in them without calling code
|
|
1463
|
scripts and reloading the definitions in them without calling code
|
|
1464
|
protected by an ' if __name__ == "__main__" ' clause.
|
|
1464
|
protected by an ' if __name__ == "__main__" ' clause.
|
|
1465
|
|
|
1465
|
|
|
1466
|
-i: run the file in IPython's namespace instead of an empty one. This
|
|
1466
|
-i: run the file in IPython's namespace instead of an empty one. This
|
|
1467
|
is useful if you are experimenting with code written in a text editor
|
|
1467
|
is useful if you are experimenting with code written in a text editor
|
|
1468
|
which depends on variables defined interactively.
|
|
1468
|
which depends on variables defined interactively.
|
|
1469
|
|
|
1469
|
|
|
1470
|
-e: ignore sys.exit() calls or SystemExit exceptions in the script
|
|
1470
|
-e: ignore sys.exit() calls or SystemExit exceptions in the script
|
|
1471
|
being run. This is particularly useful if IPython is being used to
|
|
1471
|
being run. This is particularly useful if IPython is being used to
|
|
1472
|
run unittests, which always exit with a sys.exit() call. In such
|
|
1472
|
run unittests, which always exit with a sys.exit() call. In such
|
|
1473
|
cases you are interested in the output of the test results, not in
|
|
1473
|
cases you are interested in the output of the test results, not in
|
|
1474
|
seeing a traceback of the unittest module.
|
|
1474
|
seeing a traceback of the unittest module.
|
|
1475
|
|
|
1475
|
|
|
1476
|
-t: print timing information at the end of the run. IPython will give
|
|
1476
|
-t: print timing information at the end of the run. IPython will give
|
|
1477
|
you an estimated CPU time consumption for your script, which under
|
|
1477
|
you an estimated CPU time consumption for your script, which under
|
|
1478
|
Unix uses the resource module to avoid the wraparound problems of
|
|
1478
|
Unix uses the resource module to avoid the wraparound problems of
|
|
1479
|
time.clock(). Under Unix, an estimate of time spent on system tasks
|
|
1479
|
time.clock(). Under Unix, an estimate of time spent on system tasks
|
|
1480
|
is also given (for Windows platforms this is reported as 0.0).
|
|
1480
|
is also given (for Windows platforms this is reported as 0.0).
|
|
1481
|
|
|
1481
|
|
|
1482
|
If -t is given, an additional -N<N> option can be given, where <N>
|
|
1482
|
If -t is given, an additional -N<N> option can be given, where <N>
|
|
1483
|
must be an integer indicating how many times you want the script to
|
|
1483
|
must be an integer indicating how many times you want the script to
|
|
1484
|
run. The final timing report will include total and per run results.
|
|
1484
|
run. The final timing report will include total and per run results.
|
|
1485
|
|
|
1485
|
|
|
1486
|
For example (testing the script uniq_stable.py):
|
|
1486
|
For example (testing the script uniq_stable.py):
|
|
1487
|
|
|
1487
|
|
|
1488
|
In [1]: run -t uniq_stable
|
|
1488
|
In [1]: run -t uniq_stable
|
|
1489
|
|
|
1489
|
|
|
1490
|
IPython CPU timings (estimated):\\
|
|
1490
|
IPython CPU timings (estimated):\\
|
|
1491
|
User : 0.19597 s.\\
|
|
1491
|
User : 0.19597 s.\\
|
|
1492
|
System: 0.0 s.\\
|
|
1492
|
System: 0.0 s.\\
|
|
1493
|
|
|
1493
|
|
|
1494
|
In [2]: run -t -N5 uniq_stable
|
|
1494
|
In [2]: run -t -N5 uniq_stable
|
|
1495
|
|
|
1495
|
|
|
1496
|
IPython CPU timings (estimated):\\
|
|
1496
|
IPython CPU timings (estimated):\\
|
|
1497
|
Total runs performed: 5\\
|
|
1497
|
Total runs performed: 5\\
|
|
1498
|
Times : Total Per run\\
|
|
1498
|
Times : Total Per run\\
|
|
1499
|
User : 0.910862 s, 0.1821724 s.\\
|
|
1499
|
User : 0.910862 s, 0.1821724 s.\\
|
|
1500
|
System: 0.0 s, 0.0 s.
|
|
1500
|
System: 0.0 s, 0.0 s.
|
|
1501
|
|
|
1501
|
|
|
1502
|
-d: run your program under the control of pdb, the Python debugger.
|
|
1502
|
-d: run your program under the control of pdb, the Python debugger.
|
|
1503
|
This allows you to execute your program step by step, watch variables,
|
|
1503
|
This allows you to execute your program step by step, watch variables,
|
|
1504
|
etc. Internally, what IPython does is similar to calling:
|
|
1504
|
etc. Internally, what IPython does is similar to calling:
|
|
1505
|
|
|
1505
|
|
|
1506
|
pdb.run('execfile("YOURFILENAME")')
|
|
1506
|
pdb.run('execfile("YOURFILENAME")')
|
|
1507
|
|
|
1507
|
|
|
1508
|
with a breakpoint set on line 1 of your file. You can change the line
|
|
1508
|
with a breakpoint set on line 1 of your file. You can change the line
|
|
1509
|
number for this automatic breakpoint to be <N> by using the -bN option
|
|
1509
|
number for this automatic breakpoint to be <N> by using the -bN option
|
|
1510
|
(where N must be an integer). For example:
|
|
1510
|
(where N must be an integer). For example:
|
|
1511
|
|
|
1511
|
|
|
1512
|
%run -d -b40 myscript
|
|
1512
|
%run -d -b40 myscript
|
|
1513
|
|
|
1513
|
|
|
1514
|
will set the first breakpoint at line 40 in myscript.py. Note that
|
|
1514
|
will set the first breakpoint at line 40 in myscript.py. Note that
|
|
1515
|
the first breakpoint must be set on a line which actually does
|
|
1515
|
the first breakpoint must be set on a line which actually does
|
|
1516
|
something (not a comment or docstring) for it to stop execution.
|
|
1516
|
something (not a comment or docstring) for it to stop execution.
|
|
1517
|
|
|
1517
|
|
|
1518
|
When the pdb debugger starts, you will see a (Pdb) prompt. You must
|
|
1518
|
When the pdb debugger starts, you will see a (Pdb) prompt. You must
|
|
1519
|
first enter 'c' (without qoutes) to start execution up to the first
|
|
1519
|
first enter 'c' (without qoutes) to start execution up to the first
|
|
1520
|
breakpoint.
|
|
1520
|
breakpoint.
|
|
1521
|
|
|
1521
|
|
|
1522
|
Entering 'help' gives information about the use of the debugger. You
|
|
1522
|
Entering 'help' gives information about the use of the debugger. You
|
|
1523
|
can easily see pdb's full documentation with "import pdb;pdb.help()"
|
|
1523
|
can easily see pdb's full documentation with "import pdb;pdb.help()"
|
|
1524
|
at a prompt.
|
|
1524
|
at a prompt.
|
|
1525
|
|
|
1525
|
|
|
1526
|
-p: run program under the control of the Python profiler module (which
|
|
1526
|
-p: run program under the control of the Python profiler module (which
|
|
1527
|
prints a detailed report of execution times, function calls, etc).
|
|
1527
|
prints a detailed report of execution times, function calls, etc).
|
|
1528
|
|
|
1528
|
|
|
1529
|
You can pass other options after -p which affect the behavior of the
|
|
1529
|
You can pass other options after -p which affect the behavior of the
|
|
1530
|
profiler itself. See the docs for %prun for details.
|
|
1530
|
profiler itself. See the docs for %prun for details.
|
|
1531
|
|
|
1531
|
|
|
1532
|
In this mode, the program's variables do NOT propagate back to the
|
|
1532
|
In this mode, the program's variables do NOT propagate back to the
|
|
1533
|
IPython interactive namespace (because they remain in the namespace
|
|
1533
|
IPython interactive namespace (because they remain in the namespace
|
|
1534
|
where the profiler executes them).
|
|
1534
|
where the profiler executes them).
|
|
1535
|
|
|
1535
|
|
|
1536
|
Internally this triggers a call to %prun, see its documentation for
|
|
1536
|
Internally this triggers a call to %prun, see its documentation for
|
|
1537
|
details on the options available specifically for profiling.
|
|
1537
|
details on the options available specifically for profiling.
|
|
1538
|
|
|
1538
|
|
|
1539
|
There is one special usage for which the text above doesn't apply:
|
|
1539
|
There is one special usage for which the text above doesn't apply:
|
|
1540
|
if the filename ends with .ipy, the file is run as ipython script,
|
|
1540
|
if the filename ends with .ipy, the file is run as ipython script,
|
|
1541
|
just as if the commands were written on IPython prompt.
|
|
1541
|
just as if the commands were written on IPython prompt.
|
|
1542
|
"""
|
|
1542
|
"""
|
|
1543
|
|
|
1543
|
|
|
1544
|
# get arguments and set sys.argv for program to be run.
|
|
1544
|
# get arguments and set sys.argv for program to be run.
|
|
1545
|
opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
|
|
1545
|
opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
|
|
1546
|
mode='list',list_all=1)
|
|
1546
|
mode='list',list_all=1)
|
|
1547
|
|
|
1547
|
|
|
1548
|
try:
|
|
1548
|
try:
|
|
1549
|
filename = file_finder(arg_lst[0])
|
|
1549
|
filename = file_finder(arg_lst[0])
|
|
1550
|
except IndexError:
|
|
1550
|
except IndexError:
|
|
1551
|
warn('you must provide at least a filename.')
|
|
1551
|
warn('you must provide at least a filename.')
|
|
1552
|
print '\n%run:\n',oinspect.getdoc(self.magic_run)
|
|
1552
|
print '\n%run:\n',oinspect.getdoc(self.magic_run)
|
|
1553
|
return
|
|
1553
|
return
|
|
1554
|
except IOError,msg:
|
|
1554
|
except IOError,msg:
|
|
1555
|
error(msg)
|
|
1555
|
error(msg)
|
|
1556
|
return
|
|
1556
|
return
|
|
1557
|
|
|
1557
|
|
|
1558
|
if filename.lower().endswith('.ipy'):
|
|
1558
|
if filename.lower().endswith('.ipy'):
|
|
1559
|
self.shell.safe_execfile_ipy(filename)
|
|
1559
|
self.shell.safe_execfile_ipy(filename)
|
|
1560
|
return
|
|
1560
|
return
|
|
1561
|
|
|
1561
|
|
|
1562
|
# Control the response to exit() calls made by the script being run
|
|
1562
|
# Control the response to exit() calls made by the script being run
|
|
1563
|
exit_ignore = opts.has_key('e')
|
|
1563
|
exit_ignore = opts.has_key('e')
|
|
1564
|
|
|
1564
|
|
|
1565
|
# Make sure that the running script gets a proper sys.argv as if it
|
|
1565
|
# Make sure that the running script gets a proper sys.argv as if it
|
|
1566
|
# were run from a system shell.
|
|
1566
|
# were run from a system shell.
|
|
1567
|
save_argv = sys.argv # save it for later restoring
|
|
1567
|
save_argv = sys.argv # save it for later restoring
|
|
1568
|
sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
|
|
1568
|
sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
|
|
1569
|
|
|
1569
|
|
|
1570
|
if opts.has_key('i'):
|
|
1570
|
if opts.has_key('i'):
|
|
1571
|
# Run in user's interactive namespace
|
|
1571
|
# Run in user's interactive namespace
|
|
1572
|
prog_ns = self.shell.user_ns
|
|
1572
|
prog_ns = self.shell.user_ns
|
|
1573
|
__name__save = self.shell.user_ns['__name__']
|
|
1573
|
__name__save = self.shell.user_ns['__name__']
|
|
1574
|
prog_ns['__name__'] = '__main__'
|
|
1574
|
prog_ns['__name__'] = '__main__'
|
|
1575
|
main_mod = self.shell.new_main_mod(prog_ns)
|
|
1575
|
main_mod = self.shell.new_main_mod(prog_ns)
|
|
1576
|
else:
|
|
1576
|
else:
|
|
1577
|
# Run in a fresh, empty namespace
|
|
1577
|
# Run in a fresh, empty namespace
|
|
1578
|
if opts.has_key('n'):
|
|
1578
|
if opts.has_key('n'):
|
|
1579
|
name = os.path.splitext(os.path.basename(filename))[0]
|
|
1579
|
name = os.path.splitext(os.path.basename(filename))[0]
|
|
1580
|
else:
|
|
1580
|
else:
|
|
1581
|
name = '__main__'
|
|
1581
|
name = '__main__'
|
|
1582
|
|
|
1582
|
|
|
1583
|
main_mod = self.shell.new_main_mod()
|
|
1583
|
main_mod = self.shell.new_main_mod()
|
|
1584
|
prog_ns = main_mod.__dict__
|
|
1584
|
prog_ns = main_mod.__dict__
|
|
1585
|
prog_ns['__name__'] = name
|
|
1585
|
prog_ns['__name__'] = name
|
|
1586
|
|
|
1586
|
|
|
1587
|
# Since '%run foo' emulates 'python foo.py' at the cmd line, we must
|
|
1587
|
# Since '%run foo' emulates 'python foo.py' at the cmd line, we must
|
|
1588
|
# set the __file__ global in the script's namespace
|
|
1588
|
# set the __file__ global in the script's namespace
|
|
1589
|
prog_ns['__file__'] = filename
|
|
1589
|
prog_ns['__file__'] = filename
|
|
1590
|
|
|
1590
|
|
|
1591
|
# pickle fix. See interactiveshell for an explanation. But we need to make sure
|
|
1591
|
# pickle fix. See interactiveshell for an explanation. But we need to make sure
|
|
1592
|
# that, if we overwrite __main__, we replace it at the end
|
|
1592
|
# that, if we overwrite __main__, we replace it at the end
|
|
1593
|
main_mod_name = prog_ns['__name__']
|
|
1593
|
main_mod_name = prog_ns['__name__']
|
|
1594
|
|
|
1594
|
|
|
1595
|
if main_mod_name == '__main__':
|
|
1595
|
if main_mod_name == '__main__':
|
|
1596
|
restore_main = sys.modules['__main__']
|
|
1596
|
restore_main = sys.modules['__main__']
|
|
1597
|
else:
|
|
1597
|
else:
|
|
1598
|
restore_main = False
|
|
1598
|
restore_main = False
|
|
1599
|
|
|
1599
|
|
|
1600
|
# This needs to be undone at the end to prevent holding references to
|
|
1600
|
# This needs to be undone at the end to prevent holding references to
|
|
1601
|
# every single object ever created.
|
|
1601
|
# every single object ever created.
|
|
1602
|
sys.modules[main_mod_name] = main_mod
|
|
1602
|
sys.modules[main_mod_name] = main_mod
|
|
1603
|
|
|
1603
|
|
|
1604
|
stats = None
|
|
1604
|
stats = None
|
|
1605
|
try:
|
|
1605
|
try:
|
|
1606
|
self.shell.save_history()
|
|
1606
|
#self.shell.save_history()
|
|
1607
|
|
|
1607
|
|
|
1608
|
if opts.has_key('p'):
|
|
1608
|
if opts.has_key('p'):
|
|
1609
|
stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
|
|
1609
|
stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
|
|
1610
|
else:
|
|
1610
|
else:
|
|
1611
|
if opts.has_key('d'):
|
|
1611
|
if opts.has_key('d'):
|
|
1612
|
deb = debugger.Pdb(self.shell.colors)
|
|
1612
|
deb = debugger.Pdb(self.shell.colors)
|
|
1613
|
# reset Breakpoint state, which is moronically kept
|
|
1613
|
# reset Breakpoint state, which is moronically kept
|
|
1614
|
# in a class
|
|
1614
|
# in a class
|
|
1615
|
bdb.Breakpoint.next = 1
|
|
1615
|
bdb.Breakpoint.next = 1
|
|
1616
|
bdb.Breakpoint.bplist = {}
|
|
1616
|
bdb.Breakpoint.bplist = {}
|
|
1617
|
bdb.Breakpoint.bpbynumber = [None]
|
|
1617
|
bdb.Breakpoint.bpbynumber = [None]
|
|
1618
|
# Set an initial breakpoint to stop execution
|
|
1618
|
# Set an initial breakpoint to stop execution
|
|
1619
|
maxtries = 10
|
|
1619
|
maxtries = 10
|
|
1620
|
bp = int(opts.get('b',[1])[0])
|
|
1620
|
bp = int(opts.get('b',[1])[0])
|
|
1621
|
checkline = deb.checkline(filename,bp)
|
|
1621
|
checkline = deb.checkline(filename,bp)
|
|
1622
|
if not checkline:
|
|
1622
|
if not checkline:
|
|
1623
|
for bp in range(bp+1,bp+maxtries+1):
|
|
1623
|
for bp in range(bp+1,bp+maxtries+1):
|
|
1624
|
if deb.checkline(filename,bp):
|
|
1624
|
if deb.checkline(filename,bp):
|
|
1625
|
break
|
|
1625
|
break
|
|
1626
|
else:
|
|
1626
|
else:
|
|
1627
|
msg = ("\nI failed to find a valid line to set "
|
|
1627
|
msg = ("\nI failed to find a valid line to set "
|
|
1628
|
"a breakpoint\n"
|
|
1628
|
"a breakpoint\n"
|
|
1629
|
"after trying up to line: %s.\n"
|
|
1629
|
"after trying up to line: %s.\n"
|
|
1630
|
"Please set a valid breakpoint manually "
|
|
1630
|
"Please set a valid breakpoint manually "
|
|
1631
|
"with the -b option." % bp)
|
|
1631
|
"with the -b option." % bp)
|
|
1632
|
error(msg)
|
|
1632
|
error(msg)
|
|
1633
|
return
|
|
1633
|
return
|
|
1634
|
# if we find a good linenumber, set the breakpoint
|
|
1634
|
# if we find a good linenumber, set the breakpoint
|
|
1635
|
deb.do_break('%s:%s' % (filename,bp))
|
|
1635
|
deb.do_break('%s:%s' % (filename,bp))
|
|
1636
|
# Start file run
|
|
1636
|
# Start file run
|
|
1637
|
print "NOTE: Enter 'c' at the",
|
|
1637
|
print "NOTE: Enter 'c' at the",
|
|
1638
|
print "%s prompt to start your script." % deb.prompt
|
|
1638
|
print "%s prompt to start your script." % deb.prompt
|
|
1639
|
try:
|
|
1639
|
try:
|
|
1640
|
deb.run('execfile("%s")' % filename,prog_ns)
|
|
1640
|
deb.run('execfile("%s")' % filename,prog_ns)
|
|
1641
|
|
|
1641
|
|
|
1642
|
except:
|
|
1642
|
except:
|
|
1643
|
etype, value, tb = sys.exc_info()
|
|
1643
|
etype, value, tb = sys.exc_info()
|
|
1644
|
# Skip three frames in the traceback: the %run one,
|
|
1644
|
# Skip three frames in the traceback: the %run one,
|
|
1645
|
# one inside bdb.py, and the command-line typed by the
|
|
1645
|
# one inside bdb.py, and the command-line typed by the
|
|
1646
|
# user (run by exec in pdb itself).
|
|
1646
|
# user (run by exec in pdb itself).
|
|
1647
|
self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
|
|
1647
|
self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
|
|
1648
|
else:
|
|
1648
|
else:
|
|
1649
|
if runner is None:
|
|
1649
|
if runner is None:
|
|
1650
|
runner = self.shell.safe_execfile
|
|
1650
|
runner = self.shell.safe_execfile
|
|
1651
|
if opts.has_key('t'):
|
|
1651
|
if opts.has_key('t'):
|
|
1652
|
# timed execution
|
|
1652
|
# timed execution
|
|
1653
|
try:
|
|
1653
|
try:
|
|
1654
|
nruns = int(opts['N'][0])
|
|
1654
|
nruns = int(opts['N'][0])
|
|
1655
|
if nruns < 1:
|
|
1655
|
if nruns < 1:
|
|
1656
|
error('Number of runs must be >=1')
|
|
1656
|
error('Number of runs must be >=1')
|
|
1657
|
return
|
|
1657
|
return
|
|
1658
|
except (KeyError):
|
|
1658
|
except (KeyError):
|
|
1659
|
nruns = 1
|
|
1659
|
nruns = 1
|
|
1660
|
if nruns == 1:
|
|
1660
|
if nruns == 1:
|
|
1661
|
t0 = clock2()
|
|
1661
|
t0 = clock2()
|
|
1662
|
runner(filename,prog_ns,prog_ns,
|
|
1662
|
runner(filename,prog_ns,prog_ns,
|
|
1663
|
exit_ignore=exit_ignore)
|
|
1663
|
exit_ignore=exit_ignore)
|
|
1664
|
t1 = clock2()
|
|
1664
|
t1 = clock2()
|
|
1665
|
t_usr = t1[0]-t0[0]
|
|
1665
|
t_usr = t1[0]-t0[0]
|
|
1666
|
t_sys = t1[1]-t0[1]
|
|
1666
|
t_sys = t1[1]-t0[1]
|
|
1667
|
print "\nIPython CPU timings (estimated):"
|
|
1667
|
print "\nIPython CPU timings (estimated):"
|
|
1668
|
print " User : %10s s." % t_usr
|
|
1668
|
print " User : %10s s." % t_usr
|
|
1669
|
print " System: %10s s." % t_sys
|
|
1669
|
print " System: %10s s." % t_sys
|
|
1670
|
else:
|
|
1670
|
else:
|
|
1671
|
runs = range(nruns)
|
|
1671
|
runs = range(nruns)
|
|
1672
|
t0 = clock2()
|
|
1672
|
t0 = clock2()
|
|
1673
|
for nr in runs:
|
|
1673
|
for nr in runs:
|
|
1674
|
runner(filename,prog_ns,prog_ns,
|
|
1674
|
runner(filename,prog_ns,prog_ns,
|
|
1675
|
exit_ignore=exit_ignore)
|
|
1675
|
exit_ignore=exit_ignore)
|
|
1676
|
t1 = clock2()
|
|
1676
|
t1 = clock2()
|
|
1677
|
t_usr = t1[0]-t0[0]
|
|
1677
|
t_usr = t1[0]-t0[0]
|
|
1678
|
t_sys = t1[1]-t0[1]
|
|
1678
|
t_sys = t1[1]-t0[1]
|
|
1679
|
print "\nIPython CPU timings (estimated):"
|
|
1679
|
print "\nIPython CPU timings (estimated):"
|
|
1680
|
print "Total runs performed:",nruns
|
|
1680
|
print "Total runs performed:",nruns
|
|
1681
|
print " Times : %10s %10s" % ('Total','Per run')
|
|
1681
|
print " Times : %10s %10s" % ('Total','Per run')
|
|
1682
|
print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
|
|
1682
|
print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
|
|
1683
|
print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
|
|
1683
|
print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
|
|
1684
|
|
|
1684
|
|
|
1685
|
else:
|
|
1685
|
else:
|
|
1686
|
# regular execution
|
|
1686
|
# regular execution
|
|
1687
|
runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
|
|
1687
|
runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
|
|
1688
|
|
|
1688
|
|
|
1689
|
if opts.has_key('i'):
|
|
1689
|
if opts.has_key('i'):
|
|
1690
|
self.shell.user_ns['__name__'] = __name__save
|
|
1690
|
self.shell.user_ns['__name__'] = __name__save
|
|
1691
|
else:
|
|
1691
|
else:
|
|
1692
|
# The shell MUST hold a reference to prog_ns so after %run
|
|
1692
|
# The shell MUST hold a reference to prog_ns so after %run
|
|
1693
|
# exits, the python deletion mechanism doesn't zero it out
|
|
1693
|
# exits, the python deletion mechanism doesn't zero it out
|
|
1694
|
# (leaving dangling references).
|
|
1694
|
# (leaving dangling references).
|
|
1695
|
self.shell.cache_main_mod(prog_ns,filename)
|
|
1695
|
self.shell.cache_main_mod(prog_ns,filename)
|
|
1696
|
# update IPython interactive namespace
|
|
1696
|
# update IPython interactive namespace
|
|
1697
|
|
|
1697
|
|
|
1698
|
# Some forms of read errors on the file may mean the
|
|
1698
|
# Some forms of read errors on the file may mean the
|
|
1699
|
# __name__ key was never set; using pop we don't have to
|
|
1699
|
# __name__ key was never set; using pop we don't have to
|
|
1700
|
# worry about a possible KeyError.
|
|
1700
|
# worry about a possible KeyError.
|
|
1701
|
prog_ns.pop('__name__', None)
|
|
1701
|
prog_ns.pop('__name__', None)
|
|
1702
|
|
|
1702
|
|
|
1703
|
self.shell.user_ns.update(prog_ns)
|
|
1703
|
self.shell.user_ns.update(prog_ns)
|
|
1704
|
finally:
|
|
1704
|
finally:
|
|
1705
|
# It's a bit of a mystery why, but __builtins__ can change from
|
|
1705
|
# It's a bit of a mystery why, but __builtins__ can change from
|
|
1706
|
# being a module to becoming a dict missing some key data after
|
|
1706
|
# being a module to becoming a dict missing some key data after
|
|
1707
|
# %run. As best I can see, this is NOT something IPython is doing
|
|
1707
|
# %run. As best I can see, this is NOT something IPython is doing
|
|
1708
|
# at all, and similar problems have been reported before:
|
|
1708
|
# at all, and similar problems have been reported before:
|
|
1709
|
# http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
|
|
1709
|
# http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
|
|
1710
|
# Since this seems to be done by the interpreter itself, the best
|
|
1710
|
# Since this seems to be done by the interpreter itself, the best
|
|
1711
|
# we can do is to at least restore __builtins__ for the user on
|
|
1711
|
# we can do is to at least restore __builtins__ for the user on
|
|
1712
|
# exit.
|
|
1712
|
# exit.
|
|
1713
|
self.shell.user_ns['__builtins__'] = __builtin__
|
|
1713
|
self.shell.user_ns['__builtins__'] = __builtin__
|
|
1714
|
|
|
1714
|
|
|
1715
|
# Ensure key global structures are restored
|
|
1715
|
# Ensure key global structures are restored
|
|
1716
|
sys.argv = save_argv
|
|
1716
|
sys.argv = save_argv
|
|
1717
|
if restore_main:
|
|
1717
|
if restore_main:
|
|
1718
|
sys.modules['__main__'] = restore_main
|
|
1718
|
sys.modules['__main__'] = restore_main
|
|
1719
|
else:
|
|
1719
|
else:
|
|
1720
|
# Remove from sys.modules the reference to main_mod we'd
|
|
1720
|
# Remove from sys.modules the reference to main_mod we'd
|
|
1721
|
# added. Otherwise it will trap references to objects
|
|
1721
|
# added. Otherwise it will trap references to objects
|
|
1722
|
# contained therein.
|
|
1722
|
# contained therein.
|
|
1723
|
del sys.modules[main_mod_name]
|
|
1723
|
del sys.modules[main_mod_name]
|
|
1724
|
|
|
1724
|
|
|
1725
|
self.shell.reload_history()
|
|
1725
|
#self.shell.reload_history()
|
|
1726
|
|
|
1726
|
|
|
1727
|
return stats
|
|
1727
|
return stats
|
|
1728
|
|
|
1728
|
|
|
1729
|
@testdec.skip_doctest
|
|
1729
|
@testdec.skip_doctest
|
|
1730
|
def magic_timeit(self, parameter_s =''):
|
|
1730
|
def magic_timeit(self, parameter_s =''):
|
|
1731
|
"""Time execution of a Python statement or expression
|
|
1731
|
"""Time execution of a Python statement or expression
|
|
1732
|
|
|
1732
|
|
|
1733
|
Usage:\\
|
|
1733
|
Usage:\\
|
|
1734
|
%timeit [-n<N> -r<R> [-t|-c]] statement
|
|
1734
|
%timeit [-n<N> -r<R> [-t|-c]] statement
|
|
1735
|
|
|
1735
|
|
|
1736
|
Time execution of a Python statement or expression using the timeit
|
|
1736
|
Time execution of a Python statement or expression using the timeit
|
|
1737
|
module.
|
|
1737
|
module.
|
|
1738
|
|
|
1738
|
|
|
1739
|
Options:
|
|
1739
|
Options:
|
|
1740
|
-n<N>: execute the given statement <N> times in a loop. If this value
|
|
1740
|
-n<N>: execute the given statement <N> times in a loop. If this value
|
|
1741
|
is not given, a fitting value is chosen.
|
|
1741
|
is not given, a fitting value is chosen.
|
|
1742
|
|
|
1742
|
|
|
1743
|
-r<R>: repeat the loop iteration <R> times and take the best result.
|
|
1743
|
-r<R>: repeat the loop iteration <R> times and take the best result.
|
|
1744
|
Default: 3
|
|
1744
|
Default: 3
|
|
1745
|
|
|
1745
|
|
|
1746
|
-t: use time.time to measure the time, which is the default on Unix.
|
|
1746
|
-t: use time.time to measure the time, which is the default on Unix.
|
|
1747
|
This function measures wall time.
|
|
1747
|
This function measures wall time.
|
|
1748
|
|
|
1748
|
|
|
1749
|
-c: use time.clock to measure the time, which is the default on
|
|
1749
|
-c: use time.clock to measure the time, which is the default on
|
|
1750
|
Windows and measures wall time. On Unix, resource.getrusage is used
|
|
1750
|
Windows and measures wall time. On Unix, resource.getrusage is used
|
|
1751
|
instead and returns the CPU user time.
|
|
1751
|
instead and returns the CPU user time.
|
|
1752
|
|
|
1752
|
|
|
1753
|
-p<P>: use a precision of <P> digits to display the timing result.
|
|
1753
|
-p<P>: use a precision of <P> digits to display the timing result.
|
|
1754
|
Default: 3
|
|
1754
|
Default: 3
|
|
1755
|
|
|
1755
|
|
|
1756
|
|
|
1756
|
|
|
1757
|
Examples:
|
|
1757
|
Examples:
|
|
1758
|
|
|
1758
|
|
|
1759
|
In [1]: %timeit pass
|
|
1759
|
In [1]: %timeit pass
|
|
1760
|
10000000 loops, best of 3: 53.3 ns per loop
|
|
1760
|
10000000 loops, best of 3: 53.3 ns per loop
|
|
1761
|
|
|
1761
|
|
|
1762
|
In [2]: u = None
|
|
1762
|
In [2]: u = None
|
|
1763
|
|
|
1763
|
|
|
1764
|
In [3]: %timeit u is None
|
|
1764
|
In [3]: %timeit u is None
|
|
1765
|
10000000 loops, best of 3: 184 ns per loop
|
|
1765
|
10000000 loops, best of 3: 184 ns per loop
|
|
1766
|
|
|
1766
|
|
|
1767
|
In [4]: %timeit -r 4 u == None
|
|
1767
|
In [4]: %timeit -r 4 u == None
|
|
1768
|
1000000 loops, best of 4: 242 ns per loop
|
|
1768
|
1000000 loops, best of 4: 242 ns per loop
|
|
1769
|
|
|
1769
|
|
|
1770
|
In [5]: import time
|
|
1770
|
In [5]: import time
|
|
1771
|
|
|
1771
|
|
|
1772
|
In [6]: %timeit -n1 time.sleep(2)
|
|
1772
|
In [6]: %timeit -n1 time.sleep(2)
|
|
1773
|
1 loops, best of 3: 2 s per loop
|
|
1773
|
1 loops, best of 3: 2 s per loop
|
|
1774
|
|
|
1774
|
|
|
1775
|
|
|
1775
|
|
|
1776
|
The times reported by %timeit will be slightly higher than those
|
|
1776
|
The times reported by %timeit will be slightly higher than those
|
|
1777
|
reported by the timeit.py script when variables are accessed. This is
|
|
1777
|
reported by the timeit.py script when variables are accessed. This is
|
|
1778
|
due to the fact that %timeit executes the statement in the namespace
|
|
1778
|
due to the fact that %timeit executes the statement in the namespace
|
|
1779
|
of the shell, compared with timeit.py, which uses a single setup
|
|
1779
|
of the shell, compared with timeit.py, which uses a single setup
|
|
1780
|
statement to import function or create variables. Generally, the bias
|
|
1780
|
statement to import function or create variables. Generally, the bias
|
|
1781
|
does not matter as long as results from timeit.py are not mixed with
|
|
1781
|
does not matter as long as results from timeit.py are not mixed with
|
|
1782
|
those from %timeit."""
|
|
1782
|
those from %timeit."""
|
|
1783
|
|
|
1783
|
|
|
1784
|
import timeit
|
|
1784
|
import timeit
|
|
1785
|
import math
|
|
1785
|
import math
|
|
1786
|
|
|
1786
|
|
|
1787
|
# XXX: Unfortunately the unicode 'micro' symbol can cause problems in
|
|
1787
|
# XXX: Unfortunately the unicode 'micro' symbol can cause problems in
|
|
1788
|
# certain terminals. Until we figure out a robust way of
|
|
1788
|
# certain terminals. Until we figure out a robust way of
|
|
1789
|
# auto-detecting if the terminal can deal with it, use plain 'us' for
|
|
1789
|
# auto-detecting if the terminal can deal with it, use plain 'us' for
|
|
1790
|
# microseconds. I am really NOT happy about disabling the proper
|
|
1790
|
# microseconds. I am really NOT happy about disabling the proper
|
|
1791
|
# 'micro' prefix, but crashing is worse... If anyone knows what the
|
|
1791
|
# 'micro' prefix, but crashing is worse... If anyone knows what the
|
|
1792
|
# right solution for this is, I'm all ears...
|
|
1792
|
# right solution for this is, I'm all ears...
|
|
1793
|
#
|
|
1793
|
#
|
|
1794
|
# Note: using
|
|
1794
|
# Note: using
|
|
1795
|
#
|
|
1795
|
#
|
|
1796
|
# s = u'\xb5'
|
|
1796
|
# s = u'\xb5'
|
|
1797
|
# s.encode(sys.getdefaultencoding())
|
|
1797
|
# s.encode(sys.getdefaultencoding())
|
|
1798
|
#
|
|
1798
|
#
|
|
1799
|
# is not sufficient, as I've seen terminals where that fails but
|
|
1799
|
# is not sufficient, as I've seen terminals where that fails but
|
|
1800
|
# print s
|
|
1800
|
# print s
|
|
1801
|
#
|
|
1801
|
#
|
|
1802
|
# succeeds
|
|
1802
|
# succeeds
|
|
1803
|
#
|
|
1803
|
#
|
|
1804
|
# See bug: https://bugs.launchpad.net/ipython/+bug/348466
|
|
1804
|
# See bug: https://bugs.launchpad.net/ipython/+bug/348466
|
|
1805
|
|
|
1805
|
|
|
1806
|
#units = [u"s", u"ms",u'\xb5',"ns"]
|
|
1806
|
#units = [u"s", u"ms",u'\xb5',"ns"]
|
|
1807
|
units = [u"s", u"ms",u'us',"ns"]
|
|
1807
|
units = [u"s", u"ms",u'us',"ns"]
|
|
1808
|
|
|
1808
|
|
|
1809
|
scaling = [1, 1e3, 1e6, 1e9]
|
|
1809
|
scaling = [1, 1e3, 1e6, 1e9]
|
|
1810
|
|
|
1810
|
|
|
1811
|
opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
|
|
1811
|
opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
|
|
1812
|
posix=False)
|
|
1812
|
posix=False)
|
|
1813
|
if stmt == "":
|
|
1813
|
if stmt == "":
|
|
1814
|
return
|
|
1814
|
return
|
|
1815
|
timefunc = timeit.default_timer
|
|
1815
|
timefunc = timeit.default_timer
|
|
1816
|
number = int(getattr(opts, "n", 0))
|
|
1816
|
number = int(getattr(opts, "n", 0))
|
|
1817
|
repeat = int(getattr(opts, "r", timeit.default_repeat))
|
|
1817
|
repeat = int(getattr(opts, "r", timeit.default_repeat))
|
|
1818
|
precision = int(getattr(opts, "p", 3))
|
|
1818
|
precision = int(getattr(opts, "p", 3))
|
|
1819
|
if hasattr(opts, "t"):
|
|
1819
|
if hasattr(opts, "t"):
|
|
1820
|
timefunc = time.time
|
|
1820
|
timefunc = time.time
|
|
1821
|
if hasattr(opts, "c"):
|
|
1821
|
if hasattr(opts, "c"):
|
|
1822
|
timefunc = clock
|
|
1822
|
timefunc = clock
|
|
1823
|
|
|
1823
|
|
|
1824
|
timer = timeit.Timer(timer=timefunc)
|
|
1824
|
timer = timeit.Timer(timer=timefunc)
|
|
1825
|
# this code has tight coupling to the inner workings of timeit.Timer,
|
|
1825
|
# this code has tight coupling to the inner workings of timeit.Timer,
|
|
1826
|
# but is there a better way to achieve that the code stmt has access
|
|
1826
|
# but is there a better way to achieve that the code stmt has access
|
|
1827
|
# to the shell namespace?
|
|
1827
|
# to the shell namespace?
|
|
1828
|
|
|
1828
|
|
|
1829
|
src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
|
|
1829
|
src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
|
|
1830
|
'setup': "pass"}
|
|
1830
|
'setup': "pass"}
|
|
1831
|
# Track compilation time so it can be reported if too long
|
|
1831
|
# Track compilation time so it can be reported if too long
|
|
1832
|
# Minimum time above which compilation time will be reported
|
|
1832
|
# Minimum time above which compilation time will be reported
|
|
1833
|
tc_min = 0.1
|
|
1833
|
tc_min = 0.1
|
|
1834
|
|
|
1834
|
|
|
1835
|
t0 = clock()
|
|
1835
|
t0 = clock()
|
|
1836
|
code = compile(src, "<magic-timeit>", "exec")
|
|
1836
|
code = compile(src, "<magic-timeit>", "exec")
|
|
1837
|
tc = clock()-t0
|
|
1837
|
tc = clock()-t0
|
|
1838
|
|
|
1838
|
|
|
1839
|
ns = {}
|
|
1839
|
ns = {}
|
|
1840
|
exec code in self.shell.user_ns, ns
|
|
1840
|
exec code in self.shell.user_ns, ns
|
|
1841
|
timer.inner = ns["inner"]
|
|
1841
|
timer.inner = ns["inner"]
|
|
1842
|
|
|
1842
|
|
|
1843
|
if number == 0:
|
|
1843
|
if number == 0:
|
|
1844
|
# determine number so that 0.2 <= total time < 2.0
|
|
1844
|
# determine number so that 0.2 <= total time < 2.0
|
|
1845
|
number = 1
|
|
1845
|
number = 1
|
|
1846
|
for i in range(1, 10):
|
|
1846
|
for i in range(1, 10):
|
|
1847
|
if timer.timeit(number) >= 0.2:
|
|
1847
|
if timer.timeit(number) >= 0.2:
|
|
1848
|
break
|
|
1848
|
break
|
|
1849
|
number *= 10
|
|
1849
|
number *= 10
|
|
1850
|
|
|
1850
|
|
|
1851
|
best = min(timer.repeat(repeat, number)) / number
|
|
1851
|
best = min(timer.repeat(repeat, number)) / number
|
|
1852
|
|
|
1852
|
|
|
1853
|
if best > 0.0 and best < 1000.0:
|
|
1853
|
if best > 0.0 and best < 1000.0:
|
|
1854
|
order = min(-int(math.floor(math.log10(best)) // 3), 3)
|
|
1854
|
order = min(-int(math.floor(math.log10(best)) // 3), 3)
|
|
1855
|
elif best >= 1000.0:
|
|
1855
|
elif best >= 1000.0:
|
|
1856
|
order = 0
|
|
1856
|
order = 0
|
|
1857
|
else:
|
|
1857
|
else:
|
|
1858
|
order = 3
|
|
1858
|
order = 3
|
|
1859
|
print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
|
|
1859
|
print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
|
|
1860
|
precision,
|
|
1860
|
precision,
|
|
1861
|
best * scaling[order],
|
|
1861
|
best * scaling[order],
|
|
1862
|
units[order])
|
|
1862
|
units[order])
|
|
1863
|
if tc > tc_min:
|
|
1863
|
if tc > tc_min:
|
|
1864
|
print "Compiler time: %.2f s" % tc
|
|
1864
|
print "Compiler time: %.2f s" % tc
|
|
1865
|
|
|
1865
|
|
|
1866
|
@testdec.skip_doctest
|
|
1866
|
@testdec.skip_doctest
|
|
1867
|
def magic_time(self,parameter_s = ''):
|
|
1867
|
def magic_time(self,parameter_s = ''):
|
|
1868
|
"""Time execution of a Python statement or expression.
|
|
1868
|
"""Time execution of a Python statement or expression.
|
|
1869
|
|
|
1869
|
|
|
1870
|
The CPU and wall clock times are printed, and the value of the
|
|
1870
|
The CPU and wall clock times are printed, and the value of the
|
|
1871
|
expression (if any) is returned. Note that under Win32, system time
|
|
1871
|
expression (if any) is returned. Note that under Win32, system time
|
|
1872
|
is always reported as 0, since it can not be measured.
|
|
1872
|
is always reported as 0, since it can not be measured.
|
|
1873
|
|
|
1873
|
|
|
1874
|
This function provides very basic timing functionality. In Python
|
|
1874
|
This function provides very basic timing functionality. In Python
|
|
1875
|
2.3, the timeit module offers more control and sophistication, so this
|
|
1875
|
2.3, the timeit module offers more control and sophistication, so this
|
|
1876
|
could be rewritten to use it (patches welcome).
|
|
1876
|
could be rewritten to use it (patches welcome).
|
|
1877
|
|
|
1877
|
|
|
1878
|
Some examples:
|
|
1878
|
Some examples:
|
|
1879
|
|
|
1879
|
|
|
1880
|
In [1]: time 2**128
|
|
1880
|
In [1]: time 2**128
|
|
1881
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1881
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1882
|
Wall time: 0.00
|
|
1882
|
Wall time: 0.00
|
|
1883
|
Out[1]: 340282366920938463463374607431768211456L
|
|
1883
|
Out[1]: 340282366920938463463374607431768211456L
|
|
1884
|
|
|
1884
|
|
|
1885
|
In [2]: n = 1000000
|
|
1885
|
In [2]: n = 1000000
|
|
1886
|
|
|
1886
|
|
|
1887
|
In [3]: time sum(range(n))
|
|
1887
|
In [3]: time sum(range(n))
|
|
1888
|
CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
|
|
1888
|
CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
|
|
1889
|
Wall time: 1.37
|
|
1889
|
Wall time: 1.37
|
|
1890
|
Out[3]: 499999500000L
|
|
1890
|
Out[3]: 499999500000L
|
|
1891
|
|
|
1891
|
|
|
1892
|
In [4]: time print 'hello world'
|
|
1892
|
In [4]: time print 'hello world'
|
|
1893
|
hello world
|
|
1893
|
hello world
|
|
1894
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1894
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1895
|
Wall time: 0.00
|
|
1895
|
Wall time: 0.00
|
|
1896
|
|
|
1896
|
|
|
1897
|
Note that the time needed by Python to compile the given expression
|
|
1897
|
Note that the time needed by Python to compile the given expression
|
|
1898
|
will be reported if it is more than 0.1s. In this example, the
|
|
1898
|
will be reported if it is more than 0.1s. In this example, the
|
|
1899
|
actual exponentiation is done by Python at compilation time, so while
|
|
1899
|
actual exponentiation is done by Python at compilation time, so while
|
|
1900
|
the expression can take a noticeable amount of time to compute, that
|
|
1900
|
the expression can take a noticeable amount of time to compute, that
|
|
1901
|
time is purely due to the compilation:
|
|
1901
|
time is purely due to the compilation:
|
|
1902
|
|
|
1902
|
|
|
1903
|
In [5]: time 3**9999;
|
|
1903
|
In [5]: time 3**9999;
|
|
1904
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1904
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1905
|
Wall time: 0.00 s
|
|
1905
|
Wall time: 0.00 s
|
|
1906
|
|
|
1906
|
|
|
1907
|
In [6]: time 3**999999;
|
|
1907
|
In [6]: time 3**999999;
|
|
1908
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1908
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1909
|
Wall time: 0.00 s
|
|
1909
|
Wall time: 0.00 s
|
|
1910
|
Compiler : 0.78 s
|
|
1910
|
Compiler : 0.78 s
|
|
1911
|
"""
|
|
1911
|
"""
|
|
1912
|
|
|
1912
|
|
|
1913
|
# fail immediately if the given expression can't be compiled
|
|
1913
|
# fail immediately if the given expression can't be compiled
|
|
1914
|
|
|
1914
|
|
|
1915
|
expr = self.shell.prefilter(parameter_s,False)
|
|
1915
|
expr = self.shell.prefilter(parameter_s,False)
|
|
1916
|
|
|
1916
|
|
|
1917
|
# Minimum time above which compilation time will be reported
|
|
1917
|
# Minimum time above which compilation time will be reported
|
|
1918
|
tc_min = 0.1
|
|
1918
|
tc_min = 0.1
|
|
1919
|
|
|
1919
|
|
|
1920
|
try:
|
|
1920
|
try:
|
|
1921
|
mode = 'eval'
|
|
1921
|
mode = 'eval'
|
|
1922
|
t0 = clock()
|
|
1922
|
t0 = clock()
|
|
1923
|
code = compile(expr,'<timed eval>',mode)
|
|
1923
|
code = compile(expr,'<timed eval>',mode)
|
|
1924
|
tc = clock()-t0
|
|
1924
|
tc = clock()-t0
|
|
1925
|
except SyntaxError:
|
|
1925
|
except SyntaxError:
|
|
1926
|
mode = 'exec'
|
|
1926
|
mode = 'exec'
|
|
1927
|
t0 = clock()
|
|
1927
|
t0 = clock()
|
|
1928
|
code = compile(expr,'<timed exec>',mode)
|
|
1928
|
code = compile(expr,'<timed exec>',mode)
|
|
1929
|
tc = clock()-t0
|
|
1929
|
tc = clock()-t0
|
|
1930
|
# skew measurement as little as possible
|
|
1930
|
# skew measurement as little as possible
|
|
1931
|
glob = self.shell.user_ns
|
|
1931
|
glob = self.shell.user_ns
|
|
1932
|
clk = clock2
|
|
1932
|
clk = clock2
|
|
1933
|
wtime = time.time
|
|
1933
|
wtime = time.time
|
|
1934
|
# time execution
|
|
1934
|
# time execution
|
|
1935
|
wall_st = wtime()
|
|
1935
|
wall_st = wtime()
|
|
1936
|
if mode=='eval':
|
|
1936
|
if mode=='eval':
|
|
1937
|
st = clk()
|
|
1937
|
st = clk()
|
|
1938
|
out = eval(code,glob)
|
|
1938
|
out = eval(code,glob)
|
|
1939
|
end = clk()
|
|
1939
|
end = clk()
|
|
1940
|
else:
|
|
1940
|
else:
|
|
1941
|
st = clk()
|
|
1941
|
st = clk()
|
|
1942
|
exec code in glob
|
|
1942
|
exec code in glob
|
|
1943
|
end = clk()
|
|
1943
|
end = clk()
|
|
1944
|
out = None
|
|
1944
|
out = None
|
|
1945
|
wall_end = wtime()
|
|
1945
|
wall_end = wtime()
|
|
1946
|
# Compute actual times and report
|
|
1946
|
# Compute actual times and report
|
|
1947
|
wall_time = wall_end-wall_st
|
|
1947
|
wall_time = wall_end-wall_st
|
|
1948
|
cpu_user = end[0]-st[0]
|
|
1948
|
cpu_user = end[0]-st[0]
|
|
1949
|
cpu_sys = end[1]-st[1]
|
|
1949
|
cpu_sys = end[1]-st[1]
|
|
1950
|
cpu_tot = cpu_user+cpu_sys
|
|
1950
|
cpu_tot = cpu_user+cpu_sys
|
|
1951
|
print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
|
|
1951
|
print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
|
|
1952
|
(cpu_user,cpu_sys,cpu_tot)
|
|
1952
|
(cpu_user,cpu_sys,cpu_tot)
|
|
1953
|
print "Wall time: %.2f s" % wall_time
|
|
1953
|
print "Wall time: %.2f s" % wall_time
|
|
1954
|
if tc > tc_min:
|
|
1954
|
if tc > tc_min:
|
|
1955
|
print "Compiler : %.2f s" % tc
|
|
1955
|
print "Compiler : %.2f s" % tc
|
|
1956
|
return out
|
|
1956
|
return out
|
|
1957
|
|
|
1957
|
|
|
1958
|
@testdec.skip_doctest
|
|
1958
|
@testdec.skip_doctest
|
|
1959
|
def magic_macro(self,parameter_s = ''):
|
|
1959
|
def magic_macro(self,parameter_s = ''):
|
|
1960
|
"""Define a set of input lines as a macro for future re-execution.
|
|
1960
|
"""Define a set of input lines as a macro for future re-execution.
|
|
1961
|
|
|
1961
|
|
|
1962
|
Usage:\\
|
|
1962
|
Usage:\\
|
|
1963
|
%macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
|
|
1963
|
%macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
|
|
1964
|
|
|
1964
|
|
|
1965
|
Options:
|
|
1965
|
Options:
|
|
1966
|
|
|
1966
|
|
|
1967
|
-r: use 'raw' input. By default, the 'processed' history is used,
|
|
1967
|
-r: use 'raw' input. By default, the 'processed' history is used,
|
|
1968
|
so that magics are loaded in their transformed version to valid
|
|
1968
|
so that magics are loaded in their transformed version to valid
|
|
1969
|
Python. If this option is given, the raw input as typed as the
|
|
1969
|
Python. If this option is given, the raw input as typed as the
|
|
1970
|
command line is used instead.
|
|
1970
|
command line is used instead.
|
|
1971
|
|
|
1971
|
|
|
1972
|
This will define a global variable called `name` which is a string
|
|
1972
|
This will define a global variable called `name` which is a string
|
|
1973
|
made of joining the slices and lines you specify (n1,n2,... numbers
|
|
1973
|
made of joining the slices and lines you specify (n1,n2,... numbers
|
|
1974
|
above) from your input history into a single string. This variable
|
|
1974
|
above) from your input history into a single string. This variable
|
|
1975
|
acts like an automatic function which re-executes those lines as if
|
|
1975
|
acts like an automatic function which re-executes those lines as if
|
|
1976
|
you had typed them. You just type 'name' at the prompt and the code
|
|
1976
|
you had typed them. You just type 'name' at the prompt and the code
|
|
1977
|
executes.
|
|
1977
|
executes.
|
|
1978
|
|
|
1978
|
|
|
1979
|
The notation for indicating number ranges is: n1-n2 means 'use line
|
|
1979
|
The notation for indicating number ranges is: n1-n2 means 'use line
|
|
1980
|
numbers n1,...n2' (the endpoint is included). That is, '5-7' means
|
|
1980
|
numbers n1,...n2' (the endpoint is included). That is, '5-7' means
|
|
1981
|
using the lines numbered 5,6 and 7.
|
|
1981
|
using the lines numbered 5,6 and 7.
|
|
1982
|
|
|
1982
|
|
|
1983
|
Note: as a 'hidden' feature, you can also use traditional python slice
|
|
1983
|
Note: as a 'hidden' feature, you can also use traditional python slice
|
|
1984
|
notation, where N:M means numbers N through M-1.
|
|
1984
|
notation, where N:M means numbers N through M-1.
|
|
1985
|
|
|
1985
|
|
|
1986
|
For example, if your history contains (%hist prints it):
|
|
1986
|
For example, if your history contains (%hist prints it):
|
|
1987
|
|
|
1987
|
|
|
1988
|
44: x=1
|
|
1988
|
44: x=1
|
|
1989
|
45: y=3
|
|
1989
|
45: y=3
|
|
1990
|
46: z=x+y
|
|
1990
|
46: z=x+y
|
|
1991
|
47: print x
|
|
1991
|
47: print x
|
|
1992
|
48: a=5
|
|
1992
|
48: a=5
|
|
1993
|
49: print 'x',x,'y',y
|
|
1993
|
49: print 'x',x,'y',y
|
|
1994
|
|
|
1994
|
|
|
1995
|
you can create a macro with lines 44 through 47 (included) and line 49
|
|
1995
|
you can create a macro with lines 44 through 47 (included) and line 49
|
|
1996
|
called my_macro with:
|
|
1996
|
called my_macro with:
|
|
1997
|
|
|
1997
|
|
|
1998
|
In [55]: %macro my_macro 44-47 49
|
|
1998
|
In [55]: %macro my_macro 44-47 49
|
|
1999
|
|
|
1999
|
|
|
2000
|
Now, typing `my_macro` (without quotes) will re-execute all this code
|
|
2000
|
Now, typing `my_macro` (without quotes) will re-execute all this code
|
|
2001
|
in one pass.
|
|
2001
|
in one pass.
|
|
2002
|
|
|
2002
|
|
|
2003
|
You don't need to give the line-numbers in order, and any given line
|
|
2003
|
You don't need to give the line-numbers in order, and any given line
|
|
2004
|
number can appear multiple times. You can assemble macros with any
|
|
2004
|
number can appear multiple times. You can assemble macros with any
|
|
2005
|
lines from your input history in any order.
|
|
2005
|
lines from your input history in any order.
|
|
2006
|
|
|
2006
|
|
|
2007
|
The macro is a simple object which holds its value in an attribute,
|
|
2007
|
The macro is a simple object which holds its value in an attribute,
|
|
2008
|
but IPython's display system checks for macros and executes them as
|
|
2008
|
but IPython's display system checks for macros and executes them as
|
|
2009
|
code instead of printing them when you type their name.
|
|
2009
|
code instead of printing them when you type their name.
|
|
2010
|
|
|
2010
|
|
|
2011
|
You can view a macro's contents by explicitly printing it with:
|
|
2011
|
You can view a macro's contents by explicitly printing it with:
|
|
2012
|
|
|
2012
|
|
|
2013
|
'print macro_name'.
|
|
2013
|
'print macro_name'.
|
|
2014
|
|
|
2014
|
|
|
2015
|
For one-off cases which DON'T contain magic function calls in them you
|
|
2015
|
For one-off cases which DON'T contain magic function calls in them you
|
|
2016
|
can obtain similar results by explicitly executing slices from your
|
|
2016
|
can obtain similar results by explicitly executing slices from your
|
|
2017
|
input history with:
|
|
2017
|
input history with:
|
|
2018
|
|
|
2018
|
|
|
2019
|
In [60]: exec In[44:48]+In[49]"""
|
|
2019
|
In [60]: exec In[44:48]+In[49]"""
|
|
2020
|
|
|
2020
|
|
|
2021
|
opts,args = self.parse_options(parameter_s,'r',mode='list')
|
|
2021
|
opts,args = self.parse_options(parameter_s,'r',mode='list')
|
|
2022
|
if not args: # List existing macros
|
|
2022
|
if not args: # List existing macros
|
|
2023
|
return sorted(k for k,v in self.shell.user_ns.iteritems() if\
|
|
2023
|
return sorted(k for k,v in self.shell.user_ns.iteritems() if\
|
|
2024
|
isinstance(v, Macro))
|
|
2024
|
isinstance(v, Macro))
|
|
2025
|
if len(args) == 1:
|
|
2025
|
if len(args) == 1:
|
|
2026
|
raise UsageError(
|
|
2026
|
raise UsageError(
|
|
2027
|
"%macro insufficient args; usage '%macro name n1-n2 n3-4...")
|
|
2027
|
"%macro insufficient args; usage '%macro name n1-n2 n3-4...")
|
|
2028
|
name, ranges = args[0], " ".join(args[1:])
|
|
2028
|
name, ranges = args[0], " ".join(args[1:])
|
|
2029
|
|
|
2029
|
|
|
2030
|
#print 'rng',ranges # dbg
|
|
2030
|
#print 'rng',ranges # dbg
|
|
2031
|
lines = self.extract_input_lines(ranges,'r' in opts)
|
|
2031
|
lines = self.extract_input_lines(ranges,'r' in opts)
|
|
2032
|
macro = Macro(lines)
|
|
2032
|
macro = Macro(lines)
|
|
2033
|
self.shell.define_macro(name, macro)
|
|
2033
|
self.shell.define_macro(name, macro)
|
|
2034
|
print 'Macro `%s` created. To execute, type its name (without quotes).' % name
|
|
2034
|
print 'Macro `%s` created. To execute, type its name (without quotes).' % name
|
|
2035
|
print 'Macro contents:'
|
|
2035
|
print 'Macro contents:'
|
|
2036
|
print macro,
|
|
2036
|
print macro,
|
|
2037
|
|
|
2037
|
|
|
2038
|
def magic_save(self,parameter_s = ''):
|
|
2038
|
def magic_save(self,parameter_s = ''):
|
|
2039
|
"""Save a set of lines to a given filename.
|
|
2039
|
"""Save a set of lines to a given filename.
|
|
2040
|
|
|
2040
|
|
|
2041
|
Usage:\\
|
|
2041
|
Usage:\\
|
|
2042
|
%save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
|
|
2042
|
%save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
|
|
2043
|
|
|
2043
|
|
|
2044
|
Options:
|
|
2044
|
Options:
|
|
2045
|
|
|
2045
|
|
|
2046
|
-r: use 'raw' input. By default, the 'processed' history is used,
|
|
2046
|
-r: use 'raw' input. By default, the 'processed' history is used,
|
|
2047
|
so that magics are loaded in their transformed version to valid
|
|
2047
|
so that magics are loaded in their transformed version to valid
|
|
2048
|
Python. If this option is given, the raw input as typed as the
|
|
2048
|
Python. If this option is given, the raw input as typed as the
|
|
2049
|
command line is used instead.
|
|
2049
|
command line is used instead.
|
|
2050
|
|
|
2050
|
|
|
2051
|
This function uses the same syntax as %macro for line extraction, but
|
|
2051
|
This function uses the same syntax as %macro for line extraction, but
|
|
2052
|
instead of creating a macro it saves the resulting string to the
|
|
2052
|
instead of creating a macro it saves the resulting string to the
|
|
2053
|
filename you specify.
|
|
2053
|
filename you specify.
|
|
2054
|
|
|
2054
|
|
|
2055
|
It adds a '.py' extension to the file if you don't do so yourself, and
|
|
2055
|
It adds a '.py' extension to the file if you don't do so yourself, and
|
|
2056
|
it asks for confirmation before overwriting existing files."""
|
|
2056
|
it asks for confirmation before overwriting existing files."""
|
|
2057
|
|
|
2057
|
|
|
2058
|
opts,args = self.parse_options(parameter_s,'r',mode='list')
|
|
2058
|
opts,args = self.parse_options(parameter_s,'r',mode='list')
|
|
2059
|
fname,ranges = args[0], " ".join(args[1:])
|
|
2059
|
fname,ranges = args[0], " ".join(args[1:])
|
|
2060
|
if not fname.endswith('.py'):
|
|
2060
|
if not fname.endswith('.py'):
|
|
2061
|
fname += '.py'
|
|
2061
|
fname += '.py'
|
|
2062
|
if os.path.isfile(fname):
|
|
2062
|
if os.path.isfile(fname):
|
|
2063
|
ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
|
|
2063
|
ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
|
|
2064
|
if ans.lower() not in ['y','yes']:
|
|
2064
|
if ans.lower() not in ['y','yes']:
|
|
2065
|
print 'Operation cancelled.'
|
|
2065
|
print 'Operation cancelled.'
|
|
2066
|
return
|
|
2066
|
return
|
|
2067
|
cmds = self.extract_input_lines(ranges, 'r' in opts)
|
|
2067
|
cmds = self.extract_input_lines(ranges, 'r' in opts)
|
|
2068
|
with open(fname,'w') as f:
|
|
2068
|
with open(fname,'w') as f:
|
|
2069
|
f.write(cmds)
|
|
2069
|
f.write(cmds)
|
|
2070
|
print 'The following commands were written to file `%s`:' % fname
|
|
2070
|
print 'The following commands were written to file `%s`:' % fname
|
|
2071
|
print cmds
|
|
2071
|
print cmds
|
|
2072
|
|
|
2072
|
|
|
2073
|
def _edit_macro(self,mname,macro):
|
|
2073
|
def _edit_macro(self,mname,macro):
|
|
2074
|
"""open an editor with the macro data in a file"""
|
|
2074
|
"""open an editor with the macro data in a file"""
|
|
2075
|
filename = self.shell.mktempfile(macro.value)
|
|
2075
|
filename = self.shell.mktempfile(macro.value)
|
|
2076
|
self.shell.hooks.editor(filename)
|
|
2076
|
self.shell.hooks.editor(filename)
|
|
2077
|
|
|
2077
|
|
|
2078
|
# and make a new macro object, to replace the old one
|
|
2078
|
# and make a new macro object, to replace the old one
|
|
2079
|
mfile = open(filename)
|
|
2079
|
mfile = open(filename)
|
|
2080
|
mvalue = mfile.read()
|
|
2080
|
mvalue = mfile.read()
|
|
2081
|
mfile.close()
|
|
2081
|
mfile.close()
|
|
2082
|
self.shell.user_ns[mname] = Macro(mvalue)
|
|
2082
|
self.shell.user_ns[mname] = Macro(mvalue)
|
|
2083
|
|
|
2083
|
|
|
2084
|
def magic_ed(self,parameter_s=''):
|
|
2084
|
def magic_ed(self,parameter_s=''):
|
|
2085
|
"""Alias to %edit."""
|
|
2085
|
"""Alias to %edit."""
|
|
2086
|
return self.magic_edit(parameter_s)
|
|
2086
|
return self.magic_edit(parameter_s)
|
|
2087
|
|
|
2087
|
|
|
2088
|
@testdec.skip_doctest
|
|
2088
|
@testdec.skip_doctest
|
|
2089
|
def magic_edit(self,parameter_s='',last_call=['','']):
|
|
2089
|
def magic_edit(self,parameter_s='',last_call=['','']):
|
|
2090
|
"""Bring up an editor and execute the resulting code.
|
|
2090
|
"""Bring up an editor and execute the resulting code.
|
|
2091
|
|
|
2091
|
|
|
2092
|
Usage:
|
|
2092
|
Usage:
|
|
2093
|
%edit [options] [args]
|
|
2093
|
%edit [options] [args]
|
|
2094
|
|
|
2094
|
|
|
2095
|
%edit runs IPython's editor hook. The default version of this hook is
|
|
2095
|
%edit runs IPython's editor hook. The default version of this hook is
|
|
2096
|
set to call the __IPYTHON__.rc.editor command. This is read from your
|
|
2096
|
set to call the __IPYTHON__.rc.editor command. This is read from your
|
|
2097
|
environment variable $EDITOR. If this isn't found, it will default to
|
|
2097
|
environment variable $EDITOR. If this isn't found, it will default to
|
|
2098
|
vi under Linux/Unix and to notepad under Windows. See the end of this
|
|
2098
|
vi under Linux/Unix and to notepad under Windows. See the end of this
|
|
2099
|
docstring for how to change the editor hook.
|
|
2099
|
docstring for how to change the editor hook.
|
|
2100
|
|
|
2100
|
|
|
2101
|
You can also set the value of this editor via the command line option
|
|
2101
|
You can also set the value of this editor via the command line option
|
|
2102
|
'-editor' or in your ipythonrc file. This is useful if you wish to use
|
|
2102
|
'-editor' or in your ipythonrc file. This is useful if you wish to use
|
|
2103
|
specifically for IPython an editor different from your typical default
|
|
2103
|
specifically for IPython an editor different from your typical default
|
|
2104
|
(and for Windows users who typically don't set environment variables).
|
|
2104
|
(and for Windows users who typically don't set environment variables).
|
|
2105
|
|
|
2105
|
|
|
2106
|
This command allows you to conveniently edit multi-line code right in
|
|
2106
|
This command allows you to conveniently edit multi-line code right in
|
|
2107
|
your IPython session.
|
|
2107
|
your IPython session.
|
|
2108
|
|
|
2108
|
|
|
2109
|
If called without arguments, %edit opens up an empty editor with a
|
|
2109
|
If called without arguments, %edit opens up an empty editor with a
|
|
2110
|
temporary file and will execute the contents of this file when you
|
|
2110
|
temporary file and will execute the contents of this file when you
|
|
2111
|
close it (don't forget to save it!).
|
|
2111
|
close it (don't forget to save it!).
|
|
2112
|
|
|
2112
|
|
|
2113
|
|
|
2113
|
|
|
2114
|
Options:
|
|
2114
|
Options:
|
|
2115
|
|
|
2115
|
|
|
2116
|
-n <number>: open the editor at a specified line number. By default,
|
|
2116
|
-n <number>: open the editor at a specified line number. By default,
|
|
2117
|
the IPython editor hook uses the unix syntax 'editor +N filename', but
|
|
2117
|
the IPython editor hook uses the unix syntax 'editor +N filename', but
|
|
2118
|
you can configure this by providing your own modified hook if your
|
|
2118
|
you can configure this by providing your own modified hook if your
|
|
2119
|
favorite editor supports line-number specifications with a different
|
|
2119
|
favorite editor supports line-number specifications with a different
|
|
2120
|
syntax.
|
|
2120
|
syntax.
|
|
2121
|
|
|
2121
|
|
|
2122
|
-p: this will call the editor with the same data as the previous time
|
|
2122
|
-p: this will call the editor with the same data as the previous time
|
|
2123
|
it was used, regardless of how long ago (in your current session) it
|
|
2123
|
it was used, regardless of how long ago (in your current session) it
|
|
2124
|
was.
|
|
2124
|
was.
|
|
2125
|
|
|
2125
|
|
|
2126
|
-r: use 'raw' input. This option only applies to input taken from the
|
|
2126
|
-r: use 'raw' input. This option only applies to input taken from the
|
|
2127
|
user's history. By default, the 'processed' history is used, so that
|
|
2127
|
user's history. By default, the 'processed' history is used, so that
|
|
2128
|
magics are loaded in their transformed version to valid Python. If
|
|
2128
|
magics are loaded in their transformed version to valid Python. If
|
|
2129
|
this option is given, the raw input as typed as the command line is
|
|
2129
|
this option is given, the raw input as typed as the command line is
|
|
2130
|
used instead. When you exit the editor, it will be executed by
|
|
2130
|
used instead. When you exit the editor, it will be executed by
|
|
2131
|
IPython's own processor.
|
|
2131
|
IPython's own processor.
|
|
2132
|
|
|
2132
|
|
|
2133
|
-x: do not execute the edited code immediately upon exit. This is
|
|
2133
|
-x: do not execute the edited code immediately upon exit. This is
|
|
2134
|
mainly useful if you are editing programs which need to be called with
|
|
2134
|
mainly useful if you are editing programs which need to be called with
|
|
2135
|
command line arguments, which you can then do using %run.
|
|
2135
|
command line arguments, which you can then do using %run.
|
|
2136
|
|
|
2136
|
|
|
2137
|
|
|
2137
|
|
|
2138
|
Arguments:
|
|
2138
|
Arguments:
|
|
2139
|
|
|
2139
|
|
|
2140
|
If arguments are given, the following possibilites exist:
|
|
2140
|
If arguments are given, the following possibilites exist:
|
|
2141
|
|
|
2141
|
|
|
2142
|
- The arguments are numbers or pairs of colon-separated numbers (like
|
|
2142
|
- The arguments are numbers or pairs of colon-separated numbers (like
|
|
2143
|
1 4:8 9). These are interpreted as lines of previous input to be
|
|
2143
|
1 4:8 9). These are interpreted as lines of previous input to be
|
|
2144
|
loaded into the editor. The syntax is the same of the %macro command.
|
|
2144
|
loaded into the editor. The syntax is the same of the %macro command.
|
|
2145
|
|
|
2145
|
|
|
2146
|
- If the argument doesn't start with a number, it is evaluated as a
|
|
2146
|
- If the argument doesn't start with a number, it is evaluated as a
|
|
2147
|
variable and its contents loaded into the editor. You can thus edit
|
|
2147
|
variable and its contents loaded into the editor. You can thus edit
|
|
2148
|
any string which contains python code (including the result of
|
|
2148
|
any string which contains python code (including the result of
|
|
2149
|
previous edits).
|
|
2149
|
previous edits).
|
|
2150
|
|
|
2150
|
|
|
2151
|
- If the argument is the name of an object (other than a string),
|
|
2151
|
- If the argument is the name of an object (other than a string),
|
|
2152
|
IPython will try to locate the file where it was defined and open the
|
|
2152
|
IPython will try to locate the file where it was defined and open the
|
|
2153
|
editor at the point where it is defined. You can use `%edit function`
|
|
2153
|
editor at the point where it is defined. You can use `%edit function`
|
|
2154
|
to load an editor exactly at the point where 'function' is defined,
|
|
2154
|
to load an editor exactly at the point where 'function' is defined,
|
|
2155
|
edit it and have the file be executed automatically.
|
|
2155
|
edit it and have the file be executed automatically.
|
|
2156
|
|
|
2156
|
|
|
2157
|
If the object is a macro (see %macro for details), this opens up your
|
|
2157
|
If the object is a macro (see %macro for details), this opens up your
|
|
2158
|
specified editor with a temporary file containing the macro's data.
|
|
2158
|
specified editor with a temporary file containing the macro's data.
|
|
2159
|
Upon exit, the macro is reloaded with the contents of the file.
|
|
2159
|
Upon exit, the macro is reloaded with the contents of the file.
|
|
2160
|
|
|
2160
|
|
|
2161
|
Note: opening at an exact line is only supported under Unix, and some
|
|
2161
|
Note: opening at an exact line is only supported under Unix, and some
|
|
2162
|
editors (like kedit and gedit up to Gnome 2.8) do not understand the
|
|
2162
|
editors (like kedit and gedit up to Gnome 2.8) do not understand the
|
|
2163
|
'+NUMBER' parameter necessary for this feature. Good editors like
|
|
2163
|
'+NUMBER' parameter necessary for this feature. Good editors like
|
|
2164
|
(X)Emacs, vi, jed, pico and joe all do.
|
|
2164
|
(X)Emacs, vi, jed, pico and joe all do.
|
|
2165
|
|
|
2165
|
|
|
2166
|
- If the argument is not found as a variable, IPython will look for a
|
|
2166
|
- If the argument is not found as a variable, IPython will look for a
|
|
2167
|
file with that name (adding .py if necessary) and load it into the
|
|
2167
|
file with that name (adding .py if necessary) and load it into the
|
|
2168
|
editor. It will execute its contents with execfile() when you exit,
|
|
2168
|
editor. It will execute its contents with execfile() when you exit,
|
|
2169
|
loading any code in the file into your interactive namespace.
|
|
2169
|
loading any code in the file into your interactive namespace.
|
|
2170
|
|
|
2170
|
|
|
2171
|
After executing your code, %edit will return as output the code you
|
|
2171
|
After executing your code, %edit will return as output the code you
|
|
2172
|
typed in the editor (except when it was an existing file). This way
|
|
2172
|
typed in the editor (except when it was an existing file). This way
|
|
2173
|
you can reload the code in further invocations of %edit as a variable,
|
|
2173
|
you can reload the code in further invocations of %edit as a variable,
|
|
2174
|
via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
|
|
2174
|
via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
|
|
2175
|
the output.
|
|
2175
|
the output.
|
|
2176
|
|
|
2176
|
|
|
2177
|
Note that %edit is also available through the alias %ed.
|
|
2177
|
Note that %edit is also available through the alias %ed.
|
|
2178
|
|
|
2178
|
|
|
2179
|
This is an example of creating a simple function inside the editor and
|
|
2179
|
This is an example of creating a simple function inside the editor and
|
|
2180
|
then modifying it. First, start up the editor:
|
|
2180
|
then modifying it. First, start up the editor:
|
|
2181
|
|
|
2181
|
|
|
2182
|
In [1]: ed
|
|
2182
|
In [1]: ed
|
|
2183
|
Editing... done. Executing edited code...
|
|
2183
|
Editing... done. Executing edited code...
|
|
2184
|
Out[1]: 'def foo():n print "foo() was defined in an editing session"n'
|
|
2184
|
Out[1]: 'def foo():n print "foo() was defined in an editing session"n'
|
|
2185
|
|
|
2185
|
|
|
2186
|
We can then call the function foo():
|
|
2186
|
We can then call the function foo():
|
|
2187
|
|
|
2187
|
|
|
2188
|
In [2]: foo()
|
|
2188
|
In [2]: foo()
|
|
2189
|
foo() was defined in an editing session
|
|
2189
|
foo() was defined in an editing session
|
|
2190
|
|
|
2190
|
|
|
2191
|
Now we edit foo. IPython automatically loads the editor with the
|
|
2191
|
Now we edit foo. IPython automatically loads the editor with the
|
|
2192
|
(temporary) file where foo() was previously defined:
|
|
2192
|
(temporary) file where foo() was previously defined:
|
|
2193
|
|
|
2193
|
|
|
2194
|
In [3]: ed foo
|
|
2194
|
In [3]: ed foo
|
|
2195
|
Editing... done. Executing edited code...
|
|
2195
|
Editing... done. Executing edited code...
|
|
2196
|
|
|
2196
|
|
|
2197
|
And if we call foo() again we get the modified version:
|
|
2197
|
And if we call foo() again we get the modified version:
|
|
2198
|
|
|
2198
|
|
|
2199
|
In [4]: foo()
|
|
2199
|
In [4]: foo()
|
|
2200
|
foo() has now been changed!
|
|
2200
|
foo() has now been changed!
|
|
2201
|
|
|
2201
|
|
|
2202
|
Here is an example of how to edit a code snippet successive
|
|
2202
|
Here is an example of how to edit a code snippet successive
|
|
2203
|
times. First we call the editor:
|
|
2203
|
times. First we call the editor:
|
|
2204
|
|
|
2204
|
|
|
2205
|
In [5]: ed
|
|
2205
|
In [5]: ed
|
|
2206
|
Editing... done. Executing edited code...
|
|
2206
|
Editing... done. Executing edited code...
|
|
2207
|
hello
|
|
2207
|
hello
|
|
2208
|
Out[5]: "print 'hello'n"
|
|
2208
|
Out[5]: "print 'hello'n"
|
|
2209
|
|
|
2209
|
|
|
2210
|
Now we call it again with the previous output (stored in _):
|
|
2210
|
Now we call it again with the previous output (stored in _):
|
|
2211
|
|
|
2211
|
|
|
2212
|
In [6]: ed _
|
|
2212
|
In [6]: ed _
|
|
2213
|
Editing... done. Executing edited code...
|
|
2213
|
Editing... done. Executing edited code...
|
|
2214
|
hello world
|
|
2214
|
hello world
|
|
2215
|
Out[6]: "print 'hello world'n"
|
|
2215
|
Out[6]: "print 'hello world'n"
|
|
2216
|
|
|
2216
|
|
|
2217
|
Now we call it with the output #8 (stored in _8, also as Out[8]):
|
|
2217
|
Now we call it with the output #8 (stored in _8, also as Out[8]):
|
|
2218
|
|
|
2218
|
|
|
2219
|
In [7]: ed _8
|
|
2219
|
In [7]: ed _8
|
|
2220
|
Editing... done. Executing edited code...
|
|
2220
|
Editing... done. Executing edited code...
|
|
2221
|
hello again
|
|
2221
|
hello again
|
|
2222
|
Out[7]: "print 'hello again'n"
|
|
2222
|
Out[7]: "print 'hello again'n"
|
|
2223
|
|
|
2223
|
|
|
2224
|
|
|
2224
|
|
|
2225
|
Changing the default editor hook:
|
|
2225
|
Changing the default editor hook:
|
|
2226
|
|
|
2226
|
|
|
2227
|
If you wish to write your own editor hook, you can put it in a
|
|
2227
|
If you wish to write your own editor hook, you can put it in a
|
|
2228
|
configuration file which you load at startup time. The default hook
|
|
2228
|
configuration file which you load at startup time. The default hook
|
|
2229
|
is defined in the IPython.core.hooks module, and you can use that as a
|
|
2229
|
is defined in the IPython.core.hooks module, and you can use that as a
|
|
2230
|
starting example for further modifications. That file also has
|
|
2230
|
starting example for further modifications. That file also has
|
|
2231
|
general instructions on how to set a new hook for use once you've
|
|
2231
|
general instructions on how to set a new hook for use once you've
|
|
2232
|
defined it."""
|
|
2232
|
defined it."""
|
|
2233
|
|
|
2233
|
|
|
2234
|
# FIXME: This function has become a convoluted mess. It needs a
|
|
2234
|
# FIXME: This function has become a convoluted mess. It needs a
|
|
2235
|
# ground-up rewrite with clean, simple logic.
|
|
2235
|
# ground-up rewrite with clean, simple logic.
|
|
2236
|
|
|
2236
|
|
|
2237
|
def make_filename(arg):
|
|
2237
|
def make_filename(arg):
|
|
2238
|
"Make a filename from the given args"
|
|
2238
|
"Make a filename from the given args"
|
|
2239
|
try:
|
|
2239
|
try:
|
|
2240
|
filename = get_py_filename(arg)
|
|
2240
|
filename = get_py_filename(arg)
|
|
2241
|
except IOError:
|
|
2241
|
except IOError:
|
|
2242
|
if args.endswith('.py'):
|
|
2242
|
if args.endswith('.py'):
|
|
2243
|
filename = arg
|
|
2243
|
filename = arg
|
|
2244
|
else:
|
|
2244
|
else:
|
|
2245
|
filename = None
|
|
2245
|
filename = None
|
|
2246
|
return filename
|
|
2246
|
return filename
|
|
2247
|
|
|
2247
|
|
|
2248
|
# custom exceptions
|
|
2248
|
# custom exceptions
|
|
2249
|
class DataIsObject(Exception): pass
|
|
2249
|
class DataIsObject(Exception): pass
|
|
2250
|
|
|
2250
|
|
|
2251
|
opts,args = self.parse_options(parameter_s,'prxn:')
|
|
2251
|
opts,args = self.parse_options(parameter_s,'prxn:')
|
|
2252
|
# Set a few locals from the options for convenience:
|
|
2252
|
# Set a few locals from the options for convenience:
|
|
2253
|
opts_prev = 'p' in opts
|
|
2253
|
opts_prev = 'p' in opts
|
|
2254
|
opts_raw = 'r' in opts
|
|
2254
|
opts_raw = 'r' in opts
|
|
2255
|
|
|
2255
|
|
|
2256
|
# Default line number value
|
|
2256
|
# Default line number value
|
|
2257
|
lineno = opts.get('n',None)
|
|
2257
|
lineno = opts.get('n',None)
|
|
2258
|
|
|
2258
|
|
|
2259
|
if opts_prev:
|
|
2259
|
if opts_prev:
|
|
2260
|
args = '_%s' % last_call[0]
|
|
2260
|
args = '_%s' % last_call[0]
|
|
2261
|
if not self.shell.user_ns.has_key(args):
|
|
2261
|
if not self.shell.user_ns.has_key(args):
|
|
2262
|
args = last_call[1]
|
|
2262
|
args = last_call[1]
|
|
2263
|
|
|
2263
|
|
|
2264
|
# use last_call to remember the state of the previous call, but don't
|
|
2264
|
# use last_call to remember the state of the previous call, but don't
|
|
2265
|
# let it be clobbered by successive '-p' calls.
|
|
2265
|
# let it be clobbered by successive '-p' calls.
|
|
2266
|
try:
|
|
2266
|
try:
|
|
2267
|
last_call[0] = self.shell.displayhook.prompt_count
|
|
2267
|
last_call[0] = self.shell.displayhook.prompt_count
|
|
2268
|
if not opts_prev:
|
|
2268
|
if not opts_prev:
|
|
2269
|
last_call[1] = parameter_s
|
|
2269
|
last_call[1] = parameter_s
|
|
2270
|
except:
|
|
2270
|
except:
|
|
2271
|
pass
|
|
2271
|
pass
|
|
2272
|
|
|
2272
|
|
|
2273
|
# by default this is done with temp files, except when the given
|
|
2273
|
# by default this is done with temp files, except when the given
|
|
2274
|
# arg is a filename
|
|
2274
|
# arg is a filename
|
|
2275
|
use_temp = True
|
|
2275
|
use_temp = True
|
|
2276
|
|
|
2276
|
|
|
2277
|
data = ''
|
|
2277
|
data = ''
|
|
2278
|
if args[0].isdigit():
|
|
2278
|
if args[0].isdigit():
|
|
2279
|
# Mode where user specifies ranges of lines, like in %macro.
|
|
2279
|
# Mode where user specifies ranges of lines, like in %macro.
|
|
2280
|
# This means that you can't edit files whose names begin with
|
|
2280
|
# This means that you can't edit files whose names begin with
|
|
2281
|
# numbers this way. Tough.
|
|
2281
|
# numbers this way. Tough.
|
|
2282
|
data = self.extract_input_lines(args, opts_raw)
|
|
2282
|
data = self.extract_input_lines(args, opts_raw)
|
|
2283
|
elif args.endswith('.py'):
|
|
2283
|
elif args.endswith('.py'):
|
|
2284
|
filename = make_filename(args)
|
|
2284
|
filename = make_filename(args)
|
|
2285
|
use_temp = False
|
|
2285
|
use_temp = False
|
|
2286
|
elif args:
|
|
2286
|
elif args:
|
|
2287
|
try:
|
|
2287
|
try:
|
|
2288
|
# Load the parameter given as a variable. If not a string,
|
|
2288
|
# Load the parameter given as a variable. If not a string,
|
|
2289
|
# process it as an object instead (below)
|
|
2289
|
# process it as an object instead (below)
|
|
2290
|
|
|
2290
|
|
|
2291
|
#print '*** args',args,'type',type(args) # dbg
|
|
2291
|
#print '*** args',args,'type',type(args) # dbg
|
|
2292
|
data = eval(args, self.shell.user_ns)
|
|
2292
|
data = eval(args, self.shell.user_ns)
|
|
2293
|
if not isinstance(data, basestring):
|
|
2293
|
if not isinstance(data, basestring):
|
|
2294
|
raise DataIsObject
|
|
2294
|
raise DataIsObject
|
|
2295
|
|
|
2295
|
|
|
2296
|
except (NameError,SyntaxError):
|
|
2296
|
except (NameError,SyntaxError):
|
|
2297
|
# given argument is not a variable, try as a filename
|
|
2297
|
# given argument is not a variable, try as a filename
|
|
2298
|
filename = make_filename(args)
|
|
2298
|
filename = make_filename(args)
|
|
2299
|
if filename is None:
|
|
2299
|
if filename is None:
|
|
2300
|
warn("Argument given (%s) can't be found as a variable "
|
|
2300
|
warn("Argument given (%s) can't be found as a variable "
|
|
2301
|
"or as a filename." % args)
|
|
2301
|
"or as a filename." % args)
|
|
2302
|
return
|
|
2302
|
return
|
|
2303
|
use_temp = False
|
|
2303
|
use_temp = False
|
|
2304
|
|
|
2304
|
|
|
2305
|
except DataIsObject:
|
|
2305
|
except DataIsObject:
|
|
2306
|
# macros have a special edit function
|
|
2306
|
# macros have a special edit function
|
|
2307
|
if isinstance(data, Macro):
|
|
2307
|
if isinstance(data, Macro):
|
|
2308
|
self._edit_macro(args,data)
|
|
2308
|
self._edit_macro(args,data)
|
|
2309
|
return
|
|
2309
|
return
|
|
2310
|
|
|
2310
|
|
|
2311
|
# For objects, try to edit the file where they are defined
|
|
2311
|
# For objects, try to edit the file where they are defined
|
|
2312
|
try:
|
|
2312
|
try:
|
|
2313
|
filename = inspect.getabsfile(data)
|
|
2313
|
filename = inspect.getabsfile(data)
|
|
2314
|
if 'fakemodule' in filename.lower() and inspect.isclass(data):
|
|
2314
|
if 'fakemodule' in filename.lower() and inspect.isclass(data):
|
|
2315
|
# class created by %edit? Try to find source
|
|
2315
|
# class created by %edit? Try to find source
|
|
2316
|
# by looking for method definitions instead, the
|
|
2316
|
# by looking for method definitions instead, the
|
|
2317
|
# __module__ in those classes is FakeModule.
|
|
2317
|
# __module__ in those classes is FakeModule.
|
|
2318
|
attrs = [getattr(data, aname) for aname in dir(data)]
|
|
2318
|
attrs = [getattr(data, aname) for aname in dir(data)]
|
|
2319
|
for attr in attrs:
|
|
2319
|
for attr in attrs:
|
|
2320
|
if not inspect.ismethod(attr):
|
|
2320
|
if not inspect.ismethod(attr):
|
|
2321
|
continue
|
|
2321
|
continue
|
|
2322
|
filename = inspect.getabsfile(attr)
|
|
2322
|
filename = inspect.getabsfile(attr)
|
|
2323
|
if filename and 'fakemodule' not in filename.lower():
|
|
2323
|
if filename and 'fakemodule' not in filename.lower():
|
|
2324
|
# change the attribute to be the edit target instead
|
|
2324
|
# change the attribute to be the edit target instead
|
|
2325
|
data = attr
|
|
2325
|
data = attr
|
|
2326
|
break
|
|
2326
|
break
|
|
2327
|
|
|
2327
|
|
|
2328
|
datafile = 1
|
|
2328
|
datafile = 1
|
|
2329
|
except TypeError:
|
|
2329
|
except TypeError:
|
|
2330
|
filename = make_filename(args)
|
|
2330
|
filename = make_filename(args)
|
|
2331
|
datafile = 1
|
|
2331
|
datafile = 1
|
|
2332
|
warn('Could not find file where `%s` is defined.\n'
|
|
2332
|
warn('Could not find file where `%s` is defined.\n'
|
|
2333
|
'Opening a file named `%s`' % (args,filename))
|
|
2333
|
'Opening a file named `%s`' % (args,filename))
|
|
2334
|
# Now, make sure we can actually read the source (if it was in
|
|
2334
|
# Now, make sure we can actually read the source (if it was in
|
|
2335
|
# a temp file it's gone by now).
|
|
2335
|
# a temp file it's gone by now).
|
|
2336
|
if datafile:
|
|
2336
|
if datafile:
|
|
2337
|
try:
|
|
2337
|
try:
|
|
2338
|
if lineno is None:
|
|
2338
|
if lineno is None:
|
|
2339
|
lineno = inspect.getsourcelines(data)[1]
|
|
2339
|
lineno = inspect.getsourcelines(data)[1]
|
|
2340
|
except IOError:
|
|
2340
|
except IOError:
|
|
2341
|
filename = make_filename(args)
|
|
2341
|
filename = make_filename(args)
|
|
2342
|
if filename is None:
|
|
2342
|
if filename is None:
|
|
2343
|
warn('The file `%s` where `%s` was defined cannot '
|
|
2343
|
warn('The file `%s` where `%s` was defined cannot '
|
|
2344
|
'be read.' % (filename,data))
|
|
2344
|
'be read.' % (filename,data))
|
|
2345
|
return
|
|
2345
|
return
|
|
2346
|
use_temp = False
|
|
2346
|
use_temp = False
|
|
2347
|
|
|
2347
|
|
|
2348
|
if use_temp:
|
|
2348
|
if use_temp:
|
|
2349
|
filename = self.shell.mktempfile(data)
|
|
2349
|
filename = self.shell.mktempfile(data)
|
|
2350
|
print 'IPython will make a temporary file named:',filename
|
|
2350
|
print 'IPython will make a temporary file named:',filename
|
|
2351
|
|
|
2351
|
|
|
2352
|
# do actual editing here
|
|
2352
|
# do actual editing here
|
|
2353
|
print 'Editing...',
|
|
2353
|
print 'Editing...',
|
|
2354
|
sys.stdout.flush()
|
|
2354
|
sys.stdout.flush()
|
|
2355
|
try:
|
|
2355
|
try:
|
|
2356
|
# Quote filenames that may have spaces in them
|
|
2356
|
# Quote filenames that may have spaces in them
|
|
2357
|
if ' ' in filename:
|
|
2357
|
if ' ' in filename:
|
|
2358
|
filename = "%s" % filename
|
|
2358
|
filename = "%s" % filename
|
|
2359
|
self.shell.hooks.editor(filename,lineno)
|
|
2359
|
self.shell.hooks.editor(filename,lineno)
|
|
2360
|
except TryNext:
|
|
2360
|
except TryNext:
|
|
2361
|
warn('Could not open editor')
|
|
2361
|
warn('Could not open editor')
|
|
2362
|
return
|
|
2362
|
return
|
|
2363
|
|
|
2363
|
|
|
2364
|
# XXX TODO: should this be generalized for all string vars?
|
|
2364
|
# XXX TODO: should this be generalized for all string vars?
|
|
2365
|
# For now, this is special-cased to blocks created by cpaste
|
|
2365
|
# For now, this is special-cased to blocks created by cpaste
|
|
2366
|
if args.strip() == 'pasted_block':
|
|
2366
|
if args.strip() == 'pasted_block':
|
|
2367
|
self.shell.user_ns['pasted_block'] = file_read(filename)
|
|
2367
|
self.shell.user_ns['pasted_block'] = file_read(filename)
|
|
2368
|
|
|
2368
|
|
|
2369
|
if 'x' in opts: # -x prevents actual execution
|
|
2369
|
if 'x' in opts: # -x prevents actual execution
|
|
2370
|
print
|
|
2370
|
print
|
|
2371
|
else:
|
|
2371
|
else:
|
|
2372
|
print 'done. Executing edited code...'
|
|
2372
|
print 'done. Executing edited code...'
|
|
2373
|
if opts_r:
|
|
2373
|
if opts_r:
|
|
2374
|
self.shell.run_cell(file_read(filename))
|
|
2374
|
self.shell.run_cell(file_read(filename))
|
|
2375
|
else:
|
|
2375
|
else:
|
|
2376
|
self.shell.safe_execfile(filename,self.shell.user_ns,
|
|
2376
|
self.shell.safe_execfile(filename,self.shell.user_ns,
|
|
2377
|
self.shell.user_ns)
|
|
2377
|
self.shell.user_ns)
|
|
2378
|
|
|
2378
|
|
|
2379
|
|
|
2379
|
|
|
2380
|
if use_temp:
|
|
2380
|
if use_temp:
|
|
2381
|
try:
|
|
2381
|
try:
|
|
2382
|
return open(filename).read()
|
|
2382
|
return open(filename).read()
|
|
2383
|
except IOError,msg:
|
|
2383
|
except IOError,msg:
|
|
2384
|
if msg.filename == filename:
|
|
2384
|
if msg.filename == filename:
|
|
2385
|
warn('File not found. Did you forget to save?')
|
|
2385
|
warn('File not found. Did you forget to save?')
|
|
2386
|
return
|
|
2386
|
return
|
|
2387
|
else:
|
|
2387
|
else:
|
|
2388
|
self.shell.showtraceback()
|
|
2388
|
self.shell.showtraceback()
|
|
2389
|
|
|
2389
|
|
|
2390
|
def magic_xmode(self,parameter_s = ''):
|
|
2390
|
def magic_xmode(self,parameter_s = ''):
|
|
2391
|
"""Switch modes for the exception handlers.
|
|
2391
|
"""Switch modes for the exception handlers.
|
|
2392
|
|
|
2392
|
|
|
2393
|
Valid modes: Plain, Context and Verbose.
|
|
2393
|
Valid modes: Plain, Context and Verbose.
|
|
2394
|
|
|
2394
|
|
|
2395
|
If called without arguments, acts as a toggle."""
|
|
2395
|
If called without arguments, acts as a toggle."""
|
|
2396
|
|
|
2396
|
|
|
2397
|
def xmode_switch_err(name):
|
|
2397
|
def xmode_switch_err(name):
|
|
2398
|
warn('Error changing %s exception modes.\n%s' %
|
|
2398
|
warn('Error changing %s exception modes.\n%s' %
|
|
2399
|
(name,sys.exc_info()[1]))
|
|
2399
|
(name,sys.exc_info()[1]))
|
|
2400
|
|
|
2400
|
|
|
2401
|
shell = self.shell
|
|
2401
|
shell = self.shell
|
|
2402
|
new_mode = parameter_s.strip().capitalize()
|
|
2402
|
new_mode = parameter_s.strip().capitalize()
|
|
2403
|
try:
|
|
2403
|
try:
|
|
2404
|
shell.InteractiveTB.set_mode(mode=new_mode)
|
|
2404
|
shell.InteractiveTB.set_mode(mode=new_mode)
|
|
2405
|
print 'Exception reporting mode:',shell.InteractiveTB.mode
|
|
2405
|
print 'Exception reporting mode:',shell.InteractiveTB.mode
|
|
2406
|
except:
|
|
2406
|
except:
|
|
2407
|
xmode_switch_err('user')
|
|
2407
|
xmode_switch_err('user')
|
|
2408
|
|
|
2408
|
|
|
2409
|
def magic_colors(self,parameter_s = ''):
|
|
2409
|
def magic_colors(self,parameter_s = ''):
|
|
2410
|
"""Switch color scheme for prompts, info system and exception handlers.
|
|
2410
|
"""Switch color scheme for prompts, info system and exception handlers.
|
|
2411
|
|
|
2411
|
|
|
2412
|
Currently implemented schemes: NoColor, Linux, LightBG.
|
|
2412
|
Currently implemented schemes: NoColor, Linux, LightBG.
|
|
2413
|
|
|
2413
|
|
|
2414
|
Color scheme names are not case-sensitive.
|
|
2414
|
Color scheme names are not case-sensitive.
|
|
2415
|
|
|
2415
|
|
|
2416
|
Examples
|
|
2416
|
Examples
|
|
2417
|
--------
|
|
2417
|
--------
|
|
2418
|
To get a plain black and white terminal::
|
|
2418
|
To get a plain black and white terminal::
|
|
2419
|
|
|
2419
|
|
|
2420
|
%colors nocolor
|
|
2420
|
%colors nocolor
|
|
2421
|
"""
|
|
2421
|
"""
|
|
2422
|
|
|
2422
|
|
|
2423
|
def color_switch_err(name):
|
|
2423
|
def color_switch_err(name):
|
|
2424
|
warn('Error changing %s color schemes.\n%s' %
|
|
2424
|
warn('Error changing %s color schemes.\n%s' %
|
|
2425
|
(name,sys.exc_info()[1]))
|
|
2425
|
(name,sys.exc_info()[1]))
|
|
2426
|
|
|
2426
|
|
|
2427
|
|
|
2427
|
|
|
2428
|
new_scheme = parameter_s.strip()
|
|
2428
|
new_scheme = parameter_s.strip()
|
|
2429
|
if not new_scheme:
|
|
2429
|
if not new_scheme:
|
|
2430
|
raise UsageError(
|
|
2430
|
raise UsageError(
|
|
2431
|
"%colors: you must specify a color scheme. See '%colors?'")
|
|
2431
|
"%colors: you must specify a color scheme. See '%colors?'")
|
|
2432
|
return
|
|
2432
|
return
|
|
2433
|
# local shortcut
|
|
2433
|
# local shortcut
|
|
2434
|
shell = self.shell
|
|
2434
|
shell = self.shell
|
|
2435
|
|
|
2435
|
|
|
2436
|
import IPython.utils.rlineimpl as readline
|
|
2436
|
import IPython.utils.rlineimpl as readline
|
|
2437
|
|
|
2437
|
|
|
2438
|
if not readline.have_readline and sys.platform == "win32":
|
|
2438
|
if not readline.have_readline and sys.platform == "win32":
|
|
2439
|
msg = """\
|
|
2439
|
msg = """\
|
|
2440
|
Proper color support under MS Windows requires the pyreadline library.
|
|
2440
|
Proper color support under MS Windows requires the pyreadline library.
|
|
2441
|
You can find it at:
|
|
2441
|
You can find it at:
|
|
2442
|
http://ipython.scipy.org/moin/PyReadline/Intro
|
|
2442
|
http://ipython.scipy.org/moin/PyReadline/Intro
|
|
2443
|
Gary's readline needs the ctypes module, from:
|
|
2443
|
Gary's readline needs the ctypes module, from:
|
|
2444
|
http://starship.python.net/crew/theller/ctypes
|
|
2444
|
http://starship.python.net/crew/theller/ctypes
|
|
2445
|
(Note that ctypes is already part of Python versions 2.5 and newer).
|
|
2445
|
(Note that ctypes is already part of Python versions 2.5 and newer).
|
|
2446
|
|
|
2446
|
|
|
2447
|
Defaulting color scheme to 'NoColor'"""
|
|
2447
|
Defaulting color scheme to 'NoColor'"""
|
|
2448
|
new_scheme = 'NoColor'
|
|
2448
|
new_scheme = 'NoColor'
|
|
2449
|
warn(msg)
|
|
2449
|
warn(msg)
|
|
2450
|
|
|
2450
|
|
|
2451
|
# readline option is 0
|
|
2451
|
# readline option is 0
|
|
2452
|
if not shell.has_readline:
|
|
2452
|
if not shell.has_readline:
|
|
2453
|
new_scheme = 'NoColor'
|
|
2453
|
new_scheme = 'NoColor'
|
|
2454
|
|
|
2454
|
|
|
2455
|
# Set prompt colors
|
|
2455
|
# Set prompt colors
|
|
2456
|
try:
|
|
2456
|
try:
|
|
2457
|
shell.displayhook.set_colors(new_scheme)
|
|
2457
|
shell.displayhook.set_colors(new_scheme)
|
|
2458
|
except:
|
|
2458
|
except:
|
|
2459
|
color_switch_err('prompt')
|
|
2459
|
color_switch_err('prompt')
|
|
2460
|
else:
|
|
2460
|
else:
|
|
2461
|
shell.colors = \
|
|
2461
|
shell.colors = \
|
|
2462
|
shell.displayhook.color_table.active_scheme_name
|
|
2462
|
shell.displayhook.color_table.active_scheme_name
|
|
2463
|
# Set exception colors
|
|
2463
|
# Set exception colors
|
|
2464
|
try:
|
|
2464
|
try:
|
|
2465
|
shell.InteractiveTB.set_colors(scheme = new_scheme)
|
|
2465
|
shell.InteractiveTB.set_colors(scheme = new_scheme)
|
|
2466
|
shell.SyntaxTB.set_colors(scheme = new_scheme)
|
|
2466
|
shell.SyntaxTB.set_colors(scheme = new_scheme)
|
|
2467
|
except:
|
|
2467
|
except:
|
|
2468
|
color_switch_err('exception')
|
|
2468
|
color_switch_err('exception')
|
|
2469
|
|
|
2469
|
|
|
2470
|
# Set info (for 'object?') colors
|
|
2470
|
# Set info (for 'object?') colors
|
|
2471
|
if shell.color_info:
|
|
2471
|
if shell.color_info:
|
|
2472
|
try:
|
|
2472
|
try:
|
|
2473
|
shell.inspector.set_active_scheme(new_scheme)
|
|
2473
|
shell.inspector.set_active_scheme(new_scheme)
|
|
2474
|
except:
|
|
2474
|
except:
|
|
2475
|
color_switch_err('object inspector')
|
|
2475
|
color_switch_err('object inspector')
|
|
2476
|
else:
|
|
2476
|
else:
|
|
2477
|
shell.inspector.set_active_scheme('NoColor')
|
|
2477
|
shell.inspector.set_active_scheme('NoColor')
|
|
2478
|
|
|
2478
|
|
|
2479
|
def magic_pprint(self, parameter_s=''):
|
|
2479
|
def magic_pprint(self, parameter_s=''):
|
|
2480
|
"""Toggle pretty printing on/off."""
|
|
2480
|
"""Toggle pretty printing on/off."""
|
|
2481
|
ptformatter = self.shell.display_formatter.formatters['text/plain']
|
|
2481
|
ptformatter = self.shell.display_formatter.formatters['text/plain']
|
|
2482
|
ptformatter.pprint = bool(1 - ptformatter.pprint)
|
|
2482
|
ptformatter.pprint = bool(1 - ptformatter.pprint)
|
|
2483
|
print 'Pretty printing has been turned', \
|
|
2483
|
print 'Pretty printing has been turned', \
|
|
2484
|
['OFF','ON'][ptformatter.pprint]
|
|
2484
|
['OFF','ON'][ptformatter.pprint]
|
|
2485
|
|
|
2485
|
|
|
2486
|
def magic_Exit(self, parameter_s=''):
|
|
2486
|
def magic_Exit(self, parameter_s=''):
|
|
2487
|
"""Exit IPython."""
|
|
2487
|
"""Exit IPython."""
|
|
2488
|
|
|
2488
|
|
|
2489
|
self.shell.ask_exit()
|
|
2489
|
self.shell.ask_exit()
|
|
2490
|
|
|
2490
|
|
|
2491
|
# Add aliases as magics so all common forms work: exit, quit, Exit, Quit.
|
|
2491
|
# Add aliases as magics so all common forms work: exit, quit, Exit, Quit.
|
|
2492
|
magic_exit = magic_quit = magic_Quit = magic_Exit
|
|
2492
|
magic_exit = magic_quit = magic_Quit = magic_Exit
|
|
2493
|
|
|
2493
|
|
|
2494
|
#......................................................................
|
|
2494
|
#......................................................................
|
|
2495
|
# Functions to implement unix shell-type things
|
|
2495
|
# Functions to implement unix shell-type things
|
|
2496
|
|
|
2496
|
|
|
2497
|
@testdec.skip_doctest
|
|
2497
|
@testdec.skip_doctest
|
|
2498
|
def magic_alias(self, parameter_s = ''):
|
|
2498
|
def magic_alias(self, parameter_s = ''):
|
|
2499
|
"""Define an alias for a system command.
|
|
2499
|
"""Define an alias for a system command.
|
|
2500
|
|
|
2500
|
|
|
2501
|
'%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
|
|
2501
|
'%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
|
|
2502
|
|
|
2502
|
|
|
2503
|
Then, typing 'alias_name params' will execute the system command 'cmd
|
|
2503
|
Then, typing 'alias_name params' will execute the system command 'cmd
|
|
2504
|
params' (from your underlying operating system).
|
|
2504
|
params' (from your underlying operating system).
|
|
2505
|
|
|
2505
|
|
|
2506
|
Aliases have lower precedence than magic functions and Python normal
|
|
2506
|
Aliases have lower precedence than magic functions and Python normal
|
|
2507
|
variables, so if 'foo' is both a Python variable and an alias, the
|
|
2507
|
variables, so if 'foo' is both a Python variable and an alias, the
|
|
2508
|
alias can not be executed until 'del foo' removes the Python variable.
|
|
2508
|
alias can not be executed until 'del foo' removes the Python variable.
|
|
2509
|
|
|
2509
|
|
|
2510
|
You can use the %l specifier in an alias definition to represent the
|
|
2510
|
You can use the %l specifier in an alias definition to represent the
|
|
2511
|
whole line when the alias is called. For example:
|
|
2511
|
whole line when the alias is called. For example:
|
|
2512
|
|
|
2512
|
|
|
2513
|
In [2]: alias bracket echo "Input in brackets: <%l>"
|
|
2513
|
In [2]: alias bracket echo "Input in brackets: <%l>"
|
|
2514
|
In [3]: bracket hello world
|
|
2514
|
In [3]: bracket hello world
|
|
2515
|
Input in brackets: <hello world>
|
|
2515
|
Input in brackets: <hello world>
|
|
2516
|
|
|
2516
|
|
|
2517
|
You can also define aliases with parameters using %s specifiers (one
|
|
2517
|
You can also define aliases with parameters using %s specifiers (one
|
|
2518
|
per parameter):
|
|
2518
|
per parameter):
|
|
2519
|
|
|
2519
|
|
|
2520
|
In [1]: alias parts echo first %s second %s
|
|
2520
|
In [1]: alias parts echo first %s second %s
|
|
2521
|
In [2]: %parts A B
|
|
2521
|
In [2]: %parts A B
|
|
2522
|
first A second B
|
|
2522
|
first A second B
|
|
2523
|
In [3]: %parts A
|
|
2523
|
In [3]: %parts A
|
|
2524
|
Incorrect number of arguments: 2 expected.
|
|
2524
|
Incorrect number of arguments: 2 expected.
|
|
2525
|
parts is an alias to: 'echo first %s second %s'
|
|
2525
|
parts is an alias to: 'echo first %s second %s'
|
|
2526
|
|
|
2526
|
|
|
2527
|
Note that %l and %s are mutually exclusive. You can only use one or
|
|
2527
|
Note that %l and %s are mutually exclusive. You can only use one or
|
|
2528
|
the other in your aliases.
|
|
2528
|
the other in your aliases.
|
|
2529
|
|
|
2529
|
|
|
2530
|
Aliases expand Python variables just like system calls using ! or !!
|
|
2530
|
Aliases expand Python variables just like system calls using ! or !!
|
|
2531
|
do: all expressions prefixed with '$' get expanded. For details of
|
|
2531
|
do: all expressions prefixed with '$' get expanded. For details of
|
|
2532
|
the semantic rules, see PEP-215:
|
|
2532
|
the semantic rules, see PEP-215:
|
|
2533
|
http://www.python.org/peps/pep-0215.html. This is the library used by
|
|
2533
|
http://www.python.org/peps/pep-0215.html. This is the library used by
|
|
2534
|
IPython for variable expansion. If you want to access a true shell
|
|
2534
|
IPython for variable expansion. If you want to access a true shell
|
|
2535
|
variable, an extra $ is necessary to prevent its expansion by IPython:
|
|
2535
|
variable, an extra $ is necessary to prevent its expansion by IPython:
|
|
2536
|
|
|
2536
|
|
|
2537
|
In [6]: alias show echo
|
|
2537
|
In [6]: alias show echo
|
|
2538
|
In [7]: PATH='A Python string'
|
|
2538
|
In [7]: PATH='A Python string'
|
|
2539
|
In [8]: show $PATH
|
|
2539
|
In [8]: show $PATH
|
|
2540
|
A Python string
|
|
2540
|
A Python string
|
|
2541
|
In [9]: show $$PATH
|
|
2541
|
In [9]: show $$PATH
|
|
2542
|
/usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
|
|
2542
|
/usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
|
|
2543
|
|
|
2543
|
|
|
2544
|
You can use the alias facility to acess all of $PATH. See the %rehash
|
|
2544
|
You can use the alias facility to acess all of $PATH. See the %rehash
|
|
2545
|
and %rehashx functions, which automatically create aliases for the
|
|
2545
|
and %rehashx functions, which automatically create aliases for the
|
|
2546
|
contents of your $PATH.
|
|
2546
|
contents of your $PATH.
|
|
2547
|
|
|
2547
|
|
|
2548
|
If called with no parameters, %alias prints the current alias table."""
|
|
2548
|
If called with no parameters, %alias prints the current alias table."""
|
|
2549
|
|
|
2549
|
|
|
2550
|
par = parameter_s.strip()
|
|
2550
|
par = parameter_s.strip()
|
|
2551
|
if not par:
|
|
2551
|
if not par:
|
|
2552
|
stored = self.db.get('stored_aliases', {} )
|
|
2552
|
stored = self.db.get('stored_aliases', {} )
|
|
2553
|
aliases = sorted(self.shell.alias_manager.aliases)
|
|
2553
|
aliases = sorted(self.shell.alias_manager.aliases)
|
|
2554
|
# for k, v in stored:
|
|
2554
|
# for k, v in stored:
|
|
2555
|
# atab.append(k, v[0])
|
|
2555
|
# atab.append(k, v[0])
|
|
2556
|
|
|
2556
|
|
|
2557
|
print "Total number of aliases:", len(aliases)
|
|
2557
|
print "Total number of aliases:", len(aliases)
|
|
2558
|
sys.stdout.flush()
|
|
2558
|
sys.stdout.flush()
|
|
2559
|
return aliases
|
|
2559
|
return aliases
|
|
2560
|
|
|
2560
|
|
|
2561
|
# Now try to define a new one
|
|
2561
|
# Now try to define a new one
|
|
2562
|
try:
|
|
2562
|
try:
|
|
2563
|
alias,cmd = par.split(None, 1)
|
|
2563
|
alias,cmd = par.split(None, 1)
|
|
2564
|
except:
|
|
2564
|
except:
|
|
2565
|
print oinspect.getdoc(self.magic_alias)
|
|
2565
|
print oinspect.getdoc(self.magic_alias)
|
|
2566
|
else:
|
|
2566
|
else:
|
|
2567
|
self.shell.alias_manager.soft_define_alias(alias, cmd)
|
|
2567
|
self.shell.alias_manager.soft_define_alias(alias, cmd)
|
|
2568
|
# end magic_alias
|
|
2568
|
# end magic_alias
|
|
2569
|
|
|
2569
|
|
|
2570
|
def magic_unalias(self, parameter_s = ''):
|
|
2570
|
def magic_unalias(self, parameter_s = ''):
|
|
2571
|
"""Remove an alias"""
|
|
2571
|
"""Remove an alias"""
|
|
2572
|
|
|
2572
|
|
|
2573
|
aname = parameter_s.strip()
|
|
2573
|
aname = parameter_s.strip()
|
|
2574
|
self.shell.alias_manager.undefine_alias(aname)
|
|
2574
|
self.shell.alias_manager.undefine_alias(aname)
|
|
2575
|
stored = self.db.get('stored_aliases', {} )
|
|
2575
|
stored = self.db.get('stored_aliases', {} )
|
|
2576
|
if aname in stored:
|
|
2576
|
if aname in stored:
|
|
2577
|
print "Removing %stored alias",aname
|
|
2577
|
print "Removing %stored alias",aname
|
|
2578
|
del stored[aname]
|
|
2578
|
del stored[aname]
|
|
2579
|
self.db['stored_aliases'] = stored
|
|
2579
|
self.db['stored_aliases'] = stored
|
|
2580
|
|
|
2580
|
|
|
2581
|
def magic_rehashx(self, parameter_s = ''):
|
|
2581
|
def magic_rehashx(self, parameter_s = ''):
|
|
2582
|
"""Update the alias table with all executable files in $PATH.
|
|
2582
|
"""Update the alias table with all executable files in $PATH.
|
|
2583
|
|
|
2583
|
|
|
2584
|
This version explicitly checks that every entry in $PATH is a file
|
|
2584
|
This version explicitly checks that every entry in $PATH is a file
|
|
2585
|
with execute access (os.X_OK), so it is much slower than %rehash.
|
|
2585
|
with execute access (os.X_OK), so it is much slower than %rehash.
|
|
2586
|
|
|
2586
|
|
|
2587
|
Under Windows, it checks executability as a match agains a
|
|
2587
|
Under Windows, it checks executability as a match agains a
|
|
2588
|
'|'-separated string of extensions, stored in the IPython config
|
|
2588
|
'|'-separated string of extensions, stored in the IPython config
|
|
2589
|
variable win_exec_ext. This defaults to 'exe|com|bat'.
|
|
2589
|
variable win_exec_ext. This defaults to 'exe|com|bat'.
|
|
2590
|
|
|
2590
|
|
|
2591
|
This function also resets the root module cache of module completer,
|
|
2591
|
This function also resets the root module cache of module completer,
|
|
2592
|
used on slow filesystems.
|
|
2592
|
used on slow filesystems.
|
|
2593
|
"""
|
|
2593
|
"""
|
|
2594
|
from IPython.core.alias import InvalidAliasError
|
|
2594
|
from IPython.core.alias import InvalidAliasError
|
|
2595
|
|
|
2595
|
|
|
2596
|
# for the benefit of module completer in ipy_completers.py
|
|
2596
|
# for the benefit of module completer in ipy_completers.py
|
|
2597
|
del self.db['rootmodules']
|
|
2597
|
del self.db['rootmodules']
|
|
2598
|
|
|
2598
|
|
|
2599
|
path = [os.path.abspath(os.path.expanduser(p)) for p in
|
|
2599
|
path = [os.path.abspath(os.path.expanduser(p)) for p in
|
|
2600
|
os.environ.get('PATH','').split(os.pathsep)]
|
|
2600
|
os.environ.get('PATH','').split(os.pathsep)]
|
|
2601
|
path = filter(os.path.isdir,path)
|
|
2601
|
path = filter(os.path.isdir,path)
|
|
2602
|
|
|
2602
|
|
|
2603
|
syscmdlist = []
|
|
2603
|
syscmdlist = []
|
|
2604
|
# Now define isexec in a cross platform manner.
|
|
2604
|
# Now define isexec in a cross platform manner.
|
|
2605
|
if os.name == 'posix':
|
|
2605
|
if os.name == 'posix':
|
|
2606
|
isexec = lambda fname:os.path.isfile(fname) and \
|
|
2606
|
isexec = lambda fname:os.path.isfile(fname) and \
|
|
2607
|
os.access(fname,os.X_OK)
|
|
2607
|
os.access(fname,os.X_OK)
|
|
2608
|
else:
|
|
2608
|
else:
|
|
2609
|
try:
|
|
2609
|
try:
|
|
2610
|
winext = os.environ['pathext'].replace(';','|').replace('.','')
|
|
2610
|
winext = os.environ['pathext'].replace(';','|').replace('.','')
|
|
2611
|
except KeyError:
|
|
2611
|
except KeyError:
|
|
2612
|
winext = 'exe|com|bat|py'
|
|
2612
|
winext = 'exe|com|bat|py'
|
|
2613
|
if 'py' not in winext:
|
|
2613
|
if 'py' not in winext:
|
|
2614
|
winext += '|py'
|
|
2614
|
winext += '|py'
|
|
2615
|
execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
|
|
2615
|
execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
|
|
2616
|
isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
|
|
2616
|
isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
|
|
2617
|
savedir = os.getcwd()
|
|
2617
|
savedir = os.getcwd()
|
|
2618
|
|
|
2618
|
|
|
2619
|
# Now walk the paths looking for executables to alias.
|
|
2619
|
# Now walk the paths looking for executables to alias.
|
|
2620
|
try:
|
|
2620
|
try:
|
|
2621
|
# write the whole loop for posix/Windows so we don't have an if in
|
|
2621
|
# write the whole loop for posix/Windows so we don't have an if in
|
|
2622
|
# the innermost part
|
|
2622
|
# the innermost part
|
|
2623
|
if os.name == 'posix':
|
|
2623
|
if os.name == 'posix':
|
|
2624
|
for pdir in path:
|
|
2624
|
for pdir in path:
|
|
2625
|
os.chdir(pdir)
|
|
2625
|
os.chdir(pdir)
|
|
2626
|
for ff in os.listdir(pdir):
|
|
2626
|
for ff in os.listdir(pdir):
|
|
2627
|
if isexec(ff):
|
|
2627
|
if isexec(ff):
|
|
2628
|
try:
|
|
2628
|
try:
|
|
2629
|
# Removes dots from the name since ipython
|
|
2629
|
# Removes dots from the name since ipython
|
|
2630
|
# will assume names with dots to be python.
|
|
2630
|
# will assume names with dots to be python.
|
|
2631
|
self.shell.alias_manager.define_alias(
|
|
2631
|
self.shell.alias_manager.define_alias(
|
|
2632
|
ff.replace('.',''), ff)
|
|
2632
|
ff.replace('.',''), ff)
|
|
2633
|
except InvalidAliasError:
|
|
2633
|
except InvalidAliasError:
|
|
2634
|
pass
|
|
2634
|
pass
|
|
2635
|
else:
|
|
2635
|
else:
|
|
2636
|
syscmdlist.append(ff)
|
|
2636
|
syscmdlist.append(ff)
|
|
2637
|
else:
|
|
2637
|
else:
|
|
2638
|
no_alias = self.shell.alias_manager.no_alias
|
|
2638
|
no_alias = self.shell.alias_manager.no_alias
|
|
2639
|
for pdir in path:
|
|
2639
|
for pdir in path:
|
|
2640
|
os.chdir(pdir)
|
|
2640
|
os.chdir(pdir)
|
|
2641
|
for ff in os.listdir(pdir):
|
|
2641
|
for ff in os.listdir(pdir):
|
|
2642
|
base, ext = os.path.splitext(ff)
|
|
2642
|
base, ext = os.path.splitext(ff)
|
|
2643
|
if isexec(ff) and base.lower() not in no_alias:
|
|
2643
|
if isexec(ff) and base.lower() not in no_alias:
|
|
2644
|
if ext.lower() == '.exe':
|
|
2644
|
if ext.lower() == '.exe':
|
|
2645
|
ff = base
|
|
2645
|
ff = base
|
|
2646
|
try:
|
|
2646
|
try:
|
|
2647
|
# Removes dots from the name since ipython
|
|
2647
|
# Removes dots from the name since ipython
|
|
2648
|
# will assume names with dots to be python.
|
|
2648
|
# will assume names with dots to be python.
|
|
2649
|
self.shell.alias_manager.define_alias(
|
|
2649
|
self.shell.alias_manager.define_alias(
|
|
2650
|
base.lower().replace('.',''), ff)
|
|
2650
|
base.lower().replace('.',''), ff)
|
|
2651
|
except InvalidAliasError:
|
|
2651
|
except InvalidAliasError:
|
|
2652
|
pass
|
|
2652
|
pass
|
|
2653
|
syscmdlist.append(ff)
|
|
2653
|
syscmdlist.append(ff)
|
|
2654
|
db = self.db
|
|
2654
|
db = self.db
|
|
2655
|
db['syscmdlist'] = syscmdlist
|
|
2655
|
db['syscmdlist'] = syscmdlist
|
|
2656
|
finally:
|
|
2656
|
finally:
|
|
2657
|
os.chdir(savedir)
|
|
2657
|
os.chdir(savedir)
|
|
2658
|
|
|
2658
|
|
|
2659
|
@testdec.skip_doctest
|
|
2659
|
@testdec.skip_doctest
|
|
2660
|
def magic_pwd(self, parameter_s = ''):
|
|
2660
|
def magic_pwd(self, parameter_s = ''):
|
|
2661
|
"""Return the current working directory path.
|
|
2661
|
"""Return the current working directory path.
|
|
2662
|
|
|
2662
|
|
|
2663
|
Examples
|
|
2663
|
Examples
|
|
2664
|
--------
|
|
2664
|
--------
|
|
2665
|
::
|
|
2665
|
::
|
|
2666
|
|
|
2666
|
|
|
2667
|
In [9]: pwd
|
|
2667
|
In [9]: pwd
|
|
2668
|
Out[9]: '/home/tsuser/sprint/ipython'
|
|
2668
|
Out[9]: '/home/tsuser/sprint/ipython'
|
|
2669
|
"""
|
|
2669
|
"""
|
|
2670
|
return os.getcwd()
|
|
2670
|
return os.getcwd()
|
|
2671
|
|
|
2671
|
|
|
2672
|
@testdec.skip_doctest
|
|
2672
|
@testdec.skip_doctest
|
|
2673
|
def magic_cd(self, parameter_s=''):
|
|
2673
|
def magic_cd(self, parameter_s=''):
|
|
2674
|
"""Change the current working directory.
|
|
2674
|
"""Change the current working directory.
|
|
2675
|
|
|
2675
|
|
|
2676
|
This command automatically maintains an internal list of directories
|
|
2676
|
This command automatically maintains an internal list of directories
|
|
2677
|
you visit during your IPython session, in the variable _dh. The
|
|
2677
|
you visit during your IPython session, in the variable _dh. The
|
|
2678
|
command %dhist shows this history nicely formatted. You can also
|
|
2678
|
command %dhist shows this history nicely formatted. You can also
|
|
2679
|
do 'cd -<tab>' to see directory history conveniently.
|
|
2679
|
do 'cd -<tab>' to see directory history conveniently.
|
|
2680
|
|
|
2680
|
|
|
2681
|
Usage:
|
|
2681
|
Usage:
|
|
2682
|
|
|
2682
|
|
|
2683
|
cd 'dir': changes to directory 'dir'.
|
|
2683
|
cd 'dir': changes to directory 'dir'.
|
|
2684
|
|
|
2684
|
|
|
2685
|
cd -: changes to the last visited directory.
|
|
2685
|
cd -: changes to the last visited directory.
|
|
2686
|
|
|
2686
|
|
|
2687
|
cd -<n>: changes to the n-th directory in the directory history.
|
|
2687
|
cd -<n>: changes to the n-th directory in the directory history.
|
|
2688
|
|
|
2688
|
|
|
2689
|
cd --foo: change to directory that matches 'foo' in history
|
|
2689
|
cd --foo: change to directory that matches 'foo' in history
|
|
2690
|
|
|
2690
|
|
|
2691
|
cd -b <bookmark_name>: jump to a bookmark set by %bookmark
|
|
2691
|
cd -b <bookmark_name>: jump to a bookmark set by %bookmark
|
|
2692
|
(note: cd <bookmark_name> is enough if there is no
|
|
2692
|
(note: cd <bookmark_name> is enough if there is no
|
|
2693
|
directory <bookmark_name>, but a bookmark with the name exists.)
|
|
2693
|
directory <bookmark_name>, but a bookmark with the name exists.)
|
|
2694
|
'cd -b <tab>' allows you to tab-complete bookmark names.
|
|
2694
|
'cd -b <tab>' allows you to tab-complete bookmark names.
|
|
2695
|
|
|
2695
|
|
|
2696
|
Options:
|
|
2696
|
Options:
|
|
2697
|
|
|
2697
|
|
|
2698
|
-q: quiet. Do not print the working directory after the cd command is
|
|
2698
|
-q: quiet. Do not print the working directory after the cd command is
|
|
2699
|
executed. By default IPython's cd command does print this directory,
|
|
2699
|
executed. By default IPython's cd command does print this directory,
|
|
2700
|
since the default prompts do not display path information.
|
|
2700
|
since the default prompts do not display path information.
|
|
2701
|
|
|
2701
|
|
|
2702
|
Note that !cd doesn't work for this purpose because the shell where
|
|
2702
|
Note that !cd doesn't work for this purpose because the shell where
|
|
2703
|
!command runs is immediately discarded after executing 'command'.
|
|
2703
|
!command runs is immediately discarded after executing 'command'.
|
|
2704
|
|
|
2704
|
|
|
2705
|
Examples
|
|
2705
|
Examples
|
|
2706
|
--------
|
|
2706
|
--------
|
|
2707
|
::
|
|
2707
|
::
|
|
2708
|
|
|
2708
|
|
|
2709
|
In [10]: cd parent/child
|
|
2709
|
In [10]: cd parent/child
|
|
2710
|
/home/tsuser/parent/child
|
|
2710
|
/home/tsuser/parent/child
|
|
2711
|
"""
|
|
2711
|
"""
|
|
2712
|
|
|
2712
|
|
|
2713
|
parameter_s = parameter_s.strip()
|
|
2713
|
parameter_s = parameter_s.strip()
|
|
2714
|
#bkms = self.shell.persist.get("bookmarks",{})
|
|
2714
|
#bkms = self.shell.persist.get("bookmarks",{})
|
|
2715
|
|
|
2715
|
|
|
2716
|
oldcwd = os.getcwd()
|
|
2716
|
oldcwd = os.getcwd()
|
|
2717
|
numcd = re.match(r'(-)(\d+)$',parameter_s)
|
|
2717
|
numcd = re.match(r'(-)(\d+)$',parameter_s)
|
|
2718
|
# jump in directory history by number
|
|
2718
|
# jump in directory history by number
|
|
2719
|
if numcd:
|
|
2719
|
if numcd:
|
|
2720
|
nn = int(numcd.group(2))
|
|
2720
|
nn = int(numcd.group(2))
|
|
2721
|
try:
|
|
2721
|
try:
|
|
2722
|
ps = self.shell.user_ns['_dh'][nn]
|
|
2722
|
ps = self.shell.user_ns['_dh'][nn]
|
|
2723
|
except IndexError:
|
|
2723
|
except IndexError:
|
|
2724
|
print 'The requested directory does not exist in history.'
|
|
2724
|
print 'The requested directory does not exist in history.'
|
|
2725
|
return
|
|
2725
|
return
|
|
2726
|
else:
|
|
2726
|
else:
|
|
2727
|
opts = {}
|
|
2727
|
opts = {}
|
|
2728
|
elif parameter_s.startswith('--'):
|
|
2728
|
elif parameter_s.startswith('--'):
|
|
2729
|
ps = None
|
|
2729
|
ps = None
|
|
2730
|
fallback = None
|
|
2730
|
fallback = None
|
|
2731
|
pat = parameter_s[2:]
|
|
2731
|
pat = parameter_s[2:]
|
|
2732
|
dh = self.shell.user_ns['_dh']
|
|
2732
|
dh = self.shell.user_ns['_dh']
|
|
2733
|
# first search only by basename (last component)
|
|
2733
|
# first search only by basename (last component)
|
|
2734
|
for ent in reversed(dh):
|
|
2734
|
for ent in reversed(dh):
|
|
2735
|
if pat in os.path.basename(ent) and os.path.isdir(ent):
|
|
2735
|
if pat in os.path.basename(ent) and os.path.isdir(ent):
|
|
2736
|
ps = ent
|
|
2736
|
ps = ent
|
|
2737
|
break
|
|
2737
|
break
|
|
2738
|
|
|
2738
|
|
|
2739
|
if fallback is None and pat in ent and os.path.isdir(ent):
|
|
2739
|
if fallback is None and pat in ent and os.path.isdir(ent):
|
|
2740
|
fallback = ent
|
|
2740
|
fallback = ent
|
|
2741
|
|
|
2741
|
|
|
2742
|
# if we have no last part match, pick the first full path match
|
|
2742
|
# if we have no last part match, pick the first full path match
|
|
2743
|
if ps is None:
|
|
2743
|
if ps is None:
|
|
2744
|
ps = fallback
|
|
2744
|
ps = fallback
|
|
2745
|
|
|
2745
|
|
|
2746
|
if ps is None:
|
|
2746
|
if ps is None:
|
|
2747
|
print "No matching entry in directory history"
|
|
2747
|
print "No matching entry in directory history"
|
|
2748
|
return
|
|
2748
|
return
|
|
2749
|
else:
|
|
2749
|
else:
|
|
2750
|
opts = {}
|
|
2750
|
opts = {}
|
|
2751
|
|
|
2751
|
|
|
2752
|
|
|
2752
|
|
|
2753
|
else:
|
|
2753
|
else:
|
|
2754
|
#turn all non-space-escaping backslashes to slashes,
|
|
2754
|
#turn all non-space-escaping backslashes to slashes,
|
|
2755
|
# for c:\windows\directory\names\
|
|
2755
|
# for c:\windows\directory\names\
|
|
2756
|
parameter_s = re.sub(r'\\(?! )','/', parameter_s)
|
|
2756
|
parameter_s = re.sub(r'\\(?! )','/', parameter_s)
|
|
2757
|
opts,ps = self.parse_options(parameter_s,'qb',mode='string')
|
|
2757
|
opts,ps = self.parse_options(parameter_s,'qb',mode='string')
|
|
2758
|
# jump to previous
|
|
2758
|
# jump to previous
|
|
2759
|
if ps == '-':
|
|
2759
|
if ps == '-':
|
|
2760
|
try:
|
|
2760
|
try:
|
|
2761
|
ps = self.shell.user_ns['_dh'][-2]
|
|
2761
|
ps = self.shell.user_ns['_dh'][-2]
|
|
2762
|
except IndexError:
|
|
2762
|
except IndexError:
|
|
2763
|
raise UsageError('%cd -: No previous directory to change to.')
|
|
2763
|
raise UsageError('%cd -: No previous directory to change to.')
|
|
2764
|
# jump to bookmark if needed
|
|
2764
|
# jump to bookmark if needed
|
|
2765
|
else:
|
|
2765
|
else:
|
|
2766
|
if not os.path.isdir(ps) or opts.has_key('b'):
|
|
2766
|
if not os.path.isdir(ps) or opts.has_key('b'):
|
|
2767
|
bkms = self.db.get('bookmarks', {})
|
|
2767
|
bkms = self.db.get('bookmarks', {})
|
|
2768
|
|
|
2768
|
|
|
2769
|
if bkms.has_key(ps):
|
|
2769
|
if bkms.has_key(ps):
|
|
2770
|
target = bkms[ps]
|
|
2770
|
target = bkms[ps]
|
|
2771
|
print '(bookmark:%s) -> %s' % (ps,target)
|
|
2771
|
print '(bookmark:%s) -> %s' % (ps,target)
|
|
2772
|
ps = target
|
|
2772
|
ps = target
|
|
2773
|
else:
|
|
2773
|
else:
|
|
2774
|
if opts.has_key('b'):
|
|
2774
|
if opts.has_key('b'):
|
|
2775
|
raise UsageError("Bookmark '%s' not found. "
|
|
2775
|
raise UsageError("Bookmark '%s' not found. "
|
|
2776
|
"Use '%%bookmark -l' to see your bookmarks." % ps)
|
|
2776
|
"Use '%%bookmark -l' to see your bookmarks." % ps)
|
|
2777
|
|
|
2777
|
|
|
2778
|
# at this point ps should point to the target dir
|
|
2778
|
# at this point ps should point to the target dir
|
|
2779
|
if ps:
|
|
2779
|
if ps:
|
|
2780
|
try:
|
|
2780
|
try:
|
|
2781
|
os.chdir(os.path.expanduser(ps))
|
|
2781
|
os.chdir(os.path.expanduser(ps))
|
|
2782
|
if hasattr(self.shell, 'term_title') and self.shell.term_title:
|
|
2782
|
if hasattr(self.shell, 'term_title') and self.shell.term_title:
|
|
2783
|
set_term_title('IPython: ' + abbrev_cwd())
|
|
2783
|
set_term_title('IPython: ' + abbrev_cwd())
|
|
2784
|
except OSError:
|
|
2784
|
except OSError:
|
|
2785
|
print sys.exc_info()[1]
|
|
2785
|
print sys.exc_info()[1]
|
|
2786
|
else:
|
|
2786
|
else:
|
|
2787
|
cwd = os.getcwd()
|
|
2787
|
cwd = os.getcwd()
|
|
2788
|
dhist = self.shell.user_ns['_dh']
|
|
2788
|
dhist = self.shell.user_ns['_dh']
|
|
2789
|
if oldcwd != cwd:
|
|
2789
|
if oldcwd != cwd:
|
|
2790
|
dhist.append(cwd)
|
|
2790
|
dhist.append(cwd)
|
|
2791
|
self.db['dhist'] = compress_dhist(dhist)[-100:]
|
|
2791
|
self.db['dhist'] = compress_dhist(dhist)[-100:]
|
|
2792
|
|
|
2792
|
|
|
2793
|
else:
|
|
2793
|
else:
|
|
2794
|
os.chdir(self.shell.home_dir)
|
|
2794
|
os.chdir(self.shell.home_dir)
|
|
2795
|
if hasattr(self.shell, 'term_title') and self.shell.term_title:
|
|
2795
|
if hasattr(self.shell, 'term_title') and self.shell.term_title:
|
|
2796
|
set_term_title('IPython: ' + '~')
|
|
2796
|
set_term_title('IPython: ' + '~')
|
|
2797
|
cwd = os.getcwd()
|
|
2797
|
cwd = os.getcwd()
|
|
2798
|
dhist = self.shell.user_ns['_dh']
|
|
2798
|
dhist = self.shell.user_ns['_dh']
|
|
2799
|
|
|
2799
|
|
|
2800
|
if oldcwd != cwd:
|
|
2800
|
if oldcwd != cwd:
|
|
2801
|
dhist.append(cwd)
|
|
2801
|
dhist.append(cwd)
|
|
2802
|
self.db['dhist'] = compress_dhist(dhist)[-100:]
|
|
2802
|
self.db['dhist'] = compress_dhist(dhist)[-100:]
|
|
2803
|
if not 'q' in opts and self.shell.user_ns['_dh']:
|
|
2803
|
if not 'q' in opts and self.shell.user_ns['_dh']:
|
|
2804
|
print self.shell.user_ns['_dh'][-1]
|
|
2804
|
print self.shell.user_ns['_dh'][-1]
|
|
2805
|
|
|
2805
|
|
|
2806
|
|
|
2806
|
|
|
2807
|
def magic_env(self, parameter_s=''):
|
|
2807
|
def magic_env(self, parameter_s=''):
|
|
2808
|
"""List environment variables."""
|
|
2808
|
"""List environment variables."""
|
|
2809
|
|
|
2809
|
|
|
2810
|
return os.environ.data
|
|
2810
|
return os.environ.data
|
|
2811
|
|
|
2811
|
|
|
2812
|
def magic_pushd(self, parameter_s=''):
|
|
2812
|
def magic_pushd(self, parameter_s=''):
|
|
2813
|
"""Place the current dir on stack and change directory.
|
|
2813
|
"""Place the current dir on stack and change directory.
|
|
2814
|
|
|
2814
|
|
|
2815
|
Usage:\\
|
|
2815
|
Usage:\\
|
|
2816
|
%pushd ['dirname']
|
|
2816
|
%pushd ['dirname']
|
|
2817
|
"""
|
|
2817
|
"""
|
|
2818
|
|
|
2818
|
|
|
2819
|
dir_s = self.shell.dir_stack
|
|
2819
|
dir_s = self.shell.dir_stack
|
|
2820
|
tgt = os.path.expanduser(parameter_s)
|
|
2820
|
tgt = os.path.expanduser(parameter_s)
|
|
2821
|
cwd = os.getcwd().replace(self.home_dir,'~')
|
|
2821
|
cwd = os.getcwd().replace(self.home_dir,'~')
|
|
2822
|
if tgt:
|
|
2822
|
if tgt:
|
|
2823
|
self.magic_cd(parameter_s)
|
|
2823
|
self.magic_cd(parameter_s)
|
|
2824
|
dir_s.insert(0,cwd)
|
|
2824
|
dir_s.insert(0,cwd)
|
|
2825
|
return self.magic_dirs()
|
|
2825
|
return self.magic_dirs()
|
|
2826
|
|
|
2826
|
|
|
2827
|
def magic_popd(self, parameter_s=''):
|
|
2827
|
def magic_popd(self, parameter_s=''):
|
|
2828
|
"""Change to directory popped off the top of the stack.
|
|
2828
|
"""Change to directory popped off the top of the stack.
|
|
2829
|
"""
|
|
2829
|
"""
|
|
2830
|
if not self.shell.dir_stack:
|
|
2830
|
if not self.shell.dir_stack:
|
|
2831
|
raise UsageError("%popd on empty stack")
|
|
2831
|
raise UsageError("%popd on empty stack")
|
|
2832
|
top = self.shell.dir_stack.pop(0)
|
|
2832
|
top = self.shell.dir_stack.pop(0)
|
|
2833
|
self.magic_cd(top)
|
|
2833
|
self.magic_cd(top)
|
|
2834
|
print "popd ->",top
|
|
2834
|
print "popd ->",top
|
|
2835
|
|
|
2835
|
|
|
2836
|
def magic_dirs(self, parameter_s=''):
|
|
2836
|
def magic_dirs(self, parameter_s=''):
|
|
2837
|
"""Return the current directory stack."""
|
|
2837
|
"""Return the current directory stack."""
|
|
2838
|
|
|
2838
|
|
|
2839
|
return self.shell.dir_stack
|
|
2839
|
return self.shell.dir_stack
|
|
2840
|
|
|
2840
|
|
|
2841
|
def magic_dhist(self, parameter_s=''):
|
|
2841
|
def magic_dhist(self, parameter_s=''):
|
|
2842
|
"""Print your history of visited directories.
|
|
2842
|
"""Print your history of visited directories.
|
|
2843
|
|
|
2843
|
|
|
2844
|
%dhist -> print full history\\
|
|
2844
|
%dhist -> print full history\\
|
|
2845
|
%dhist n -> print last n entries only\\
|
|
2845
|
%dhist n -> print last n entries only\\
|
|
2846
|
%dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
|
|
2846
|
%dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
|
|
2847
|
|
|
2847
|
|
|
2848
|
This history is automatically maintained by the %cd command, and
|
|
2848
|
This history is automatically maintained by the %cd command, and
|
|
2849
|
always available as the global list variable _dh. You can use %cd -<n>
|
|
2849
|
always available as the global list variable _dh. You can use %cd -<n>
|
|
2850
|
to go to directory number <n>.
|
|
2850
|
to go to directory number <n>.
|
|
2851
|
|
|
2851
|
|
|
2852
|
Note that most of time, you should view directory history by entering
|
|
2852
|
Note that most of time, you should view directory history by entering
|
|
2853
|
cd -<TAB>.
|
|
2853
|
cd -<TAB>.
|
|
2854
|
|
|
2854
|
|
|
2855
|
"""
|
|
2855
|
"""
|
|
2856
|
|
|
2856
|
|
|
2857
|
dh = self.shell.user_ns['_dh']
|
|
2857
|
dh = self.shell.user_ns['_dh']
|
|
2858
|
if parameter_s:
|
|
2858
|
if parameter_s:
|
|
2859
|
try:
|
|
2859
|
try:
|
|
2860
|
args = map(int,parameter_s.split())
|
|
2860
|
args = map(int,parameter_s.split())
|
|
2861
|
except:
|
|
2861
|
except:
|
|
2862
|
self.arg_err(Magic.magic_dhist)
|
|
2862
|
self.arg_err(Magic.magic_dhist)
|
|
2863
|
return
|
|
2863
|
return
|
|
2864
|
if len(args) == 1:
|
|
2864
|
if len(args) == 1:
|
|
2865
|
ini,fin = max(len(dh)-(args[0]),0),len(dh)
|
|
2865
|
ini,fin = max(len(dh)-(args[0]),0),len(dh)
|
|
2866
|
elif len(args) == 2:
|
|
2866
|
elif len(args) == 2:
|
|
2867
|
ini,fin = args
|
|
2867
|
ini,fin = args
|
|
2868
|
else:
|
|
2868
|
else:
|
|
2869
|
self.arg_err(Magic.magic_dhist)
|
|
2869
|
self.arg_err(Magic.magic_dhist)
|
|
2870
|
return
|
|
2870
|
return
|
|
2871
|
else:
|
|
2871
|
else:
|
|
2872
|
ini,fin = 0,len(dh)
|
|
2872
|
ini,fin = 0,len(dh)
|
|
2873
|
nlprint(dh,
|
|
2873
|
nlprint(dh,
|
|
2874
|
header = 'Directory history (kept in _dh)',
|
|
2874
|
header = 'Directory history (kept in _dh)',
|
|
2875
|
start=ini,stop=fin)
|
|
2875
|
start=ini,stop=fin)
|
|
2876
|
|
|
2876
|
|
|
2877
|
@testdec.skip_doctest
|
|
2877
|
@testdec.skip_doctest
|
|
2878
|
def magic_sc(self, parameter_s=''):
|
|
2878
|
def magic_sc(self, parameter_s=''):
|
|
2879
|
"""Shell capture - execute a shell command and capture its output.
|
|
2879
|
"""Shell capture - execute a shell command and capture its output.
|
|
2880
|
|
|
2880
|
|
|
2881
|
DEPRECATED. Suboptimal, retained for backwards compatibility.
|
|
2881
|
DEPRECATED. Suboptimal, retained for backwards compatibility.
|
|
2882
|
|
|
2882
|
|
|
2883
|
You should use the form 'var = !command' instead. Example:
|
|
2883
|
You should use the form 'var = !command' instead. Example:
|
|
2884
|
|
|
2884
|
|
|
2885
|
"%sc -l myfiles = ls ~" should now be written as
|
|
2885
|
"%sc -l myfiles = ls ~" should now be written as
|
|
2886
|
|
|
2886
|
|
|
2887
|
"myfiles = !ls ~"
|
|
2887
|
"myfiles = !ls ~"
|
|
2888
|
|
|
2888
|
|
|
2889
|
myfiles.s, myfiles.l and myfiles.n still apply as documented
|
|
2889
|
myfiles.s, myfiles.l and myfiles.n still apply as documented
|
|
2890
|
below.
|
|
2890
|
below.
|
|
2891
|
|
|
2891
|
|
|
2892
|
--
|
|
2892
|
--
|
|
2893
|
%sc [options] varname=command
|
|
2893
|
%sc [options] varname=command
|
|
2894
|
|
|
2894
|
|
|
2895
|
IPython will run the given command using commands.getoutput(), and
|
|
2895
|
IPython will run the given command using commands.getoutput(), and
|
|
2896
|
will then update the user's interactive namespace with a variable
|
|
2896
|
will then update the user's interactive namespace with a variable
|
|
2897
|
called varname, containing the value of the call. Your command can
|
|
2897
|
called varname, containing the value of the call. Your command can
|
|
2898
|
contain shell wildcards, pipes, etc.
|
|
2898
|
contain shell wildcards, pipes, etc.
|
|
2899
|
|
|
2899
|
|
|
2900
|
The '=' sign in the syntax is mandatory, and the variable name you
|
|
2900
|
The '=' sign in the syntax is mandatory, and the variable name you
|
|
2901
|
supply must follow Python's standard conventions for valid names.
|
|
2901
|
supply must follow Python's standard conventions for valid names.
|
|
2902
|
|
|
2902
|
|
|
2903
|
(A special format without variable name exists for internal use)
|
|
2903
|
(A special format without variable name exists for internal use)
|
|
2904
|
|
|
2904
|
|
|
2905
|
Options:
|
|
2905
|
Options:
|
|
2906
|
|
|
2906
|
|
|
2907
|
-l: list output. Split the output on newlines into a list before
|
|
2907
|
-l: list output. Split the output on newlines into a list before
|
|
2908
|
assigning it to the given variable. By default the output is stored
|
|
2908
|
assigning it to the given variable. By default the output is stored
|
|
2909
|
as a single string.
|
|
2909
|
as a single string.
|
|
2910
|
|
|
2910
|
|
|
2911
|
-v: verbose. Print the contents of the variable.
|
|
2911
|
-v: verbose. Print the contents of the variable.
|
|
2912
|
|
|
2912
|
|
|
2913
|
In most cases you should not need to split as a list, because the
|
|
2913
|
In most cases you should not need to split as a list, because the
|
|
2914
|
returned value is a special type of string which can automatically
|
|
2914
|
returned value is a special type of string which can automatically
|
|
2915
|
provide its contents either as a list (split on newlines) or as a
|
|
2915
|
provide its contents either as a list (split on newlines) or as a
|
|
2916
|
space-separated string. These are convenient, respectively, either
|
|
2916
|
space-separated string. These are convenient, respectively, either
|
|
2917
|
for sequential processing or to be passed to a shell command.
|
|
2917
|
for sequential processing or to be passed to a shell command.
|
|
2918
|
|
|
2918
|
|
|
2919
|
For example:
|
|
2919
|
For example:
|
|
2920
|
|
|
2920
|
|
|
2921
|
# all-random
|
|
2921
|
# all-random
|
|
2922
|
|
|
2922
|
|
|
2923
|
# Capture into variable a
|
|
2923
|
# Capture into variable a
|
|
2924
|
In [1]: sc a=ls *py
|
|
2924
|
In [1]: sc a=ls *py
|
|
2925
|
|
|
2925
|
|
|
2926
|
# a is a string with embedded newlines
|
|
2926
|
# a is a string with embedded newlines
|
|
2927
|
In [2]: a
|
|
2927
|
In [2]: a
|
|
2928
|
Out[2]: 'setup.py\\nwin32_manual_post_install.py'
|
|
2928
|
Out[2]: 'setup.py\\nwin32_manual_post_install.py'
|
|
2929
|
|
|
2929
|
|
|
2930
|
# which can be seen as a list:
|
|
2930
|
# which can be seen as a list:
|
|
2931
|
In [3]: a.l
|
|
2931
|
In [3]: a.l
|
|
2932
|
Out[3]: ['setup.py', 'win32_manual_post_install.py']
|
|
2932
|
Out[3]: ['setup.py', 'win32_manual_post_install.py']
|
|
2933
|
|
|
2933
|
|
|
2934
|
# or as a whitespace-separated string:
|
|
2934
|
# or as a whitespace-separated string:
|
|
2935
|
In [4]: a.s
|
|
2935
|
In [4]: a.s
|
|
2936
|
Out[4]: 'setup.py win32_manual_post_install.py'
|
|
2936
|
Out[4]: 'setup.py win32_manual_post_install.py'
|
|
2937
|
|
|
2937
|
|
|
2938
|
# a.s is useful to pass as a single command line:
|
|
2938
|
# a.s is useful to pass as a single command line:
|
|
2939
|
In [5]: !wc -l $a.s
|
|
2939
|
In [5]: !wc -l $a.s
|
|
2940
|
146 setup.py
|
|
2940
|
146 setup.py
|
|
2941
|
130 win32_manual_post_install.py
|
|
2941
|
130 win32_manual_post_install.py
|
|
2942
|
276 total
|
|
2942
|
276 total
|
|
2943
|
|
|
2943
|
|
|
2944
|
# while the list form is useful to loop over:
|
|
2944
|
# while the list form is useful to loop over:
|
|
2945
|
In [6]: for f in a.l:
|
|
2945
|
In [6]: for f in a.l:
|
|
2946
|
...: !wc -l $f
|
|
2946
|
...: !wc -l $f
|
|
2947
|
...:
|
|
2947
|
...:
|
|
2948
|
146 setup.py
|
|
2948
|
146 setup.py
|
|
2949
|
130 win32_manual_post_install.py
|
|
2949
|
130 win32_manual_post_install.py
|
|
2950
|
|
|
2950
|
|
|
2951
|
Similiarly, the lists returned by the -l option are also special, in
|
|
2951
|
Similiarly, the lists returned by the -l option are also special, in
|
|
2952
|
the sense that you can equally invoke the .s attribute on them to
|
|
2952
|
the sense that you can equally invoke the .s attribute on them to
|
|
2953
|
automatically get a whitespace-separated string from their contents:
|
|
2953
|
automatically get a whitespace-separated string from their contents:
|
|
2954
|
|
|
2954
|
|
|
2955
|
In [7]: sc -l b=ls *py
|
|
2955
|
In [7]: sc -l b=ls *py
|
|
2956
|
|
|
2956
|
|
|
2957
|
In [8]: b
|
|
2957
|
In [8]: b
|
|
2958
|
Out[8]: ['setup.py', 'win32_manual_post_install.py']
|
|
2958
|
Out[8]: ['setup.py', 'win32_manual_post_install.py']
|
|
2959
|
|
|
2959
|
|
|
2960
|
In [9]: b.s
|
|
2960
|
In [9]: b.s
|
|
2961
|
Out[9]: 'setup.py win32_manual_post_install.py'
|
|
2961
|
Out[9]: 'setup.py win32_manual_post_install.py'
|
|
2962
|
|
|
2962
|
|
|
2963
|
In summary, both the lists and strings used for ouptut capture have
|
|
2963
|
In summary, both the lists and strings used for ouptut capture have
|
|
2964
|
the following special attributes:
|
|
2964
|
the following special attributes:
|
|
2965
|
|
|
2965
|
|
|
2966
|
.l (or .list) : value as list.
|
|
2966
|
.l (or .list) : value as list.
|
|
2967
|
.n (or .nlstr): value as newline-separated string.
|
|
2967
|
.n (or .nlstr): value as newline-separated string.
|
|
2968
|
.s (or .spstr): value as space-separated string.
|
|
2968
|
.s (or .spstr): value as space-separated string.
|
|
2969
|
"""
|
|
2969
|
"""
|
|
2970
|
|
|
2970
|
|
|
2971
|
opts,args = self.parse_options(parameter_s,'lv')
|
|
2971
|
opts,args = self.parse_options(parameter_s,'lv')
|
|
2972
|
# Try to get a variable name and command to run
|
|
2972
|
# Try to get a variable name and command to run
|
|
2973
|
try:
|
|
2973
|
try:
|
|
2974
|
# the variable name must be obtained from the parse_options
|
|
2974
|
# the variable name must be obtained from the parse_options
|
|
2975
|
# output, which uses shlex.split to strip options out.
|
|
2975
|
# output, which uses shlex.split to strip options out.
|
|
2976
|
var,_ = args.split('=',1)
|
|
2976
|
var,_ = args.split('=',1)
|
|
2977
|
var = var.strip()
|
|
2977
|
var = var.strip()
|
|
2978
|
# But the the command has to be extracted from the original input
|
|
2978
|
# But the the command has to be extracted from the original input
|
|
2979
|
# parameter_s, not on what parse_options returns, to avoid the
|
|
2979
|
# parameter_s, not on what parse_options returns, to avoid the
|
|
2980
|
# quote stripping which shlex.split performs on it.
|
|
2980
|
# quote stripping which shlex.split performs on it.
|
|
2981
|
_,cmd = parameter_s.split('=',1)
|
|
2981
|
_,cmd = parameter_s.split('=',1)
|
|
2982
|
except ValueError:
|
|
2982
|
except ValueError:
|
|
2983
|
var,cmd = '',''
|
|
2983
|
var,cmd = '',''
|
|
2984
|
# If all looks ok, proceed
|
|
2984
|
# If all looks ok, proceed
|
|
2985
|
split = 'l' in opts
|
|
2985
|
split = 'l' in opts
|
|
2986
|
out = self.shell.getoutput(cmd, split=split)
|
|
2986
|
out = self.shell.getoutput(cmd, split=split)
|
|
2987
|
if opts.has_key('v'):
|
|
2987
|
if opts.has_key('v'):
|
|
2988
|
print '%s ==\n%s' % (var,pformat(out))
|
|
2988
|
print '%s ==\n%s' % (var,pformat(out))
|
|
2989
|
if var:
|
|
2989
|
if var:
|
|
2990
|
self.shell.user_ns.update({var:out})
|
|
2990
|
self.shell.user_ns.update({var:out})
|
|
2991
|
else:
|
|
2991
|
else:
|
|
2992
|
return out
|
|
2992
|
return out
|
|
2993
|
|
|
2993
|
|
|
2994
|
def magic_sx(self, parameter_s=''):
|
|
2994
|
def magic_sx(self, parameter_s=''):
|
|
2995
|
"""Shell execute - run a shell command and capture its output.
|
|
2995
|
"""Shell execute - run a shell command and capture its output.
|
|
2996
|
|
|
2996
|
|
|
2997
|
%sx command
|
|
2997
|
%sx command
|
|
2998
|
|
|
2998
|
|
|
2999
|
IPython will run the given command using commands.getoutput(), and
|
|
2999
|
IPython will run the given command using commands.getoutput(), and
|
|
3000
|
return the result formatted as a list (split on '\\n'). Since the
|
|
3000
|
return the result formatted as a list (split on '\\n'). Since the
|
|
3001
|
output is _returned_, it will be stored in ipython's regular output
|
|
3001
|
output is _returned_, it will be stored in ipython's regular output
|
|
3002
|
cache Out[N] and in the '_N' automatic variables.
|
|
3002
|
cache Out[N] and in the '_N' automatic variables.
|
|
3003
|
|
|
3003
|
|
|
3004
|
Notes:
|
|
3004
|
Notes:
|
|
3005
|
|
|
3005
|
|
|
3006
|
1) If an input line begins with '!!', then %sx is automatically
|
|
3006
|
1) If an input line begins with '!!', then %sx is automatically
|
|
3007
|
invoked. That is, while:
|
|
3007
|
invoked. That is, while:
|
|
3008
|
!ls
|
|
3008
|
!ls
|
|
3009
|
causes ipython to simply issue system('ls'), typing
|
|
3009
|
causes ipython to simply issue system('ls'), typing
|
|
3010
|
!!ls
|
|
3010
|
!!ls
|
|
3011
|
is a shorthand equivalent to:
|
|
3011
|
is a shorthand equivalent to:
|
|
3012
|
%sx ls
|
|
3012
|
%sx ls
|
|
3013
|
|
|
3013
|
|
|
3014
|
2) %sx differs from %sc in that %sx automatically splits into a list,
|
|
3014
|
2) %sx differs from %sc in that %sx automatically splits into a list,
|
|
3015
|
like '%sc -l'. The reason for this is to make it as easy as possible
|
|
3015
|
like '%sc -l'. The reason for this is to make it as easy as possible
|
|
3016
|
to process line-oriented shell output via further python commands.
|
|
3016
|
to process line-oriented shell output via further python commands.
|
|
3017
|
%sc is meant to provide much finer control, but requires more
|
|
3017
|
%sc is meant to provide much finer control, but requires more
|
|
3018
|
typing.
|
|
3018
|
typing.
|
|
3019
|
|
|
3019
|
|
|
3020
|
3) Just like %sc -l, this is a list with special attributes:
|
|
3020
|
3) Just like %sc -l, this is a list with special attributes:
|
|
3021
|
|
|
3021
|
|
|
3022
|
.l (or .list) : value as list.
|
|
3022
|
.l (or .list) : value as list.
|
|
3023
|
.n (or .nlstr): value as newline-separated string.
|
|
3023
|
.n (or .nlstr): value as newline-separated string.
|
|
3024
|
.s (or .spstr): value as whitespace-separated string.
|
|
3024
|
.s (or .spstr): value as whitespace-separated string.
|
|
3025
|
|
|
3025
|
|
|
3026
|
This is very useful when trying to use such lists as arguments to
|
|
3026
|
This is very useful when trying to use such lists as arguments to
|
|
3027
|
system commands."""
|
|
3027
|
system commands."""
|
|
3028
|
|
|
3028
|
|
|
3029
|
if parameter_s:
|
|
3029
|
if parameter_s:
|
|
3030
|
return self.shell.getoutput(parameter_s)
|
|
3030
|
return self.shell.getoutput(parameter_s)
|
|
3031
|
|
|
3031
|
|
|
3032
|
def magic_r(self, parameter_s=''):
|
|
3032
|
def magic_r(self, parameter_s=''):
|
|
3033
|
"""Repeat previous input.
|
|
3033
|
"""Repeat previous input.
|
|
3034
|
|
|
3034
|
|
|
3035
|
Note: Consider using the more powerfull %rep instead!
|
|
3035
|
Note: Consider using the more powerfull %rep instead!
|
|
3036
|
|
|
3036
|
|
|
3037
|
If given an argument, repeats the previous command which starts with
|
|
3037
|
If given an argument, repeats the previous command which starts with
|
|
3038
|
the same string, otherwise it just repeats the previous input.
|
|
3038
|
the same string, otherwise it just repeats the previous input.
|
|
3039
|
|
|
3039
|
|
|
3040
|
Shell escaped commands (with ! as first character) are not recognized
|
|
3040
|
Shell escaped commands (with ! as first character) are not recognized
|
|
3041
|
by this system, only pure python code and magic commands.
|
|
3041
|
by this system, only pure python code and magic commands.
|
|
3042
|
"""
|
|
3042
|
"""
|
|
3043
|
|
|
3043
|
|
|
3044
|
start = parameter_s.strip()
|
|
3044
|
start = parameter_s.strip()
|
|
3045
|
esc_magic = ESC_MAGIC
|
|
3045
|
esc_magic = ESC_MAGIC
|
|
3046
|
# Identify magic commands even if automagic is on (which means
|
|
3046
|
# Identify magic commands even if automagic is on (which means
|
|
3047
|
# the in-memory version is different from that typed by the user).
|
|
3047
|
# the in-memory version is different from that typed by the user).
|
|
3048
|
if self.shell.automagic:
|
|
3048
|
if self.shell.automagic:
|
|
3049
|
start_magic = esc_magic+start
|
|
3049
|
start_magic = esc_magic+start
|
|
3050
|
else:
|
|
3050
|
else:
|
|
3051
|
start_magic = start
|
|
3051
|
start_magic = start
|
|
3052
|
# Look through the input history in reverse
|
|
3052
|
# Look through the input history in reverse
|
|
3053
|
for n in range(len(self.shell.history_manager.input_hist_parsed)-2,0,-1):
|
|
3053
|
for n in range(len(self.shell.history_manager.input_hist_parsed)-2,0,-1):
|
|
3054
|
input = self.shell.history_manager.input_hist_parsed[n]
|
|
3054
|
input = self.shell.history_manager.input_hist_parsed[n]
|
|
3055
|
# skip plain 'r' lines so we don't recurse to infinity
|
|
3055
|
# skip plain 'r' lines so we don't recurse to infinity
|
|
3056
|
if input != '_ip.magic("r")\n' and \
|
|
3056
|
if input != '_ip.magic("r")\n' and \
|
|
3057
|
(input.startswith(start) or input.startswith(start_magic)):
|
|
3057
|
(input.startswith(start) or input.startswith(start_magic)):
|
|
3058
|
#print 'match',`input` # dbg
|
|
3058
|
#print 'match',`input` # dbg
|
|
3059
|
print 'Executing:',input,
|
|
3059
|
print 'Executing:',input,
|
|
3060
|
self.shell.run_cell(input)
|
|
3060
|
self.shell.run_cell(input)
|
|
3061
|
return
|
|
3061
|
return
|
|
3062
|
print 'No previous input matching `%s` found.' % start
|
|
3062
|
print 'No previous input matching `%s` found.' % start
|
|
3063
|
|
|
3063
|
|
|
3064
|
|
|
3064
|
|
|
3065
|
def magic_bookmark(self, parameter_s=''):
|
|
3065
|
def magic_bookmark(self, parameter_s=''):
|
|
3066
|
"""Manage IPython's bookmark system.
|
|
3066
|
"""Manage IPython's bookmark system.
|
|
3067
|
|
|
3067
|
|
|
3068
|
%bookmark <name> - set bookmark to current dir
|
|
3068
|
%bookmark <name> - set bookmark to current dir
|
|
3069
|
%bookmark <name> <dir> - set bookmark to <dir>
|
|
3069
|
%bookmark <name> <dir> - set bookmark to <dir>
|
|
3070
|
%bookmark -l - list all bookmarks
|
|
3070
|
%bookmark -l - list all bookmarks
|
|
3071
|
%bookmark -d <name> - remove bookmark
|
|
3071
|
%bookmark -d <name> - remove bookmark
|
|
3072
|
%bookmark -r - remove all bookmarks
|
|
3072
|
%bookmark -r - remove all bookmarks
|
|
3073
|
|
|
3073
|
|
|
3074
|
You can later on access a bookmarked folder with:
|
|
3074
|
You can later on access a bookmarked folder with:
|
|
3075
|
%cd -b <name>
|
|
3075
|
%cd -b <name>
|
|
3076
|
or simply '%cd <name>' if there is no directory called <name> AND
|
|
3076
|
or simply '%cd <name>' if there is no directory called <name> AND
|
|
3077
|
there is such a bookmark defined.
|
|
3077
|
there is such a bookmark defined.
|
|
3078
|
|
|
3078
|
|
|
3079
|
Your bookmarks persist through IPython sessions, but they are
|
|
3079
|
Your bookmarks persist through IPython sessions, but they are
|
|
3080
|
associated with each profile."""
|
|
3080
|
associated with each profile."""
|
|
3081
|
|
|
3081
|
|
|
3082
|
opts,args = self.parse_options(parameter_s,'drl',mode='list')
|
|
3082
|
opts,args = self.parse_options(parameter_s,'drl',mode='list')
|
|
3083
|
if len(args) > 2:
|
|
3083
|
if len(args) > 2:
|
|
3084
|
raise UsageError("%bookmark: too many arguments")
|
|
3084
|
raise UsageError("%bookmark: too many arguments")
|
|
3085
|
|
|
3085
|
|
|
3086
|
bkms = self.db.get('bookmarks',{})
|
|
3086
|
bkms = self.db.get('bookmarks',{})
|
|
3087
|
|
|
3087
|
|
|
3088
|
if opts.has_key('d'):
|
|
3088
|
if opts.has_key('d'):
|
|
3089
|
try:
|
|
3089
|
try:
|
|
3090
|
todel = args[0]
|
|
3090
|
todel = args[0]
|
|
3091
|
except IndexError:
|
|
3091
|
except IndexError:
|
|
3092
|
raise UsageError(
|
|
3092
|
raise UsageError(
|
|
3093
|
"%bookmark -d: must provide a bookmark to delete")
|
|
3093
|
"%bookmark -d: must provide a bookmark to delete")
|
|
3094
|
else:
|
|
3094
|
else:
|
|
3095
|
try:
|
|
3095
|
try:
|
|
3096
|
del bkms[todel]
|
|
3096
|
del bkms[todel]
|
|
3097
|
except KeyError:
|
|
3097
|
except KeyError:
|
|
3098
|
raise UsageError(
|
|
3098
|
raise UsageError(
|
|
3099
|
"%%bookmark -d: Can't delete bookmark '%s'" % todel)
|
|
3099
|
"%%bookmark -d: Can't delete bookmark '%s'" % todel)
|
|
3100
|
|
|
3100
|
|
|
3101
|
elif opts.has_key('r'):
|
|
3101
|
elif opts.has_key('r'):
|
|
3102
|
bkms = {}
|
|
3102
|
bkms = {}
|
|
3103
|
elif opts.has_key('l'):
|
|
3103
|
elif opts.has_key('l'):
|
|
3104
|
bks = bkms.keys()
|
|
3104
|
bks = bkms.keys()
|
|
3105
|
bks.sort()
|
|
3105
|
bks.sort()
|
|
3106
|
if bks:
|
|
3106
|
if bks:
|
|
3107
|
size = max(map(len,bks))
|
|
3107
|
size = max(map(len,bks))
|
|
3108
|
else:
|
|
3108
|
else:
|
|
3109
|
size = 0
|
|
3109
|
size = 0
|
|
3110
|
fmt = '%-'+str(size)+'s -> %s'
|
|
3110
|
fmt = '%-'+str(size)+'s -> %s'
|
|
3111
|
print 'Current bookmarks:'
|
|
3111
|
print 'Current bookmarks:'
|
|
3112
|
for bk in bks:
|
|
3112
|
for bk in bks:
|
|
3113
|
print fmt % (bk,bkms[bk])
|
|
3113
|
print fmt % (bk,bkms[bk])
|
|
3114
|
else:
|
|
3114
|
else:
|
|
3115
|
if not args:
|
|
3115
|
if not args:
|
|
3116
|
raise UsageError("%bookmark: You must specify the bookmark name")
|
|
3116
|
raise UsageError("%bookmark: You must specify the bookmark name")
|
|
3117
|
elif len(args)==1:
|
|
3117
|
elif len(args)==1:
|
|
3118
|
bkms[args[0]] = os.getcwd()
|
|
3118
|
bkms[args[0]] = os.getcwd()
|
|
3119
|
elif len(args)==2:
|
|
3119
|
elif len(args)==2:
|
|
3120
|
bkms[args[0]] = args[1]
|
|
3120
|
bkms[args[0]] = args[1]
|
|
3121
|
self.db['bookmarks'] = bkms
|
|
3121
|
self.db['bookmarks'] = bkms
|
|
3122
|
|
|
3122
|
|
|
3123
|
def magic_pycat(self, parameter_s=''):
|
|
3123
|
def magic_pycat(self, parameter_s=''):
|
|
3124
|
"""Show a syntax-highlighted file through a pager.
|
|
3124
|
"""Show a syntax-highlighted file through a pager.
|
|
3125
|
|
|
3125
|
|
|
3126
|
This magic is similar to the cat utility, but it will assume the file
|
|
3126
|
This magic is similar to the cat utility, but it will assume the file
|
|
3127
|
to be Python source and will show it with syntax highlighting. """
|
|
3127
|
to be Python source and will show it with syntax highlighting. """
|
|
3128
|
|
|
3128
|
|
|
3129
|
try:
|
|
3129
|
try:
|
|
3130
|
filename = get_py_filename(parameter_s)
|
|
3130
|
filename = get_py_filename(parameter_s)
|
|
3131
|
cont = file_read(filename)
|
|
3131
|
cont = file_read(filename)
|
|
3132
|
except IOError:
|
|
3132
|
except IOError:
|
|
3133
|
try:
|
|
3133
|
try:
|
|
3134
|
cont = eval(parameter_s,self.user_ns)
|
|
3134
|
cont = eval(parameter_s,self.user_ns)
|
|
3135
|
except NameError:
|
|
3135
|
except NameError:
|
|
3136
|
cont = None
|
|
3136
|
cont = None
|
|
3137
|
if cont is None:
|
|
3137
|
if cont is None:
|
|
3138
|
print "Error: no such file or variable"
|
|
3138
|
print "Error: no such file or variable"
|
|
3139
|
return
|
|
3139
|
return
|
|
3140
|
|
|
3140
|
|
|
3141
|
page.page(self.shell.pycolorize(cont))
|
|
3141
|
page.page(self.shell.pycolorize(cont))
|
|
3142
|
|
|
3142
|
|
|
3143
|
def _rerun_pasted(self):
|
|
3143
|
def _rerun_pasted(self):
|
|
3144
|
""" Rerun a previously pasted command.
|
|
3144
|
""" Rerun a previously pasted command.
|
|
3145
|
"""
|
|
3145
|
"""
|
|
3146
|
b = self.user_ns.get('pasted_block', None)
|
|
3146
|
b = self.user_ns.get('pasted_block', None)
|
|
3147
|
if b is None:
|
|
3147
|
if b is None:
|
|
3148
|
raise UsageError('No previous pasted block available')
|
|
3148
|
raise UsageError('No previous pasted block available')
|
|
3149
|
print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
|
|
3149
|
print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
|
|
3150
|
exec b in self.user_ns
|
|
3150
|
exec b in self.user_ns
|
|
3151
|
|
|
3151
|
|
|
3152
|
def _get_pasted_lines(self, sentinel):
|
|
3152
|
def _get_pasted_lines(self, sentinel):
|
|
3153
|
""" Yield pasted lines until the user enters the given sentinel value.
|
|
3153
|
""" Yield pasted lines until the user enters the given sentinel value.
|
|
3154
|
"""
|
|
3154
|
"""
|
|
3155
|
from IPython.core import interactiveshell
|
|
3155
|
from IPython.core import interactiveshell
|
|
3156
|
print "Pasting code; enter '%s' alone on the line to stop." % sentinel
|
|
3156
|
print "Pasting code; enter '%s' alone on the line to stop." % sentinel
|
|
3157
|
while True:
|
|
3157
|
while True:
|
|
3158
|
l = interactiveshell.raw_input_original(':')
|
|
3158
|
l = interactiveshell.raw_input_original(':')
|
|
3159
|
if l == sentinel:
|
|
3159
|
if l == sentinel:
|
|
3160
|
return
|
|
3160
|
return
|
|
3161
|
else:
|
|
3161
|
else:
|
|
3162
|
yield l
|
|
3162
|
yield l
|
|
3163
|
|
|
3163
|
|
|
3164
|
def _strip_pasted_lines_for_code(self, raw_lines):
|
|
3164
|
def _strip_pasted_lines_for_code(self, raw_lines):
|
|
3165
|
""" Strip non-code parts of a sequence of lines to return a block of
|
|
3165
|
""" Strip non-code parts of a sequence of lines to return a block of
|
|
3166
|
code.
|
|
3166
|
code.
|
|
3167
|
"""
|
|
3167
|
"""
|
|
3168
|
# Regular expressions that declare text we strip from the input:
|
|
3168
|
# Regular expressions that declare text we strip from the input:
|
|
3169
|
strip_re = [r'^\s*In \[\d+\]:', # IPython input prompt
|
|
3169
|
strip_re = [r'^\s*In \[\d+\]:', # IPython input prompt
|
|
3170
|
r'^\s*(\s?>)+', # Python input prompt
|
|
3170
|
r'^\s*(\s?>)+', # Python input prompt
|
|
3171
|
r'^\s*\.{3,}', # Continuation prompts
|
|
3171
|
r'^\s*\.{3,}', # Continuation prompts
|
|
3172
|
r'^\++',
|
|
3172
|
r'^\++',
|
|
3173
|
]
|
|
3173
|
]
|
|
3174
|
|
|
3174
|
|
|
3175
|
strip_from_start = map(re.compile,strip_re)
|
|
3175
|
strip_from_start = map(re.compile,strip_re)
|
|
3176
|
|
|
3176
|
|
|
3177
|
lines = []
|
|
3177
|
lines = []
|
|
3178
|
for l in raw_lines:
|
|
3178
|
for l in raw_lines:
|
|
3179
|
for pat in strip_from_start:
|
|
3179
|
for pat in strip_from_start:
|
|
3180
|
l = pat.sub('',l)
|
|
3180
|
l = pat.sub('',l)
|
|
3181
|
lines.append(l)
|
|
3181
|
lines.append(l)
|
|
3182
|
|
|
3182
|
|
|
3183
|
block = "\n".join(lines) + '\n'
|
|
3183
|
block = "\n".join(lines) + '\n'
|
|
3184
|
#print "block:\n",block
|
|
3184
|
#print "block:\n",block
|
|
3185
|
return block
|
|
3185
|
return block
|
|
3186
|
|
|
3186
|
|
|
3187
|
def _execute_block(self, block, par):
|
|
3187
|
def _execute_block(self, block, par):
|
|
3188
|
""" Execute a block, or store it in a variable, per the user's request.
|
|
3188
|
""" Execute a block, or store it in a variable, per the user's request.
|
|
3189
|
"""
|
|
3189
|
"""
|
|
3190
|
if not par:
|
|
3190
|
if not par:
|
|
3191
|
b = textwrap.dedent(block)
|
|
3191
|
b = textwrap.dedent(block)
|
|
3192
|
self.user_ns['pasted_block'] = b
|
|
3192
|
self.user_ns['pasted_block'] = b
|
|
3193
|
exec b in self.user_ns
|
|
3193
|
exec b in self.user_ns
|
|
3194
|
else:
|
|
3194
|
else:
|
|
3195
|
self.user_ns[par] = SList(block.splitlines())
|
|
3195
|
self.user_ns[par] = SList(block.splitlines())
|
|
3196
|
print "Block assigned to '%s'" % par
|
|
3196
|
print "Block assigned to '%s'" % par
|
|
3197
|
|
|
3197
|
|
|
3198
|
def magic_quickref(self,arg):
|
|
3198
|
def magic_quickref(self,arg):
|
|
3199
|
""" Show a quick reference sheet """
|
|
3199
|
""" Show a quick reference sheet """
|
|
3200
|
import IPython.core.usage
|
|
3200
|
import IPython.core.usage
|
|
3201
|
qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
|
|
3201
|
qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
|
|
3202
|
|
|
3202
|
|
|
3203
|
page.page(qr)
|
|
3203
|
page.page(qr)
|
|
3204
|
|
|
3204
|
|
|
3205
|
def magic_doctest_mode(self,parameter_s=''):
|
|
3205
|
def magic_doctest_mode(self,parameter_s=''):
|
|
3206
|
"""Toggle doctest mode on and off.
|
|
3206
|
"""Toggle doctest mode on and off.
|
|
3207
|
|
|
3207
|
|
|
3208
|
This mode is intended to make IPython behave as much as possible like a
|
|
3208
|
This mode is intended to make IPython behave as much as possible like a
|
|
3209
|
plain Python shell, from the perspective of how its prompts, exceptions
|
|
3209
|
plain Python shell, from the perspective of how its prompts, exceptions
|
|
3210
|
and output look. This makes it easy to copy and paste parts of a
|
|
3210
|
and output look. This makes it easy to copy and paste parts of a
|
|
3211
|
session into doctests. It does so by:
|
|
3211
|
session into doctests. It does so by:
|
|
3212
|
|
|
3212
|
|
|
3213
|
- Changing the prompts to the classic ``>>>`` ones.
|
|
3213
|
- Changing the prompts to the classic ``>>>`` ones.
|
|
3214
|
- Changing the exception reporting mode to 'Plain'.
|
|
3214
|
- Changing the exception reporting mode to 'Plain'.
|
|
3215
|
- Disabling pretty-printing of output.
|
|
3215
|
- Disabling pretty-printing of output.
|
|
3216
|
|
|
3216
|
|
|
3217
|
Note that IPython also supports the pasting of code snippets that have
|
|
3217
|
Note that IPython also supports the pasting of code snippets that have
|
|
3218
|
leading '>>>' and '...' prompts in them. This means that you can paste
|
|
3218
|
leading '>>>' and '...' prompts in them. This means that you can paste
|
|
3219
|
doctests from files or docstrings (even if they have leading
|
|
3219
|
doctests from files or docstrings (even if they have leading
|
|
3220
|
whitespace), and the code will execute correctly. You can then use
|
|
3220
|
whitespace), and the code will execute correctly. You can then use
|
|
3221
|
'%history -t' to see the translated history; this will give you the
|
|
3221
|
'%history -t' to see the translated history; this will give you the
|
|
3222
|
input after removal of all the leading prompts and whitespace, which
|
|
3222
|
input after removal of all the leading prompts and whitespace, which
|
|
3223
|
can be pasted back into an editor.
|
|
3223
|
can be pasted back into an editor.
|
|
3224
|
|
|
3224
|
|
|
3225
|
With these features, you can switch into this mode easily whenever you
|
|
3225
|
With these features, you can switch into this mode easily whenever you
|
|
3226
|
need to do testing and changes to doctests, without having to leave
|
|
3226
|
need to do testing and changes to doctests, without having to leave
|
|
3227
|
your existing IPython session.
|
|
3227
|
your existing IPython session.
|
|
3228
|
"""
|
|
3228
|
"""
|
|
3229
|
|
|
3229
|
|
|
3230
|
from IPython.utils.ipstruct import Struct
|
|
3230
|
from IPython.utils.ipstruct import Struct
|
|
3231
|
|
|
3231
|
|
|
3232
|
# Shorthands
|
|
3232
|
# Shorthands
|
|
3233
|
shell = self.shell
|
|
3233
|
shell = self.shell
|
|
3234
|
oc = shell.displayhook
|
|
3234
|
oc = shell.displayhook
|
|
3235
|
meta = shell.meta
|
|
3235
|
meta = shell.meta
|
|
3236
|
disp_formatter = self.shell.display_formatter
|
|
3236
|
disp_formatter = self.shell.display_formatter
|
|
3237
|
ptformatter = disp_formatter.formatters['text/plain']
|
|
3237
|
ptformatter = disp_formatter.formatters['text/plain']
|
|
3238
|
# dstore is a data store kept in the instance metadata bag to track any
|
|
3238
|
# dstore is a data store kept in the instance metadata bag to track any
|
|
3239
|
# changes we make, so we can undo them later.
|
|
3239
|
# changes we make, so we can undo them later.
|
|
3240
|
dstore = meta.setdefault('doctest_mode',Struct())
|
|
3240
|
dstore = meta.setdefault('doctest_mode',Struct())
|
|
3241
|
save_dstore = dstore.setdefault
|
|
3241
|
save_dstore = dstore.setdefault
|
|
3242
|
|
|
3242
|
|
|
3243
|
# save a few values we'll need to recover later
|
|
3243
|
# save a few values we'll need to recover later
|
|
3244
|
mode = save_dstore('mode',False)
|
|
3244
|
mode = save_dstore('mode',False)
|
|
3245
|
save_dstore('rc_pprint',ptformatter.pprint)
|
|
3245
|
save_dstore('rc_pprint',ptformatter.pprint)
|
|
3246
|
save_dstore('xmode',shell.InteractiveTB.mode)
|
|
3246
|
save_dstore('xmode',shell.InteractiveTB.mode)
|
|
3247
|
save_dstore('rc_separate_out',shell.separate_out)
|
|
3247
|
save_dstore('rc_separate_out',shell.separate_out)
|
|
3248
|
save_dstore('rc_separate_out2',shell.separate_out2)
|
|
3248
|
save_dstore('rc_separate_out2',shell.separate_out2)
|
|
3249
|
save_dstore('rc_prompts_pad_left',shell.prompts_pad_left)
|
|
3249
|
save_dstore('rc_prompts_pad_left',shell.prompts_pad_left)
|
|
3250
|
save_dstore('rc_separate_in',shell.separate_in)
|
|
3250
|
save_dstore('rc_separate_in',shell.separate_in)
|
|
3251
|
save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
|
|
3251
|
save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
|
|
3252
|
|
|
3252
|
|
|
3253
|
if mode == False:
|
|
3253
|
if mode == False:
|
|
3254
|
# turn on
|
|
3254
|
# turn on
|
|
3255
|
oc.prompt1.p_template = '>>> '
|
|
3255
|
oc.prompt1.p_template = '>>> '
|
|
3256
|
oc.prompt2.p_template = '... '
|
|
3256
|
oc.prompt2.p_template = '... '
|
|
3257
|
oc.prompt_out.p_template = ''
|
|
3257
|
oc.prompt_out.p_template = ''
|
|
3258
|
|
|
3258
|
|
|
3259
|
# Prompt separators like plain python
|
|
3259
|
# Prompt separators like plain python
|
|
3260
|
oc.input_sep = oc.prompt1.sep = ''
|
|
3260
|
oc.input_sep = oc.prompt1.sep = ''
|
|
3261
|
oc.output_sep = ''
|
|
3261
|
oc.output_sep = ''
|
|
3262
|
oc.output_sep2 = ''
|
|
3262
|
oc.output_sep2 = ''
|
|
3263
|
|
|
3263
|
|
|
3264
|
oc.prompt1.pad_left = oc.prompt2.pad_left = \
|
|
3264
|
oc.prompt1.pad_left = oc.prompt2.pad_left = \
|
|
3265
|
oc.prompt_out.pad_left = False
|
|
3265
|
oc.prompt_out.pad_left = False
|
|
3266
|
|
|
3266
|
|
|
3267
|
ptformatter.pprint = False
|
|
3267
|
ptformatter.pprint = False
|
|
3268
|
disp_formatter.plain_text_only = True
|
|
3268
|
disp_formatter.plain_text_only = True
|
|
3269
|
|
|
3269
|
|
|
3270
|
shell.magic_xmode('Plain')
|
|
3270
|
shell.magic_xmode('Plain')
|
|
3271
|
else:
|
|
3271
|
else:
|
|
3272
|
# turn off
|
|
3272
|
# turn off
|
|
3273
|
oc.prompt1.p_template = shell.prompt_in1
|
|
3273
|
oc.prompt1.p_template = shell.prompt_in1
|
|
3274
|
oc.prompt2.p_template = shell.prompt_in2
|
|
3274
|
oc.prompt2.p_template = shell.prompt_in2
|
|
3275
|
oc.prompt_out.p_template = shell.prompt_out
|
|
3275
|
oc.prompt_out.p_template = shell.prompt_out
|
|
3276
|
|
|
3276
|
|
|
3277
|
oc.input_sep = oc.prompt1.sep = dstore.rc_separate_in
|
|
3277
|
oc.input_sep = oc.prompt1.sep = dstore.rc_separate_in
|
|
3278
|
|
|
3278
|
|
|
3279
|
oc.output_sep = dstore.rc_separate_out
|
|
3279
|
oc.output_sep = dstore.rc_separate_out
|
|
3280
|
oc.output_sep2 = dstore.rc_separate_out2
|
|
3280
|
oc.output_sep2 = dstore.rc_separate_out2
|
|
3281
|
|
|
3281
|
|
|
3282
|
oc.prompt1.pad_left = oc.prompt2.pad_left = \
|
|
3282
|
oc.prompt1.pad_left = oc.prompt2.pad_left = \
|
|
3283
|
oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
|
|
3283
|
oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
|
|
3284
|
|
|
3284
|
|
|
3285
|
ptformatter.pprint = dstore.rc_pprint
|
|
3285
|
ptformatter.pprint = dstore.rc_pprint
|
|
3286
|
disp_formatter.plain_text_only = dstore.rc_plain_text_only
|
|
3286
|
disp_formatter.plain_text_only = dstore.rc_plain_text_only
|
|
3287
|
|
|
3287
|
|
|
3288
|
shell.magic_xmode(dstore.xmode)
|
|
3288
|
shell.magic_xmode(dstore.xmode)
|
|
3289
|
|
|
3289
|
|
|
3290
|
# Store new mode and inform
|
|
3290
|
# Store new mode and inform
|
|
3291
|
dstore.mode = bool(1-int(mode))
|
|
3291
|
dstore.mode = bool(1-int(mode))
|
|
3292
|
mode_label = ['OFF','ON'][dstore.mode]
|
|
3292
|
mode_label = ['OFF','ON'][dstore.mode]
|
|
3293
|
print 'Doctest mode is:', mode_label
|
|
3293
|
print 'Doctest mode is:', mode_label
|
|
3294
|
|
|
3294
|
|
|
3295
|
def magic_gui(self, parameter_s=''):
|
|
3295
|
def magic_gui(self, parameter_s=''):
|
|
3296
|
"""Enable or disable IPython GUI event loop integration.
|
|
3296
|
"""Enable or disable IPython GUI event loop integration.
|
|
3297
|
|
|
3297
|
|
|
3298
|
%gui [GUINAME]
|
|
3298
|
%gui [GUINAME]
|
|
3299
|
|
|
3299
|
|
|
3300
|
This magic replaces IPython's threaded shells that were activated
|
|
3300
|
This magic replaces IPython's threaded shells that were activated
|
|
3301
|
using the (pylab/wthread/etc.) command line flags. GUI toolkits
|
|
3301
|
using the (pylab/wthread/etc.) command line flags. GUI toolkits
|
|
3302
|
can now be enabled, disabled and swtiched at runtime and keyboard
|
|
3302
|
can now be enabled, disabled and swtiched at runtime and keyboard
|
|
3303
|
interrupts should work without any problems. The following toolkits
|
|
3303
|
interrupts should work without any problems. The following toolkits
|
|
3304
|
are supported: wxPython, PyQt4, PyGTK, and Tk::
|
|
3304
|
are supported: wxPython, PyQt4, PyGTK, and Tk::
|
|
3305
|
|
|
3305
|
|
|
3306
|
%gui wx # enable wxPython event loop integration
|
|
3306
|
%gui wx # enable wxPython event loop integration
|
|
3307
|
%gui qt4|qt # enable PyQt4 event loop integration
|
|
3307
|
%gui qt4|qt # enable PyQt4 event loop integration
|
|
3308
|
%gui gtk # enable PyGTK event loop integration
|
|
3308
|
%gui gtk # enable PyGTK event loop integration
|
|
3309
|
%gui tk # enable Tk event loop integration
|
|
3309
|
%gui tk # enable Tk event loop integration
|
|
3310
|
%gui # disable all event loop integration
|
|
3310
|
%gui # disable all event loop integration
|
|
3311
|
|
|
3311
|
|
|
3312
|
WARNING: after any of these has been called you can simply create
|
|
3312
|
WARNING: after any of these has been called you can simply create
|
|
3313
|
an application object, but DO NOT start the event loop yourself, as
|
|
3313
|
an application object, but DO NOT start the event loop yourself, as
|
|
3314
|
we have already handled that.
|
|
3314
|
we have already handled that.
|
|
3315
|
"""
|
|
3315
|
"""
|
|
3316
|
from IPython.lib.inputhook import enable_gui
|
|
3316
|
from IPython.lib.inputhook import enable_gui
|
|
3317
|
opts, arg = self.parse_options(parameter_s, '')
|
|
3317
|
opts, arg = self.parse_options(parameter_s, '')
|
|
3318
|
if arg=='': arg = None
|
|
3318
|
if arg=='': arg = None
|
|
3319
|
return enable_gui(arg)
|
|
3319
|
return enable_gui(arg)
|
|
3320
|
|
|
3320
|
|
|
3321
|
def magic_load_ext(self, module_str):
|
|
3321
|
def magic_load_ext(self, module_str):
|
|
3322
|
"""Load an IPython extension by its module name."""
|
|
3322
|
"""Load an IPython extension by its module name."""
|
|
3323
|
return self.extension_manager.load_extension(module_str)
|
|
3323
|
return self.extension_manager.load_extension(module_str)
|
|
3324
|
|
|
3324
|
|
|
3325
|
def magic_unload_ext(self, module_str):
|
|
3325
|
def magic_unload_ext(self, module_str):
|
|
3326
|
"""Unload an IPython extension by its module name."""
|
|
3326
|
"""Unload an IPython extension by its module name."""
|
|
3327
|
self.extension_manager.unload_extension(module_str)
|
|
3327
|
self.extension_manager.unload_extension(module_str)
|
|
3328
|
|
|
3328
|
|
|
3329
|
def magic_reload_ext(self, module_str):
|
|
3329
|
def magic_reload_ext(self, module_str):
|
|
3330
|
"""Reload an IPython extension by its module name."""
|
|
3330
|
"""Reload an IPython extension by its module name."""
|
|
3331
|
self.extension_manager.reload_extension(module_str)
|
|
3331
|
self.extension_manager.reload_extension(module_str)
|
|
3332
|
|
|
3332
|
|
|
3333
|
@testdec.skip_doctest
|
|
3333
|
@testdec.skip_doctest
|
|
3334
|
def magic_install_profiles(self, s):
|
|
3334
|
def magic_install_profiles(self, s):
|
|
3335
|
"""Install the default IPython profiles into the .ipython dir.
|
|
3335
|
"""Install the default IPython profiles into the .ipython dir.
|
|
3336
|
|
|
3336
|
|
|
3337
|
If the default profiles have already been installed, they will not
|
|
3337
|
If the default profiles have already been installed, they will not
|
|
3338
|
be overwritten. You can force overwriting them by using the ``-o``
|
|
3338
|
be overwritten. You can force overwriting them by using the ``-o``
|
|
3339
|
option::
|
|
3339
|
option::
|
|
3340
|
|
|
3340
|
|
|
3341
|
In [1]: %install_profiles -o
|
|
3341
|
In [1]: %install_profiles -o
|
|
3342
|
"""
|
|
3342
|
"""
|
|
3343
|
if '-o' in s:
|
|
3343
|
if '-o' in s:
|
|
3344
|
overwrite = True
|
|
3344
|
overwrite = True
|
|
3345
|
else:
|
|
3345
|
else:
|
|
3346
|
overwrite = False
|
|
3346
|
overwrite = False
|
|
3347
|
from IPython.config import profile
|
|
3347
|
from IPython.config import profile
|
|
3348
|
profile_dir = os.path.split(profile.__file__)[0]
|
|
3348
|
profile_dir = os.path.split(profile.__file__)[0]
|
|
3349
|
ipython_dir = self.ipython_dir
|
|
3349
|
ipython_dir = self.ipython_dir
|
|
3350
|
files = os.listdir(profile_dir)
|
|
3350
|
files = os.listdir(profile_dir)
|
|
3351
|
|
|
3351
|
|
|
3352
|
to_install = []
|
|
3352
|
to_install = []
|
|
3353
|
for f in files:
|
|
3353
|
for f in files:
|
|
3354
|
if f.startswith('ipython_config'):
|
|
3354
|
if f.startswith('ipython_config'):
|
|
3355
|
src = os.path.join(profile_dir, f)
|
|
3355
|
src = os.path.join(profile_dir, f)
|
|
3356
|
dst = os.path.join(ipython_dir, f)
|
|
3356
|
dst = os.path.join(ipython_dir, f)
|
|
3357
|
if (not os.path.isfile(dst)) or overwrite:
|
|
3357
|
if (not os.path.isfile(dst)) or overwrite:
|
|
3358
|
to_install.append((f, src, dst))
|
|
3358
|
to_install.append((f, src, dst))
|
|
3359
|
if len(to_install)>0:
|
|
3359
|
if len(to_install)>0:
|
|
3360
|
print "Installing profiles to: ", ipython_dir
|
|
3360
|
print "Installing profiles to: ", ipython_dir
|
|
3361
|
for (f, src, dst) in to_install:
|
|
3361
|
for (f, src, dst) in to_install:
|
|
3362
|
shutil.copy(src, dst)
|
|
3362
|
shutil.copy(src, dst)
|
|
3363
|
print " %s" % f
|
|
3363
|
print " %s" % f
|
|
3364
|
|
|
3364
|
|
|
3365
|
def magic_install_default_config(self, s):
|
|
3365
|
def magic_install_default_config(self, s):
|
|
3366
|
"""Install IPython's default config file into the .ipython dir.
|
|
3366
|
"""Install IPython's default config file into the .ipython dir.
|
|
3367
|
|
|
3367
|
|
|
3368
|
If the default config file (:file:`ipython_config.py`) is already
|
|
3368
|
If the default config file (:file:`ipython_config.py`) is already
|
|
3369
|
installed, it will not be overwritten. You can force overwriting
|
|
3369
|
installed, it will not be overwritten. You can force overwriting
|
|
3370
|
by using the ``-o`` option::
|
|
3370
|
by using the ``-o`` option::
|
|
3371
|
|
|
3371
|
|
|
3372
|
In [1]: %install_default_config
|
|
3372
|
In [1]: %install_default_config
|
|
3373
|
"""
|
|
3373
|
"""
|
|
3374
|
if '-o' in s:
|
|
3374
|
if '-o' in s:
|
|
3375
|
overwrite = True
|
|
3375
|
overwrite = True
|
|
3376
|
else:
|
|
3376
|
else:
|
|
3377
|
overwrite = False
|
|
3377
|
overwrite = False
|
|
3378
|
from IPython.config import default
|
|
3378
|
from IPython.config import default
|
|
3379
|
config_dir = os.path.split(default.__file__)[0]
|
|
3379
|
config_dir = os.path.split(default.__file__)[0]
|
|
3380
|
ipython_dir = self.ipython_dir
|
|
3380
|
ipython_dir = self.ipython_dir
|
|
3381
|
default_config_file_name = 'ipython_config.py'
|
|
3381
|
default_config_file_name = 'ipython_config.py'
|
|
3382
|
src = os.path.join(config_dir, default_config_file_name)
|
|
3382
|
src = os.path.join(config_dir, default_config_file_name)
|
|
3383
|
dst = os.path.join(ipython_dir, default_config_file_name)
|
|
3383
|
dst = os.path.join(ipython_dir, default_config_file_name)
|
|
3384
|
if (not os.path.isfile(dst)) or overwrite:
|
|
3384
|
if (not os.path.isfile(dst)) or overwrite:
|
|
3385
|
shutil.copy(src, dst)
|
|
3385
|
shutil.copy(src, dst)
|
|
3386
|
print "Installing default config file: %s" % dst
|
|
3386
|
print "Installing default config file: %s" % dst
|
|
3387
|
|
|
3387
|
|
|
3388
|
# Pylab support: simple wrappers that activate pylab, load gui input
|
|
3388
|
# Pylab support: simple wrappers that activate pylab, load gui input
|
|
3389
|
# handling and modify slightly %run
|
|
3389
|
# handling and modify slightly %run
|
|
3390
|
|
|
3390
|
|
|
3391
|
@testdec.skip_doctest
|
|
3391
|
@testdec.skip_doctest
|
|
3392
|
def _pylab_magic_run(self, parameter_s=''):
|
|
3392
|
def _pylab_magic_run(self, parameter_s=''):
|
|
3393
|
Magic.magic_run(self, parameter_s,
|
|
3393
|
Magic.magic_run(self, parameter_s,
|
|
3394
|
runner=mpl_runner(self.shell.safe_execfile))
|
|
3394
|
runner=mpl_runner(self.shell.safe_execfile))
|
|
3395
|
|
|
3395
|
|
|
3396
|
_pylab_magic_run.__doc__ = magic_run.__doc__
|
|
3396
|
_pylab_magic_run.__doc__ = magic_run.__doc__
|
|
3397
|
|
|
3397
|
|
|
3398
|
@testdec.skip_doctest
|
|
3398
|
@testdec.skip_doctest
|
|
3399
|
def magic_pylab(self, s):
|
|
3399
|
def magic_pylab(self, s):
|
|
3400
|
"""Load numpy and matplotlib to work interactively.
|
|
3400
|
"""Load numpy and matplotlib to work interactively.
|
|
3401
|
|
|
3401
|
|
|
3402
|
%pylab [GUINAME]
|
|
3402
|
%pylab [GUINAME]
|
|
3403
|
|
|
3403
|
|
|
3404
|
This function lets you activate pylab (matplotlib, numpy and
|
|
3404
|
This function lets you activate pylab (matplotlib, numpy and
|
|
3405
|
interactive support) at any point during an IPython session.
|
|
3405
|
interactive support) at any point during an IPython session.
|
|
3406
|
|
|
3406
|
|
|
3407
|
It will import at the top level numpy as np, pyplot as plt, matplotlib,
|
|
3407
|
It will import at the top level numpy as np, pyplot as plt, matplotlib,
|
|
3408
|
pylab and mlab, as well as all names from numpy and pylab.
|
|
3408
|
pylab and mlab, as well as all names from numpy and pylab.
|
|
3409
|
|
|
3409
|
|
|
3410
|
Parameters
|
|
3410
|
Parameters
|
|
3411
|
----------
|
|
3411
|
----------
|
|
3412
|
guiname : optional
|
|
3412
|
guiname : optional
|
|
3413
|
One of the valid arguments to the %gui magic ('qt', 'wx', 'gtk' or
|
|
3413
|
One of the valid arguments to the %gui magic ('qt', 'wx', 'gtk' or
|
|
3414
|
'tk'). If given, the corresponding Matplotlib backend is used,
|
|
3414
|
'tk'). If given, the corresponding Matplotlib backend is used,
|
|
3415
|
otherwise matplotlib's default (which you can override in your
|
|
3415
|
otherwise matplotlib's default (which you can override in your
|
|
3416
|
matplotlib config file) is used.
|
|
3416
|
matplotlib config file) is used.
|
|
3417
|
|
|
3417
|
|
|
3418
|
Examples
|
|
3418
|
Examples
|
|
3419
|
--------
|
|
3419
|
--------
|
|
3420
|
In this case, where the MPL default is TkAgg:
|
|
3420
|
In this case, where the MPL default is TkAgg:
|
|
3421
|
In [2]: %pylab
|
|
3421
|
In [2]: %pylab
|
|
3422
|
|
|
3422
|
|
|
3423
|
Welcome to pylab, a matplotlib-based Python environment.
|
|
3423
|
Welcome to pylab, a matplotlib-based Python environment.
|
|
3424
|
Backend in use: TkAgg
|
|
3424
|
Backend in use: TkAgg
|
|
3425
|
For more information, type 'help(pylab)'.
|
|
3425
|
For more information, type 'help(pylab)'.
|
|
3426
|
|
|
3426
|
|
|
3427
|
But you can explicitly request a different backend:
|
|
3427
|
But you can explicitly request a different backend:
|
|
3428
|
In [3]: %pylab qt
|
|
3428
|
In [3]: %pylab qt
|
|
3429
|
|
|
3429
|
|
|
3430
|
Welcome to pylab, a matplotlib-based Python environment.
|
|
3430
|
Welcome to pylab, a matplotlib-based Python environment.
|
|
3431
|
Backend in use: Qt4Agg
|
|
3431
|
Backend in use: Qt4Agg
|
|
3432
|
For more information, type 'help(pylab)'.
|
|
3432
|
For more information, type 'help(pylab)'.
|
|
3433
|
"""
|
|
3433
|
"""
|
|
3434
|
self.shell.enable_pylab(s)
|
|
3434
|
self.shell.enable_pylab(s)
|
|
3435
|
|
|
3435
|
|
|
3436
|
def magic_tb(self, s):
|
|
3436
|
def magic_tb(self, s):
|
|
3437
|
"""Print the last traceback with the currently active exception mode.
|
|
3437
|
"""Print the last traceback with the currently active exception mode.
|
|
3438
|
|
|
3438
|
|
|
3439
|
See %xmode for changing exception reporting modes."""
|
|
3439
|
See %xmode for changing exception reporting modes."""
|
|
3440
|
self.shell.showtraceback()
|
|
3440
|
self.shell.showtraceback()
|
|
3441
|
|
|
3441
|
|
|
3442
|
@testdec.skip_doctest
|
|
3442
|
@testdec.skip_doctest
|
|
3443
|
def magic_precision(self, s=''):
|
|
3443
|
def magic_precision(self, s=''):
|
|
3444
|
"""Set floating point precision for pretty printing.
|
|
3444
|
"""Set floating point precision for pretty printing.
|
|
3445
|
|
|
3445
|
|
|
3446
|
Can set either integer precision or a format string.
|
|
3446
|
Can set either integer precision or a format string.
|
|
3447
|
|
|
3447
|
|
|
3448
|
If numpy has been imported and precision is an int,
|
|
3448
|
If numpy has been imported and precision is an int,
|
|
3449
|
numpy display precision will also be set, via ``numpy.set_printoptions``.
|
|
3449
|
numpy display precision will also be set, via ``numpy.set_printoptions``.
|
|
3450
|
|
|
3450
|
|
|
3451
|
If no argument is given, defaults will be restored.
|
|
3451
|
If no argument is given, defaults will be restored.
|
|
3452
|
|
|
3452
|
|
|
3453
|
Examples
|
|
3453
|
Examples
|
|
3454
|
--------
|
|
3454
|
--------
|
|
3455
|
::
|
|
3455
|
::
|
|
3456
|
|
|
3456
|
|
|
3457
|
In [1]: from math import pi
|
|
3457
|
In [1]: from math import pi
|
|
3458
|
|
|
3458
|
|
|
3459
|
In [2]: %precision 3
|
|
3459
|
In [2]: %precision 3
|
|
3460
|
Out[2]: '%.3f'
|
|
3460
|
Out[2]: '%.3f'
|
|
3461
|
|
|
3461
|
|
|
3462
|
In [3]: pi
|
|
3462
|
In [3]: pi
|
|
3463
|
Out[3]: 3.142
|
|
3463
|
Out[3]: 3.142
|
|
3464
|
|
|
3464
|
|
|
3465
|
In [4]: %precision %i
|
|
3465
|
In [4]: %precision %i
|
|
3466
|
Out[4]: '%i'
|
|
3466
|
Out[4]: '%i'
|
|
3467
|
|
|
3467
|
|
|
3468
|
In [5]: pi
|
|
3468
|
In [5]: pi
|
|
3469
|
Out[5]: 3
|
|
3469
|
Out[5]: 3
|
|
3470
|
|
|
3470
|
|
|
3471
|
In [6]: %precision %e
|
|
3471
|
In [6]: %precision %e
|
|
3472
|
Out[6]: '%e'
|
|
3472
|
Out[6]: '%e'
|
|
3473
|
|
|
3473
|
|
|
3474
|
In [7]: pi**10
|
|
3474
|
In [7]: pi**10
|
|
3475
|
Out[7]: 9.364805e+04
|
|
3475
|
Out[7]: 9.364805e+04
|
|
3476
|
|
|
3476
|
|
|
3477
|
In [8]: %precision
|
|
3477
|
In [8]: %precision
|
|
3478
|
Out[8]: '%r'
|
|
3478
|
Out[8]: '%r'
|
|
3479
|
|
|
3479
|
|
|
3480
|
In [9]: pi**10
|
|
3480
|
In [9]: pi**10
|
|
3481
|
Out[9]: 93648.047476082982
|
|
3481
|
Out[9]: 93648.047476082982
|
|
3482
|
|
|
3482
|
|
|
3483
|
"""
|
|
3483
|
"""
|
|
3484
|
|
|
3484
|
|
|
3485
|
ptformatter = self.shell.display_formatter.formatters['text/plain']
|
|
3485
|
ptformatter = self.shell.display_formatter.formatters['text/plain']
|
|
3486
|
ptformatter.float_precision = s
|
|
3486
|
ptformatter.float_precision = s
|
|
3487
|
return ptformatter.float_format
|
|
3487
|
return ptformatter.float_format
|
|
3488
|
|
|
3488
|
|
|
3489
|
# end Magic
|
|
3489
|
# end Magic
|