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