##// END OF EJS Templates
Merge pull request #6933 from dsblank/master...
Thomas Kluyver -
r18875:b9ad8d79 merge
parent child Browse files
Show More
@@ -0,0 +1,95 b''
1 """ ZMQ Kernel History accessor and manager. """
2 #-----------------------------------------------------------------------------
3 # Copyright (C) 2010-2011 The IPython Development Team.
4 #
5 # Distributed under the terms of the BSD License.
6 #
7 # The full license is in the file COPYING.txt, distributed with this software.
8 #-----------------------------------------------------------------------------
9
10 #-----------------------------------------------------------------------------
11 # Imports
12 #-----------------------------------------------------------------------------
13
14 from IPython.core.history import HistoryAccessorBase
15 from IPython.utils.traitlets import Dict, List
16
17 try:
18 from queue import Empty # Py 3
19 except ImportError:
20 from Queue import Empty # Py 2
21
22 class ZMQHistoryManager(HistoryAccessorBase):
23 """History accessor and manager for ZMQ-based kernels"""
24 input_hist_parsed = List([""])
25 output_hist = Dict()
26 dir_hist = List()
27 output_hist_reprs = Dict()
28
29 def __init__(self, client):
30 """
31 Class to load the command-line history from a ZMQ-based kernel,
32 and access the history.
33
34 Parameters
35 ----------
36
37 client: `IPython.kernel.KernelClient`
38 The kernel client in order to request the history.
39 """
40 self.client = client
41
42 def _load_history(self, raw=True, output=False, hist_access_type='range',
43 **kwargs):
44 """
45 Load the history over ZMQ from the kernel. Wraps the history
46 messaging with loop to wait to get history results.
47 """
48 history = []
49 if hasattr(self.client, "history"):
50 ## In tests, KernelClient may not have a history method
51 msg_id = self.client.history(raw=raw, output=output,
52 hist_access_type=hist_access_type,
53 **kwargs)
54 while True:
55 try:
56 reply = self.client.get_shell_msg(timeout=1)
57 except Empty:
58 break
59 else:
60 if reply['parent_header'].get('msg_id') == msg_id:
61 history = reply['content'].get('history', [])
62 break
63 return history
64
65 def get_tail(self, n=10, raw=True, output=False, include_latest=False):
66 return self._load_history(hist_access_type='tail', n=n, raw=raw,
67 output=output)
68
69 def search(self, pattern="*", raw=True, search_raw=True,
70 output=False, n=None, unique=False):
71 return self._load_history(hist_access_type='search', pattern=pattern,
72 raw=raw, search_raw=search_raw,
73 output=output, n=n, unique=unique)
74
75 def get_range(self, session, start=1, stop=None, raw=True,output=False):
76 return self._load_history(hist_access_type='range', raw=raw,
77 output=output, start=start, stop=stop,
78 session=session)
79
80 def get_range_by_str(self, rangestr, raw=True, output=False):
81 return self._load_history(hist_access_type='range', raw=raw,
82 output=output, rangestr=rangestr)
83
84 def end_session(self):
85 """
86 Nothing to do for ZMQ-based histories.
87 """
88 pass
89
90 def reset(self, new_session=True):
91 """
92 Nothing to do for ZMQ-based histories.
93 """
94 pass
95
@@ -1,855 +1,870 b''
1 """ History related magics and functionality """
1 """ History related magics and functionality """
2 #-----------------------------------------------------------------------------
2 #-----------------------------------------------------------------------------
3 # Copyright (C) 2010-2011 The IPython Development Team.
3 # Copyright (C) 2010-2011 The IPython Development Team.
4 #
4 #
5 # Distributed under the terms of the BSD License.
5 # Distributed under the terms of the BSD License.
6 #
6 #
7 # The full license is in the file COPYING.txt, distributed with this software.
7 # The full license is in the file COPYING.txt, distributed with this software.
8 #-----------------------------------------------------------------------------
8 #-----------------------------------------------------------------------------
9
9
10 #-----------------------------------------------------------------------------
10 #-----------------------------------------------------------------------------
11 # Imports
11 # Imports
12 #-----------------------------------------------------------------------------
12 #-----------------------------------------------------------------------------
13 from __future__ import print_function
13 from __future__ import print_function
14
14
15 # Stdlib imports
15 # Stdlib imports
16 import atexit
16 import atexit
17 import datetime
17 import datetime
18 import os
18 import os
19 import re
19 import re
20 try:
20 try:
21 import sqlite3
21 import sqlite3
22 except ImportError:
22 except ImportError:
23 try:
23 try:
24 from pysqlite2 import dbapi2 as sqlite3
24 from pysqlite2 import dbapi2 as sqlite3
25 except ImportError:
25 except ImportError:
26 sqlite3 = None
26 sqlite3 = None
27 import threading
27 import threading
28
28
29 # Our own packages
29 # Our own packages
30 from IPython.config.configurable import Configurable
30 from IPython.config.configurable import Configurable
31 from IPython.external.decorator import decorator
31 from IPython.external.decorator import decorator
32 from IPython.utils.decorators import undoc
32 from IPython.utils.decorators import undoc
33 from IPython.utils.path import locate_profile
33 from IPython.utils.path import locate_profile
34 from IPython.utils import py3compat
34 from IPython.utils import py3compat
35 from IPython.utils.traitlets import (
35 from IPython.utils.traitlets import (
36 Any, Bool, Dict, Instance, Integer, List, Unicode, TraitError,
36 Any, Bool, Dict, Instance, Integer, List, Unicode, TraitError,
37 )
37 )
38 from IPython.utils.warn import warn
38 from IPython.utils.warn import warn
39
39
40 #-----------------------------------------------------------------------------
40 #-----------------------------------------------------------------------------
41 # Classes and functions
41 # Classes and functions
42 #-----------------------------------------------------------------------------
42 #-----------------------------------------------------------------------------
43
43
44 @undoc
44 @undoc
45 class DummyDB(object):
45 class DummyDB(object):
46 """Dummy DB that will act as a black hole for history.
46 """Dummy DB that will act as a black hole for history.
47
47
48 Only used in the absence of sqlite"""
48 Only used in the absence of sqlite"""
49 def execute(*args, **kwargs):
49 def execute(*args, **kwargs):
50 return []
50 return []
51
51
52 def commit(self, *args, **kwargs):
52 def commit(self, *args, **kwargs):
53 pass
53 pass
54
54
55 def __enter__(self, *args, **kwargs):
55 def __enter__(self, *args, **kwargs):
56 pass
56 pass
57
57
58 def __exit__(self, *args, **kwargs):
58 def __exit__(self, *args, **kwargs):
59 pass
59 pass
60
60
61
61
62 @decorator
62 @decorator
63 def needs_sqlite(f, self, *a, **kw):
63 def needs_sqlite(f, self, *a, **kw):
64 """Decorator: return an empty list in the absence of sqlite."""
64 """Decorator: return an empty list in the absence of sqlite."""
65 if sqlite3 is None or not self.enabled:
65 if sqlite3 is None or not self.enabled:
66 return []
66 return []
67 else:
67 else:
68 return f(self, *a, **kw)
68 return f(self, *a, **kw)
69
69
70
70
71 if sqlite3 is not None:
71 if sqlite3 is not None:
72 DatabaseError = sqlite3.DatabaseError
72 DatabaseError = sqlite3.DatabaseError
73 else:
73 else:
74 @undoc
74 @undoc
75 class DatabaseError(Exception):
75 class DatabaseError(Exception):
76 "Dummy exception when sqlite could not be imported. Should never occur."
76 "Dummy exception when sqlite could not be imported. Should never occur."
77
77
78 @decorator
78 @decorator
79 def catch_corrupt_db(f, self, *a, **kw):
79 def catch_corrupt_db(f, self, *a, **kw):
80 """A decorator which wraps HistoryAccessor method calls to catch errors from
80 """A decorator which wraps HistoryAccessor method calls to catch errors from
81 a corrupt SQLite database, move the old database out of the way, and create
81 a corrupt SQLite database, move the old database out of the way, and create
82 a new one.
82 a new one.
83 """
83 """
84 try:
84 try:
85 return f(self, *a, **kw)
85 return f(self, *a, **kw)
86 except DatabaseError:
86 except DatabaseError:
87 if os.path.isfile(self.hist_file):
87 if os.path.isfile(self.hist_file):
88 # Try to move the file out of the way
88 # Try to move the file out of the way
89 base,ext = os.path.splitext(self.hist_file)
89 base,ext = os.path.splitext(self.hist_file)
90 newpath = base + '-corrupt' + ext
90 newpath = base + '-corrupt' + ext
91 os.rename(self.hist_file, newpath)
91 os.rename(self.hist_file, newpath)
92 self.init_db()
92 self.init_db()
93 print("ERROR! History file wasn't a valid SQLite database.",
93 print("ERROR! History file wasn't a valid SQLite database.",
94 "It was moved to %s" % newpath, "and a new file created.")
94 "It was moved to %s" % newpath, "and a new file created.")
95 return []
95 return []
96
96
97 else:
97 else:
98 # The hist_file is probably :memory: or something else.
98 # The hist_file is probably :memory: or something else.
99 raise
99 raise
100
100
101 class HistoryAccessorBase(Configurable):
102 """An abstract class for History Accessors """
101
103
104 def get_tail(self, n=10, raw=True, output=False, include_latest=False):
105 raise NotImplementedError
106
107 def search(self, pattern="*", raw=True, search_raw=True,
108 output=False, n=None, unique=False):
109 raise NotImplementedError
110
111 def get_range(self, session, start=1, stop=None, raw=True,output=False):
112 raise NotImplementedError
102
113
103 class HistoryAccessor(Configurable):
114 def get_range_by_str(self, rangestr, raw=True, output=False):
115 raise NotImplementedError
116
117
118 class HistoryAccessor(HistoryAccessorBase):
104 """Access the history database without adding to it.
119 """Access the history database without adding to it.
105
120
106 This is intended for use by standalone history tools. IPython shells use
121 This is intended for use by standalone history tools. IPython shells use
107 HistoryManager, below, which is a subclass of this."""
122 HistoryManager, below, which is a subclass of this."""
108
123
109 # String holding the path to the history file
124 # String holding the path to the history file
110 hist_file = Unicode(config=True,
125 hist_file = Unicode(config=True,
111 help="""Path to file to use for SQLite history database.
126 help="""Path to file to use for SQLite history database.
112
127
113 By default, IPython will put the history database in the IPython
128 By default, IPython will put the history database in the IPython
114 profile directory. If you would rather share one history among
129 profile directory. If you would rather share one history among
115 profiles, you can set this value in each, so that they are consistent.
130 profiles, you can set this value in each, so that they are consistent.
116
131
117 Due to an issue with fcntl, SQLite is known to misbehave on some NFS
132 Due to an issue with fcntl, SQLite is known to misbehave on some NFS
118 mounts. If you see IPython hanging, try setting this to something on a
133 mounts. If you see IPython hanging, try setting this to something on a
119 local disk, e.g::
134 local disk, e.g::
120
135
121 ipython --HistoryManager.hist_file=/tmp/ipython_hist.sqlite
136 ipython --HistoryManager.hist_file=/tmp/ipython_hist.sqlite
122
137
123 """)
138 """)
124
139
125 enabled = Bool(True, config=True,
140 enabled = Bool(True, config=True,
126 help="""enable the SQLite history
141 help="""enable the SQLite history
127
142
128 set enabled=False to disable the SQLite history,
143 set enabled=False to disable the SQLite history,
129 in which case there will be no stored history, no SQLite connection,
144 in which case there will be no stored history, no SQLite connection,
130 and no background saving thread. This may be necessary in some
145 and no background saving thread. This may be necessary in some
131 threaded environments where IPython is embedded.
146 threaded environments where IPython is embedded.
132 """
147 """
133 )
148 )
134
149
135 connection_options = Dict(config=True,
150 connection_options = Dict(config=True,
136 help="""Options for configuring the SQLite connection
151 help="""Options for configuring the SQLite connection
137
152
138 These options are passed as keyword args to sqlite3.connect
153 These options are passed as keyword args to sqlite3.connect
139 when establishing database conenctions.
154 when establishing database conenctions.
140 """
155 """
141 )
156 )
142
157
143 # The SQLite database
158 # The SQLite database
144 db = Any()
159 db = Any()
145 def _db_changed(self, name, old, new):
160 def _db_changed(self, name, old, new):
146 """validate the db, since it can be an Instance of two different types"""
161 """validate the db, since it can be an Instance of two different types"""
147 connection_types = (DummyDB,)
162 connection_types = (DummyDB,)
148 if sqlite3 is not None:
163 if sqlite3 is not None:
149 connection_types = (DummyDB, sqlite3.Connection)
164 connection_types = (DummyDB, sqlite3.Connection)
150 if not isinstance(new, connection_types):
165 if not isinstance(new, connection_types):
151 msg = "%s.db must be sqlite3 Connection or DummyDB, not %r" % \
166 msg = "%s.db must be sqlite3 Connection or DummyDB, not %r" % \
152 (self.__class__.__name__, new)
167 (self.__class__.__name__, new)
153 raise TraitError(msg)
168 raise TraitError(msg)
154
169
155 def __init__(self, profile='default', hist_file=u'', **traits):
170 def __init__(self, profile='default', hist_file=u'', **traits):
156 """Create a new history accessor.
171 """Create a new history accessor.
157
172
158 Parameters
173 Parameters
159 ----------
174 ----------
160 profile : str
175 profile : str
161 The name of the profile from which to open history.
176 The name of the profile from which to open history.
162 hist_file : str
177 hist_file : str
163 Path to an SQLite history database stored by IPython. If specified,
178 Path to an SQLite history database stored by IPython. If specified,
164 hist_file overrides profile.
179 hist_file overrides profile.
165 config : :class:`~IPython.config.loader.Config`
180 config : :class:`~IPython.config.loader.Config`
166 Config object. hist_file can also be set through this.
181 Config object. hist_file can also be set through this.
167 """
182 """
168 # We need a pointer back to the shell for various tasks.
183 # We need a pointer back to the shell for various tasks.
169 super(HistoryAccessor, self).__init__(**traits)
184 super(HistoryAccessor, self).__init__(**traits)
170 # defer setting hist_file from kwarg until after init,
185 # defer setting hist_file from kwarg until after init,
171 # otherwise the default kwarg value would clobber any value
186 # otherwise the default kwarg value would clobber any value
172 # set by config
187 # set by config
173 if hist_file:
188 if hist_file:
174 self.hist_file = hist_file
189 self.hist_file = hist_file
175
190
176 if self.hist_file == u'':
191 if self.hist_file == u'':
177 # No one has set the hist_file, yet.
192 # No one has set the hist_file, yet.
178 self.hist_file = self._get_hist_file_name(profile)
193 self.hist_file = self._get_hist_file_name(profile)
179
194
180 if sqlite3 is None and self.enabled:
195 if sqlite3 is None and self.enabled:
181 warn("IPython History requires SQLite, your history will not be saved")
196 warn("IPython History requires SQLite, your history will not be saved")
182 self.enabled = False
197 self.enabled = False
183
198
184 self.init_db()
199 self.init_db()
185
200
186 def _get_hist_file_name(self, profile='default'):
201 def _get_hist_file_name(self, profile='default'):
187 """Find the history file for the given profile name.
202 """Find the history file for the given profile name.
188
203
189 This is overridden by the HistoryManager subclass, to use the shell's
204 This is overridden by the HistoryManager subclass, to use the shell's
190 active profile.
205 active profile.
191
206
192 Parameters
207 Parameters
193 ----------
208 ----------
194 profile : str
209 profile : str
195 The name of a profile which has a history file.
210 The name of a profile which has a history file.
196 """
211 """
197 return os.path.join(locate_profile(profile), 'history.sqlite')
212 return os.path.join(locate_profile(profile), 'history.sqlite')
198
213
199 @catch_corrupt_db
214 @catch_corrupt_db
200 def init_db(self):
215 def init_db(self):
201 """Connect to the database, and create tables if necessary."""
216 """Connect to the database, and create tables if necessary."""
202 if not self.enabled:
217 if not self.enabled:
203 self.db = DummyDB()
218 self.db = DummyDB()
204 return
219 return
205
220
206 # use detect_types so that timestamps return datetime objects
221 # use detect_types so that timestamps return datetime objects
207 kwargs = dict(detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
222 kwargs = dict(detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
208 kwargs.update(self.connection_options)
223 kwargs.update(self.connection_options)
209 self.db = sqlite3.connect(self.hist_file, **kwargs)
224 self.db = sqlite3.connect(self.hist_file, **kwargs)
210 self.db.execute("""CREATE TABLE IF NOT EXISTS sessions (session integer
225 self.db.execute("""CREATE TABLE IF NOT EXISTS sessions (session integer
211 primary key autoincrement, start timestamp,
226 primary key autoincrement, start timestamp,
212 end timestamp, num_cmds integer, remark text)""")
227 end timestamp, num_cmds integer, remark text)""")
213 self.db.execute("""CREATE TABLE IF NOT EXISTS history
228 self.db.execute("""CREATE TABLE IF NOT EXISTS history
214 (session integer, line integer, source text, source_raw text,
229 (session integer, line integer, source text, source_raw text,
215 PRIMARY KEY (session, line))""")
230 PRIMARY KEY (session, line))""")
216 # Output history is optional, but ensure the table's there so it can be
231 # Output history is optional, but ensure the table's there so it can be
217 # enabled later.
232 # enabled later.
218 self.db.execute("""CREATE TABLE IF NOT EXISTS output_history
233 self.db.execute("""CREATE TABLE IF NOT EXISTS output_history
219 (session integer, line integer, output text,
234 (session integer, line integer, output text,
220 PRIMARY KEY (session, line))""")
235 PRIMARY KEY (session, line))""")
221 self.db.commit()
236 self.db.commit()
222
237
223 def writeout_cache(self):
238 def writeout_cache(self):
224 """Overridden by HistoryManager to dump the cache before certain
239 """Overridden by HistoryManager to dump the cache before certain
225 database lookups."""
240 database lookups."""
226 pass
241 pass
227
242
228 ## -------------------------------
243 ## -------------------------------
229 ## Methods for retrieving history:
244 ## Methods for retrieving history:
230 ## -------------------------------
245 ## -------------------------------
231 def _run_sql(self, sql, params, raw=True, output=False):
246 def _run_sql(self, sql, params, raw=True, output=False):
232 """Prepares and runs an SQL query for the history database.
247 """Prepares and runs an SQL query for the history database.
233
248
234 Parameters
249 Parameters
235 ----------
250 ----------
236 sql : str
251 sql : str
237 Any filtering expressions to go after SELECT ... FROM ...
252 Any filtering expressions to go after SELECT ... FROM ...
238 params : tuple
253 params : tuple
239 Parameters passed to the SQL query (to replace "?")
254 Parameters passed to the SQL query (to replace "?")
240 raw, output : bool
255 raw, output : bool
241 See :meth:`get_range`
256 See :meth:`get_range`
242
257
243 Returns
258 Returns
244 -------
259 -------
245 Tuples as :meth:`get_range`
260 Tuples as :meth:`get_range`
246 """
261 """
247 toget = 'source_raw' if raw else 'source'
262 toget = 'source_raw' if raw else 'source'
248 sqlfrom = "history"
263 sqlfrom = "history"
249 if output:
264 if output:
250 sqlfrom = "history LEFT JOIN output_history USING (session, line)"
265 sqlfrom = "history LEFT JOIN output_history USING (session, line)"
251 toget = "history.%s, output_history.output" % toget
266 toget = "history.%s, output_history.output" % toget
252 cur = self.db.execute("SELECT session, line, %s FROM %s " %\
267 cur = self.db.execute("SELECT session, line, %s FROM %s " %\
253 (toget, sqlfrom) + sql, params)
268 (toget, sqlfrom) + sql, params)
254 if output: # Regroup into 3-tuples, and parse JSON
269 if output: # Regroup into 3-tuples, and parse JSON
255 return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)
270 return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)
256 return cur
271 return cur
257
272
258 @needs_sqlite
273 @needs_sqlite
259 @catch_corrupt_db
274 @catch_corrupt_db
260 def get_session_info(self, session):
275 def get_session_info(self, session):
261 """Get info about a session.
276 """Get info about a session.
262
277
263 Parameters
278 Parameters
264 ----------
279 ----------
265
280
266 session : int
281 session : int
267 Session number to retrieve.
282 Session number to retrieve.
268
283
269 Returns
284 Returns
270 -------
285 -------
271
286
272 session_id : int
287 session_id : int
273 Session ID number
288 Session ID number
274 start : datetime
289 start : datetime
275 Timestamp for the start of the session.
290 Timestamp for the start of the session.
276 end : datetime
291 end : datetime
277 Timestamp for the end of the session, or None if IPython crashed.
292 Timestamp for the end of the session, or None if IPython crashed.
278 num_cmds : int
293 num_cmds : int
279 Number of commands run, or None if IPython crashed.
294 Number of commands run, or None if IPython crashed.
280 remark : unicode
295 remark : unicode
281 A manually set description.
296 A manually set description.
282 """
297 """
283 query = "SELECT * from sessions where session == ?"
298 query = "SELECT * from sessions where session == ?"
284 return self.db.execute(query, (session,)).fetchone()
299 return self.db.execute(query, (session,)).fetchone()
285
300
286 @catch_corrupt_db
301 @catch_corrupt_db
287 def get_last_session_id(self):
302 def get_last_session_id(self):
288 """Get the last session ID currently in the database.
303 """Get the last session ID currently in the database.
289
304
290 Within IPython, this should be the same as the value stored in
305 Within IPython, this should be the same as the value stored in
291 :attr:`HistoryManager.session_number`.
306 :attr:`HistoryManager.session_number`.
292 """
307 """
293 for record in self.get_tail(n=1, include_latest=True):
308 for record in self.get_tail(n=1, include_latest=True):
294 return record[0]
309 return record[0]
295
310
296 @catch_corrupt_db
311 @catch_corrupt_db
297 def get_tail(self, n=10, raw=True, output=False, include_latest=False):
312 def get_tail(self, n=10, raw=True, output=False, include_latest=False):
298 """Get the last n lines from the history database.
313 """Get the last n lines from the history database.
299
314
300 Parameters
315 Parameters
301 ----------
316 ----------
302 n : int
317 n : int
303 The number of lines to get
318 The number of lines to get
304 raw, output : bool
319 raw, output : bool
305 See :meth:`get_range`
320 See :meth:`get_range`
306 include_latest : bool
321 include_latest : bool
307 If False (default), n+1 lines are fetched, and the latest one
322 If False (default), n+1 lines are fetched, and the latest one
308 is discarded. This is intended to be used where the function
323 is discarded. This is intended to be used where the function
309 is called by a user command, which it should not return.
324 is called by a user command, which it should not return.
310
325
311 Returns
326 Returns
312 -------
327 -------
313 Tuples as :meth:`get_range`
328 Tuples as :meth:`get_range`
314 """
329 """
315 self.writeout_cache()
330 self.writeout_cache()
316 if not include_latest:
331 if not include_latest:
317 n += 1
332 n += 1
318 cur = self._run_sql("ORDER BY session DESC, line DESC LIMIT ?",
333 cur = self._run_sql("ORDER BY session DESC, line DESC LIMIT ?",
319 (n,), raw=raw, output=output)
334 (n,), raw=raw, output=output)
320 if not include_latest:
335 if not include_latest:
321 return reversed(list(cur)[1:])
336 return reversed(list(cur)[1:])
322 return reversed(list(cur))
337 return reversed(list(cur))
323
338
324 @catch_corrupt_db
339 @catch_corrupt_db
325 def search(self, pattern="*", raw=True, search_raw=True,
340 def search(self, pattern="*", raw=True, search_raw=True,
326 output=False, n=None, unique=False):
341 output=False, n=None, unique=False):
327 """Search the database using unix glob-style matching (wildcards
342 """Search the database using unix glob-style matching (wildcards
328 * and ?).
343 * and ?).
329
344
330 Parameters
345 Parameters
331 ----------
346 ----------
332 pattern : str
347 pattern : str
333 The wildcarded pattern to match when searching
348 The wildcarded pattern to match when searching
334 search_raw : bool
349 search_raw : bool
335 If True, search the raw input, otherwise, the parsed input
350 If True, search the raw input, otherwise, the parsed input
336 raw, output : bool
351 raw, output : bool
337 See :meth:`get_range`
352 See :meth:`get_range`
338 n : None or int
353 n : None or int
339 If an integer is given, it defines the limit of
354 If an integer is given, it defines the limit of
340 returned entries.
355 returned entries.
341 unique : bool
356 unique : bool
342 When it is true, return only unique entries.
357 When it is true, return only unique entries.
343
358
344 Returns
359 Returns
345 -------
360 -------
346 Tuples as :meth:`get_range`
361 Tuples as :meth:`get_range`
347 """
362 """
348 tosearch = "source_raw" if search_raw else "source"
363 tosearch = "source_raw" if search_raw else "source"
349 if output:
364 if output:
350 tosearch = "history." + tosearch
365 tosearch = "history." + tosearch
351 self.writeout_cache()
366 self.writeout_cache()
352 sqlform = "WHERE %s GLOB ?" % tosearch
367 sqlform = "WHERE %s GLOB ?" % tosearch
353 params = (pattern,)
368 params = (pattern,)
354 if unique:
369 if unique:
355 sqlform += ' GROUP BY {0}'.format(tosearch)
370 sqlform += ' GROUP BY {0}'.format(tosearch)
356 if n is not None:
371 if n is not None:
357 sqlform += " ORDER BY session DESC, line DESC LIMIT ?"
372 sqlform += " ORDER BY session DESC, line DESC LIMIT ?"
358 params += (n,)
373 params += (n,)
359 elif unique:
374 elif unique:
360 sqlform += " ORDER BY session, line"
375 sqlform += " ORDER BY session, line"
361 cur = self._run_sql(sqlform, params, raw=raw, output=output)
376 cur = self._run_sql(sqlform, params, raw=raw, output=output)
362 if n is not None:
377 if n is not None:
363 return reversed(list(cur))
378 return reversed(list(cur))
364 return cur
379 return cur
365
380
366 @catch_corrupt_db
381 @catch_corrupt_db
367 def get_range(self, session, start=1, stop=None, raw=True,output=False):
382 def get_range(self, session, start=1, stop=None, raw=True,output=False):
368 """Retrieve input by session.
383 """Retrieve input by session.
369
384
370 Parameters
385 Parameters
371 ----------
386 ----------
372 session : int
387 session : int
373 Session number to retrieve.
388 Session number to retrieve.
374 start : int
389 start : int
375 First line to retrieve.
390 First line to retrieve.
376 stop : int
391 stop : int
377 End of line range (excluded from output itself). If None, retrieve
392 End of line range (excluded from output itself). If None, retrieve
378 to the end of the session.
393 to the end of the session.
379 raw : bool
394 raw : bool
380 If True, return untranslated input
395 If True, return untranslated input
381 output : bool
396 output : bool
382 If True, attempt to include output. This will be 'real' Python
397 If True, attempt to include output. This will be 'real' Python
383 objects for the current session, or text reprs from previous
398 objects for the current session, or text reprs from previous
384 sessions if db_log_output was enabled at the time. Where no output
399 sessions if db_log_output was enabled at the time. Where no output
385 is found, None is used.
400 is found, None is used.
386
401
387 Returns
402 Returns
388 -------
403 -------
389 entries
404 entries
390 An iterator over the desired lines. Each line is a 3-tuple, either
405 An iterator over the desired lines. Each line is a 3-tuple, either
391 (session, line, input) if output is False, or
406 (session, line, input) if output is False, or
392 (session, line, (input, output)) if output is True.
407 (session, line, (input, output)) if output is True.
393 """
408 """
394 if stop:
409 if stop:
395 lineclause = "line >= ? AND line < ?"
410 lineclause = "line >= ? AND line < ?"
396 params = (session, start, stop)
411 params = (session, start, stop)
397 else:
412 else:
398 lineclause = "line>=?"
413 lineclause = "line>=?"
399 params = (session, start)
414 params = (session, start)
400
415
401 return self._run_sql("WHERE session==? AND %s" % lineclause,
416 return self._run_sql("WHERE session==? AND %s" % lineclause,
402 params, raw=raw, output=output)
417 params, raw=raw, output=output)
403
418
404 def get_range_by_str(self, rangestr, raw=True, output=False):
419 def get_range_by_str(self, rangestr, raw=True, output=False):
405 """Get lines of history from a string of ranges, as used by magic
420 """Get lines of history from a string of ranges, as used by magic
406 commands %hist, %save, %macro, etc.
421 commands %hist, %save, %macro, etc.
407
422
408 Parameters
423 Parameters
409 ----------
424 ----------
410 rangestr : str
425 rangestr : str
411 A string specifying ranges, e.g. "5 ~2/1-4". See
426 A string specifying ranges, e.g. "5 ~2/1-4". See
412 :func:`magic_history` for full details.
427 :func:`magic_history` for full details.
413 raw, output : bool
428 raw, output : bool
414 As :meth:`get_range`
429 As :meth:`get_range`
415
430
416 Returns
431 Returns
417 -------
432 -------
418 Tuples as :meth:`get_range`
433 Tuples as :meth:`get_range`
419 """
434 """
420 for sess, s, e in extract_hist_ranges(rangestr):
435 for sess, s, e in extract_hist_ranges(rangestr):
421 for line in self.get_range(sess, s, e, raw=raw, output=output):
436 for line in self.get_range(sess, s, e, raw=raw, output=output):
422 yield line
437 yield line
423
438
424
439
425 class HistoryManager(HistoryAccessor):
440 class HistoryManager(HistoryAccessor):
426 """A class to organize all history-related functionality in one place.
441 """A class to organize all history-related functionality in one place.
427 """
442 """
428 # Public interface
443 # Public interface
429
444
430 # An instance of the IPython shell we are attached to
445 # An instance of the IPython shell we are attached to
431 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
446 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
432 # Lists to hold processed and raw history. These start with a blank entry
447 # Lists to hold processed and raw history. These start with a blank entry
433 # so that we can index them starting from 1
448 # so that we can index them starting from 1
434 input_hist_parsed = List([""])
449 input_hist_parsed = List([""])
435 input_hist_raw = List([""])
450 input_hist_raw = List([""])
436 # A list of directories visited during session
451 # A list of directories visited during session
437 dir_hist = List()
452 dir_hist = List()
438 def _dir_hist_default(self):
453 def _dir_hist_default(self):
439 try:
454 try:
440 return [py3compat.getcwd()]
455 return [py3compat.getcwd()]
441 except OSError:
456 except OSError:
442 return []
457 return []
443
458
444 # A dict of output history, keyed with ints from the shell's
459 # A dict of output history, keyed with ints from the shell's
445 # execution count.
460 # execution count.
446 output_hist = Dict()
461 output_hist = Dict()
447 # The text/plain repr of outputs.
462 # The text/plain repr of outputs.
448 output_hist_reprs = Dict()
463 output_hist_reprs = Dict()
449
464
450 # The number of the current session in the history database
465 # The number of the current session in the history database
451 session_number = Integer()
466 session_number = Integer()
452
467
453 db_log_output = Bool(False, config=True,
468 db_log_output = Bool(False, config=True,
454 help="Should the history database include output? (default: no)"
469 help="Should the history database include output? (default: no)"
455 )
470 )
456 db_cache_size = Integer(0, config=True,
471 db_cache_size = Integer(0, config=True,
457 help="Write to database every x commands (higher values save disk access & power).\n"
472 help="Write to database every x commands (higher values save disk access & power).\n"
458 "Values of 1 or less effectively disable caching."
473 "Values of 1 or less effectively disable caching."
459 )
474 )
460 # The input and output caches
475 # The input and output caches
461 db_input_cache = List()
476 db_input_cache = List()
462 db_output_cache = List()
477 db_output_cache = List()
463
478
464 # History saving in separate thread
479 # History saving in separate thread
465 save_thread = Instance('IPython.core.history.HistorySavingThread')
480 save_thread = Instance('IPython.core.history.HistorySavingThread')
466 try: # Event is a function returning an instance of _Event...
481 try: # Event is a function returning an instance of _Event...
467 save_flag = Instance(threading._Event)
482 save_flag = Instance(threading._Event)
468 except AttributeError: # ...until Python 3.3, when it's a class.
483 except AttributeError: # ...until Python 3.3, when it's a class.
469 save_flag = Instance(threading.Event)
484 save_flag = Instance(threading.Event)
470
485
471 # Private interface
486 # Private interface
472 # Variables used to store the three last inputs from the user. On each new
487 # Variables used to store the three last inputs from the user. On each new
473 # history update, we populate the user's namespace with these, shifted as
488 # history update, we populate the user's namespace with these, shifted as
474 # necessary.
489 # necessary.
475 _i00 = Unicode(u'')
490 _i00 = Unicode(u'')
476 _i = Unicode(u'')
491 _i = Unicode(u'')
477 _ii = Unicode(u'')
492 _ii = Unicode(u'')
478 _iii = Unicode(u'')
493 _iii = Unicode(u'')
479
494
480 # A regex matching all forms of the exit command, so that we don't store
495 # A regex matching all forms of the exit command, so that we don't store
481 # them in the history (it's annoying to rewind the first entry and land on
496 # them in the history (it's annoying to rewind the first entry and land on
482 # an exit call).
497 # an exit call).
483 _exit_re = re.compile(r"(exit|quit)(\s*\(.*\))?$")
498 _exit_re = re.compile(r"(exit|quit)(\s*\(.*\))?$")
484
499
485 def __init__(self, shell=None, config=None, **traits):
500 def __init__(self, shell=None, config=None, **traits):
486 """Create a new history manager associated with a shell instance.
501 """Create a new history manager associated with a shell instance.
487 """
502 """
488 # We need a pointer back to the shell for various tasks.
503 # We need a pointer back to the shell for various tasks.
489 super(HistoryManager, self).__init__(shell=shell, config=config,
504 super(HistoryManager, self).__init__(shell=shell, config=config,
490 **traits)
505 **traits)
491 self.save_flag = threading.Event()
506 self.save_flag = threading.Event()
492 self.db_input_cache_lock = threading.Lock()
507 self.db_input_cache_lock = threading.Lock()
493 self.db_output_cache_lock = threading.Lock()
508 self.db_output_cache_lock = threading.Lock()
494 if self.enabled and self.hist_file != ':memory:':
509 if self.enabled and self.hist_file != ':memory:':
495 self.save_thread = HistorySavingThread(self)
510 self.save_thread = HistorySavingThread(self)
496 self.save_thread.start()
511 self.save_thread.start()
497
512
498 self.new_session()
513 self.new_session()
499
514
500 def _get_hist_file_name(self, profile=None):
515 def _get_hist_file_name(self, profile=None):
501 """Get default history file name based on the Shell's profile.
516 """Get default history file name based on the Shell's profile.
502
517
503 The profile parameter is ignored, but must exist for compatibility with
518 The profile parameter is ignored, but must exist for compatibility with
504 the parent class."""
519 the parent class."""
505 profile_dir = self.shell.profile_dir.location
520 profile_dir = self.shell.profile_dir.location
506 return os.path.join(profile_dir, 'history.sqlite')
521 return os.path.join(profile_dir, 'history.sqlite')
507
522
508 @needs_sqlite
523 @needs_sqlite
509 def new_session(self, conn=None):
524 def new_session(self, conn=None):
510 """Get a new session number."""
525 """Get a new session number."""
511 if conn is None:
526 if conn is None:
512 conn = self.db
527 conn = self.db
513
528
514 with conn:
529 with conn:
515 cur = conn.execute("""INSERT INTO sessions VALUES (NULL, ?, NULL,
530 cur = conn.execute("""INSERT INTO sessions VALUES (NULL, ?, NULL,
516 NULL, "") """, (datetime.datetime.now(),))
531 NULL, "") """, (datetime.datetime.now(),))
517 self.session_number = cur.lastrowid
532 self.session_number = cur.lastrowid
518
533
519 def end_session(self):
534 def end_session(self):
520 """Close the database session, filling in the end time and line count."""
535 """Close the database session, filling in the end time and line count."""
521 self.writeout_cache()
536 self.writeout_cache()
522 with self.db:
537 with self.db:
523 self.db.execute("""UPDATE sessions SET end=?, num_cmds=? WHERE
538 self.db.execute("""UPDATE sessions SET end=?, num_cmds=? WHERE
524 session==?""", (datetime.datetime.now(),
539 session==?""", (datetime.datetime.now(),
525 len(self.input_hist_parsed)-1, self.session_number))
540 len(self.input_hist_parsed)-1, self.session_number))
526 self.session_number = 0
541 self.session_number = 0
527
542
528 def name_session(self, name):
543 def name_session(self, name):
529 """Give the current session a name in the history database."""
544 """Give the current session a name in the history database."""
530 with self.db:
545 with self.db:
531 self.db.execute("UPDATE sessions SET remark=? WHERE session==?",
546 self.db.execute("UPDATE sessions SET remark=? WHERE session==?",
532 (name, self.session_number))
547 (name, self.session_number))
533
548
534 def reset(self, new_session=True):
549 def reset(self, new_session=True):
535 """Clear the session history, releasing all object references, and
550 """Clear the session history, releasing all object references, and
536 optionally open a new session."""
551 optionally open a new session."""
537 self.output_hist.clear()
552 self.output_hist.clear()
538 # The directory history can't be completely empty
553 # The directory history can't be completely empty
539 self.dir_hist[:] = [py3compat.getcwd()]
554 self.dir_hist[:] = [py3compat.getcwd()]
540
555
541 if new_session:
556 if new_session:
542 if self.session_number:
557 if self.session_number:
543 self.end_session()
558 self.end_session()
544 self.input_hist_parsed[:] = [""]
559 self.input_hist_parsed[:] = [""]
545 self.input_hist_raw[:] = [""]
560 self.input_hist_raw[:] = [""]
546 self.new_session()
561 self.new_session()
547
562
548 # ------------------------------
563 # ------------------------------
549 # Methods for retrieving history
564 # Methods for retrieving history
550 # ------------------------------
565 # ------------------------------
551 def get_session_info(self, session=0):
566 def get_session_info(self, session=0):
552 """Get info about a session.
567 """Get info about a session.
553
568
554 Parameters
569 Parameters
555 ----------
570 ----------
556
571
557 session : int
572 session : int
558 Session number to retrieve. The current session is 0, and negative
573 Session number to retrieve. The current session is 0, and negative
559 numbers count back from current session, so -1 is the previous session.
574 numbers count back from current session, so -1 is the previous session.
560
575
561 Returns
576 Returns
562 -------
577 -------
563
578
564 session_id : int
579 session_id : int
565 Session ID number
580 Session ID number
566 start : datetime
581 start : datetime
567 Timestamp for the start of the session.
582 Timestamp for the start of the session.
568 end : datetime
583 end : datetime
569 Timestamp for the end of the session, or None if IPython crashed.
584 Timestamp for the end of the session, or None if IPython crashed.
570 num_cmds : int
585 num_cmds : int
571 Number of commands run, or None if IPython crashed.
586 Number of commands run, or None if IPython crashed.
572 remark : unicode
587 remark : unicode
573 A manually set description.
588 A manually set description.
574 """
589 """
575 if session <= 0:
590 if session <= 0:
576 session += self.session_number
591 session += self.session_number
577
592
578 return super(HistoryManager, self).get_session_info(session=session)
593 return super(HistoryManager, self).get_session_info(session=session)
579
594
580 def _get_range_session(self, start=1, stop=None, raw=True, output=False):
595 def _get_range_session(self, start=1, stop=None, raw=True, output=False):
581 """Get input and output history from the current session. Called by
596 """Get input and output history from the current session. Called by
582 get_range, and takes similar parameters."""
597 get_range, and takes similar parameters."""
583 input_hist = self.input_hist_raw if raw else self.input_hist_parsed
598 input_hist = self.input_hist_raw if raw else self.input_hist_parsed
584
599
585 n = len(input_hist)
600 n = len(input_hist)
586 if start < 0:
601 if start < 0:
587 start += n
602 start += n
588 if not stop or (stop > n):
603 if not stop or (stop > n):
589 stop = n
604 stop = n
590 elif stop < 0:
605 elif stop < 0:
591 stop += n
606 stop += n
592
607
593 for i in range(start, stop):
608 for i in range(start, stop):
594 if output:
609 if output:
595 line = (input_hist[i], self.output_hist_reprs.get(i))
610 line = (input_hist[i], self.output_hist_reprs.get(i))
596 else:
611 else:
597 line = input_hist[i]
612 line = input_hist[i]
598 yield (0, i, line)
613 yield (0, i, line)
599
614
600 def get_range(self, session=0, start=1, stop=None, raw=True,output=False):
615 def get_range(self, session=0, start=1, stop=None, raw=True,output=False):
601 """Retrieve input by session.
616 """Retrieve input by session.
602
617
603 Parameters
618 Parameters
604 ----------
619 ----------
605 session : int
620 session : int
606 Session number to retrieve. The current session is 0, and negative
621 Session number to retrieve. The current session is 0, and negative
607 numbers count back from current session, so -1 is previous session.
622 numbers count back from current session, so -1 is previous session.
608 start : int
623 start : int
609 First line to retrieve.
624 First line to retrieve.
610 stop : int
625 stop : int
611 End of line range (excluded from output itself). If None, retrieve
626 End of line range (excluded from output itself). If None, retrieve
612 to the end of the session.
627 to the end of the session.
613 raw : bool
628 raw : bool
614 If True, return untranslated input
629 If True, return untranslated input
615 output : bool
630 output : bool
616 If True, attempt to include output. This will be 'real' Python
631 If True, attempt to include output. This will be 'real' Python
617 objects for the current session, or text reprs from previous
632 objects for the current session, or text reprs from previous
618 sessions if db_log_output was enabled at the time. Where no output
633 sessions if db_log_output was enabled at the time. Where no output
619 is found, None is used.
634 is found, None is used.
620
635
621 Returns
636 Returns
622 -------
637 -------
623 entries
638 entries
624 An iterator over the desired lines. Each line is a 3-tuple, either
639 An iterator over the desired lines. Each line is a 3-tuple, either
625 (session, line, input) if output is False, or
640 (session, line, input) if output is False, or
626 (session, line, (input, output)) if output is True.
641 (session, line, (input, output)) if output is True.
627 """
642 """
628 if session <= 0:
643 if session <= 0:
629 session += self.session_number
644 session += self.session_number
630 if session==self.session_number: # Current session
645 if session==self.session_number: # Current session
631 return self._get_range_session(start, stop, raw, output)
646 return self._get_range_session(start, stop, raw, output)
632 return super(HistoryManager, self).get_range(session, start, stop, raw,
647 return super(HistoryManager, self).get_range(session, start, stop, raw,
633 output)
648 output)
634
649
635 ## ----------------------------
650 ## ----------------------------
636 ## Methods for storing history:
651 ## Methods for storing history:
637 ## ----------------------------
652 ## ----------------------------
638 def store_inputs(self, line_num, source, source_raw=None):
653 def store_inputs(self, line_num, source, source_raw=None):
639 """Store source and raw input in history and create input cache
654 """Store source and raw input in history and create input cache
640 variables ``_i*``.
655 variables ``_i*``.
641
656
642 Parameters
657 Parameters
643 ----------
658 ----------
644 line_num : int
659 line_num : int
645 The prompt number of this input.
660 The prompt number of this input.
646
661
647 source : str
662 source : str
648 Python input.
663 Python input.
649
664
650 source_raw : str, optional
665 source_raw : str, optional
651 If given, this is the raw input without any IPython transformations
666 If given, this is the raw input without any IPython transformations
652 applied to it. If not given, ``source`` is used.
667 applied to it. If not given, ``source`` is used.
653 """
668 """
654 if source_raw is None:
669 if source_raw is None:
655 source_raw = source
670 source_raw = source
656 source = source.rstrip('\n')
671 source = source.rstrip('\n')
657 source_raw = source_raw.rstrip('\n')
672 source_raw = source_raw.rstrip('\n')
658
673
659 # do not store exit/quit commands
674 # do not store exit/quit commands
660 if self._exit_re.match(source_raw.strip()):
675 if self._exit_re.match(source_raw.strip()):
661 return
676 return
662
677
663 self.input_hist_parsed.append(source)
678 self.input_hist_parsed.append(source)
664 self.input_hist_raw.append(source_raw)
679 self.input_hist_raw.append(source_raw)
665
680
666 with self.db_input_cache_lock:
681 with self.db_input_cache_lock:
667 self.db_input_cache.append((line_num, source, source_raw))
682 self.db_input_cache.append((line_num, source, source_raw))
668 # Trigger to flush cache and write to DB.
683 # Trigger to flush cache and write to DB.
669 if len(self.db_input_cache) >= self.db_cache_size:
684 if len(self.db_input_cache) >= self.db_cache_size:
670 self.save_flag.set()
685 self.save_flag.set()
671
686
672 # update the auto _i variables
687 # update the auto _i variables
673 self._iii = self._ii
688 self._iii = self._ii
674 self._ii = self._i
689 self._ii = self._i
675 self._i = self._i00
690 self._i = self._i00
676 self._i00 = source_raw
691 self._i00 = source_raw
677
692
678 # hackish access to user namespace to create _i1,_i2... dynamically
693 # hackish access to user namespace to create _i1,_i2... dynamically
679 new_i = '_i%s' % line_num
694 new_i = '_i%s' % line_num
680 to_main = {'_i': self._i,
695 to_main = {'_i': self._i,
681 '_ii': self._ii,
696 '_ii': self._ii,
682 '_iii': self._iii,
697 '_iii': self._iii,
683 new_i : self._i00 }
698 new_i : self._i00 }
684
699
685 if self.shell is not None:
700 if self.shell is not None:
686 self.shell.push(to_main, interactive=False)
701 self.shell.push(to_main, interactive=False)
687
702
688 def store_output(self, line_num):
703 def store_output(self, line_num):
689 """If database output logging is enabled, this saves all the
704 """If database output logging is enabled, this saves all the
690 outputs from the indicated prompt number to the database. It's
705 outputs from the indicated prompt number to the database. It's
691 called by run_cell after code has been executed.
706 called by run_cell after code has been executed.
692
707
693 Parameters
708 Parameters
694 ----------
709 ----------
695 line_num : int
710 line_num : int
696 The line number from which to save outputs
711 The line number from which to save outputs
697 """
712 """
698 if (not self.db_log_output) or (line_num not in self.output_hist_reprs):
713 if (not self.db_log_output) or (line_num not in self.output_hist_reprs):
699 return
714 return
700 output = self.output_hist_reprs[line_num]
715 output = self.output_hist_reprs[line_num]
701
716
702 with self.db_output_cache_lock:
717 with self.db_output_cache_lock:
703 self.db_output_cache.append((line_num, output))
718 self.db_output_cache.append((line_num, output))
704 if self.db_cache_size <= 1:
719 if self.db_cache_size <= 1:
705 self.save_flag.set()
720 self.save_flag.set()
706
721
707 def _writeout_input_cache(self, conn):
722 def _writeout_input_cache(self, conn):
708 with conn:
723 with conn:
709 for line in self.db_input_cache:
724 for line in self.db_input_cache:
710 conn.execute("INSERT INTO history VALUES (?, ?, ?, ?)",
725 conn.execute("INSERT INTO history VALUES (?, ?, ?, ?)",
711 (self.session_number,)+line)
726 (self.session_number,)+line)
712
727
713 def _writeout_output_cache(self, conn):
728 def _writeout_output_cache(self, conn):
714 with conn:
729 with conn:
715 for line in self.db_output_cache:
730 for line in self.db_output_cache:
716 conn.execute("INSERT INTO output_history VALUES (?, ?, ?)",
731 conn.execute("INSERT INTO output_history VALUES (?, ?, ?)",
717 (self.session_number,)+line)
732 (self.session_number,)+line)
718
733
719 @needs_sqlite
734 @needs_sqlite
720 def writeout_cache(self, conn=None):
735 def writeout_cache(self, conn=None):
721 """Write any entries in the cache to the database."""
736 """Write any entries in the cache to the database."""
722 if conn is None:
737 if conn is None:
723 conn = self.db
738 conn = self.db
724
739
725 with self.db_input_cache_lock:
740 with self.db_input_cache_lock:
726 try:
741 try:
727 self._writeout_input_cache(conn)
742 self._writeout_input_cache(conn)
728 except sqlite3.IntegrityError:
743 except sqlite3.IntegrityError:
729 self.new_session(conn)
744 self.new_session(conn)
730 print("ERROR! Session/line number was not unique in",
745 print("ERROR! Session/line number was not unique in",
731 "database. History logging moved to new session",
746 "database. History logging moved to new session",
732 self.session_number)
747 self.session_number)
733 try:
748 try:
734 # Try writing to the new session. If this fails, don't
749 # Try writing to the new session. If this fails, don't
735 # recurse
750 # recurse
736 self._writeout_input_cache(conn)
751 self._writeout_input_cache(conn)
737 except sqlite3.IntegrityError:
752 except sqlite3.IntegrityError:
738 pass
753 pass
739 finally:
754 finally:
740 self.db_input_cache = []
755 self.db_input_cache = []
741
756
742 with self.db_output_cache_lock:
757 with self.db_output_cache_lock:
743 try:
758 try:
744 self._writeout_output_cache(conn)
759 self._writeout_output_cache(conn)
745 except sqlite3.IntegrityError:
760 except sqlite3.IntegrityError:
746 print("!! Session/line number for output was not unique",
761 print("!! Session/line number for output was not unique",
747 "in database. Output will not be stored.")
762 "in database. Output will not be stored.")
748 finally:
763 finally:
749 self.db_output_cache = []
764 self.db_output_cache = []
750
765
751
766
752 class HistorySavingThread(threading.Thread):
767 class HistorySavingThread(threading.Thread):
753 """This thread takes care of writing history to the database, so that
768 """This thread takes care of writing history to the database, so that
754 the UI isn't held up while that happens.
769 the UI isn't held up while that happens.
755
770
756 It waits for the HistoryManager's save_flag to be set, then writes out
771 It waits for the HistoryManager's save_flag to be set, then writes out
757 the history cache. The main thread is responsible for setting the flag when
772 the history cache. The main thread is responsible for setting the flag when
758 the cache size reaches a defined threshold."""
773 the cache size reaches a defined threshold."""
759 daemon = True
774 daemon = True
760 stop_now = False
775 stop_now = False
761 enabled = True
776 enabled = True
762 def __init__(self, history_manager):
777 def __init__(self, history_manager):
763 super(HistorySavingThread, self).__init__(name="IPythonHistorySavingThread")
778 super(HistorySavingThread, self).__init__(name="IPythonHistorySavingThread")
764 self.history_manager = history_manager
779 self.history_manager = history_manager
765 self.enabled = history_manager.enabled
780 self.enabled = history_manager.enabled
766 atexit.register(self.stop)
781 atexit.register(self.stop)
767
782
768 @needs_sqlite
783 @needs_sqlite
769 def run(self):
784 def run(self):
770 # We need a separate db connection per thread:
785 # We need a separate db connection per thread:
771 try:
786 try:
772 self.db = sqlite3.connect(self.history_manager.hist_file,
787 self.db = sqlite3.connect(self.history_manager.hist_file,
773 **self.history_manager.connection_options
788 **self.history_manager.connection_options
774 )
789 )
775 while True:
790 while True:
776 self.history_manager.save_flag.wait()
791 self.history_manager.save_flag.wait()
777 if self.stop_now:
792 if self.stop_now:
778 self.db.close()
793 self.db.close()
779 return
794 return
780 self.history_manager.save_flag.clear()
795 self.history_manager.save_flag.clear()
781 self.history_manager.writeout_cache(self.db)
796 self.history_manager.writeout_cache(self.db)
782 except Exception as e:
797 except Exception as e:
783 print(("The history saving thread hit an unexpected error (%s)."
798 print(("The history saving thread hit an unexpected error (%s)."
784 "History will not be written to the database.") % repr(e))
799 "History will not be written to the database.") % repr(e))
785
800
786 def stop(self):
801 def stop(self):
787 """This can be called from the main thread to safely stop this thread.
802 """This can be called from the main thread to safely stop this thread.
788
803
789 Note that it does not attempt to write out remaining history before
804 Note that it does not attempt to write out remaining history before
790 exiting. That should be done by calling the HistoryManager's
805 exiting. That should be done by calling the HistoryManager's
791 end_session method."""
806 end_session method."""
792 self.stop_now = True
807 self.stop_now = True
793 self.history_manager.save_flag.set()
808 self.history_manager.save_flag.set()
794 self.join()
809 self.join()
795
810
796
811
797 # To match, e.g. ~5/8-~2/3
812 # To match, e.g. ~5/8-~2/3
798 range_re = re.compile(r"""
813 range_re = re.compile(r"""
799 ((?P<startsess>~?\d+)/)?
814 ((?P<startsess>~?\d+)/)?
800 (?P<start>\d+)?
815 (?P<start>\d+)?
801 ((?P<sep>[\-:])
816 ((?P<sep>[\-:])
802 ((?P<endsess>~?\d+)/)?
817 ((?P<endsess>~?\d+)/)?
803 (?P<end>\d+))?
818 (?P<end>\d+))?
804 $""", re.VERBOSE)
819 $""", re.VERBOSE)
805
820
806
821
807 def extract_hist_ranges(ranges_str):
822 def extract_hist_ranges(ranges_str):
808 """Turn a string of history ranges into 3-tuples of (session, start, stop).
823 """Turn a string of history ranges into 3-tuples of (session, start, stop).
809
824
810 Examples
825 Examples
811 --------
826 --------
812 >>> list(extract_hist_ranges("~8/5-~7/4 2"))
827 >>> list(extract_hist_ranges("~8/5-~7/4 2"))
813 [(-8, 5, None), (-7, 1, 5), (0, 2, 3)]
828 [(-8, 5, None), (-7, 1, 5), (0, 2, 3)]
814 """
829 """
815 for range_str in ranges_str.split():
830 for range_str in ranges_str.split():
816 rmatch = range_re.match(range_str)
831 rmatch = range_re.match(range_str)
817 if not rmatch:
832 if not rmatch:
818 continue
833 continue
819 start = rmatch.group("start")
834 start = rmatch.group("start")
820 if start:
835 if start:
821 start = int(start)
836 start = int(start)
822 end = rmatch.group("end")
837 end = rmatch.group("end")
823 # If no end specified, get (a, a + 1)
838 # If no end specified, get (a, a + 1)
824 end = int(end) if end else start + 1
839 end = int(end) if end else start + 1
825 else: # start not specified
840 else: # start not specified
826 if not rmatch.group('startsess'): # no startsess
841 if not rmatch.group('startsess'): # no startsess
827 continue
842 continue
828 start = 1
843 start = 1
829 end = None # provide the entire session hist
844 end = None # provide the entire session hist
830
845
831 if rmatch.group("sep") == "-": # 1-3 == 1:4 --> [1, 2, 3]
846 if rmatch.group("sep") == "-": # 1-3 == 1:4 --> [1, 2, 3]
832 end += 1
847 end += 1
833 startsess = rmatch.group("startsess") or "0"
848 startsess = rmatch.group("startsess") or "0"
834 endsess = rmatch.group("endsess") or startsess
849 endsess = rmatch.group("endsess") or startsess
835 startsess = int(startsess.replace("~","-"))
850 startsess = int(startsess.replace("~","-"))
836 endsess = int(endsess.replace("~","-"))
851 endsess = int(endsess.replace("~","-"))
837 assert endsess >= startsess, "start session must be earlier than end session"
852 assert endsess >= startsess, "start session must be earlier than end session"
838
853
839 if endsess == startsess:
854 if endsess == startsess:
840 yield (startsess, start, end)
855 yield (startsess, start, end)
841 continue
856 continue
842 # Multiple sessions in one range:
857 # Multiple sessions in one range:
843 yield (startsess, start, None)
858 yield (startsess, start, None)
844 for sess in range(startsess+1, endsess):
859 for sess in range(startsess+1, endsess):
845 yield (sess, 1, None)
860 yield (sess, 1, None)
846 yield (endsess, 1, end)
861 yield (endsess, 1, end)
847
862
848
863
849 def _format_lineno(session, line):
864 def _format_lineno(session, line):
850 """Helper function to format line numbers properly."""
865 """Helper function to format line numbers properly."""
851 if session == 0:
866 if session == 0:
852 return str(line)
867 return str(line)
853 return "%s#%s" % (session, line)
868 return "%s#%s" % (session, line)
854
869
855
870
@@ -1,3318 +1,3318 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """Main IPython class."""
2 """Main IPython class."""
3
3
4 #-----------------------------------------------------------------------------
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 # Copyright (C) 2008-2011 The IPython Development Team
7 # Copyright (C) 2008-2011 The IPython Development Team
8 #
8 #
9 # Distributed under the terms of the BSD License. The full license is in
9 # Distributed under the terms of the BSD License. The full license is in
10 # the file COPYING, distributed as part of this software.
10 # the file COPYING, distributed as part of this software.
11 #-----------------------------------------------------------------------------
11 #-----------------------------------------------------------------------------
12
12
13 from __future__ import absolute_import, print_function
13 from __future__ import absolute_import, print_function
14
14
15 import __future__
15 import __future__
16 import abc
16 import abc
17 import ast
17 import ast
18 import atexit
18 import atexit
19 import functools
19 import functools
20 import os
20 import os
21 import re
21 import re
22 import runpy
22 import runpy
23 import sys
23 import sys
24 import tempfile
24 import tempfile
25 import types
25 import types
26 import subprocess
26 import subprocess
27 from io import open as io_open
27 from io import open as io_open
28
28
29 from IPython.config.configurable import SingletonConfigurable
29 from IPython.config.configurable import SingletonConfigurable
30 from IPython.core import debugger, oinspect
30 from IPython.core import debugger, oinspect
31 from IPython.core import magic
31 from IPython.core import magic
32 from IPython.core import page
32 from IPython.core import page
33 from IPython.core import prefilter
33 from IPython.core import prefilter
34 from IPython.core import shadowns
34 from IPython.core import shadowns
35 from IPython.core import ultratb
35 from IPython.core import ultratb
36 from IPython.core.alias import AliasManager, AliasError
36 from IPython.core.alias import AliasManager, AliasError
37 from IPython.core.autocall import ExitAutocall
37 from IPython.core.autocall import ExitAutocall
38 from IPython.core.builtin_trap import BuiltinTrap
38 from IPython.core.builtin_trap import BuiltinTrap
39 from IPython.core.events import EventManager, available_events
39 from IPython.core.events import EventManager, available_events
40 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
40 from IPython.core.compilerop import CachingCompiler, check_linecache_ipython
41 from IPython.core.display_trap import DisplayTrap
41 from IPython.core.display_trap import DisplayTrap
42 from IPython.core.displayhook import DisplayHook
42 from IPython.core.displayhook import DisplayHook
43 from IPython.core.displaypub import DisplayPublisher
43 from IPython.core.displaypub import DisplayPublisher
44 from IPython.core.error import InputRejected, UsageError
44 from IPython.core.error import InputRejected, UsageError
45 from IPython.core.extensions import ExtensionManager
45 from IPython.core.extensions import ExtensionManager
46 from IPython.core.formatters import DisplayFormatter
46 from IPython.core.formatters import DisplayFormatter
47 from IPython.core.history import HistoryManager
47 from IPython.core.history import HistoryManager
48 from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC, ESC_MAGIC2
48 from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC, ESC_MAGIC2
49 from IPython.core.logger import Logger
49 from IPython.core.logger import Logger
50 from IPython.core.macro import Macro
50 from IPython.core.macro import Macro
51 from IPython.core.payload import PayloadManager
51 from IPython.core.payload import PayloadManager
52 from IPython.core.prefilter import PrefilterManager
52 from IPython.core.prefilter import PrefilterManager
53 from IPython.core.profiledir import ProfileDir
53 from IPython.core.profiledir import ProfileDir
54 from IPython.core.prompts import PromptManager
54 from IPython.core.prompts import PromptManager
55 from IPython.core.usage import default_banner
55 from IPython.core.usage import default_banner
56 from IPython.lib.latextools import LaTeXTool
56 from IPython.lib.latextools import LaTeXTool
57 from IPython.testing.skipdoctest import skip_doctest
57 from IPython.testing.skipdoctest import skip_doctest
58 from IPython.utils import PyColorize
58 from IPython.utils import PyColorize
59 from IPython.utils import io
59 from IPython.utils import io
60 from IPython.utils import py3compat
60 from IPython.utils import py3compat
61 from IPython.utils import openpy
61 from IPython.utils import openpy
62 from IPython.utils.decorators import undoc
62 from IPython.utils.decorators import undoc
63 from IPython.utils.io import ask_yes_no
63 from IPython.utils.io import ask_yes_no
64 from IPython.utils.ipstruct import Struct
64 from IPython.utils.ipstruct import Struct
65 from IPython.utils.path import get_home_dir, get_ipython_dir, get_py_filename, unquote_filename, ensure_dir_exists
65 from IPython.utils.path import get_home_dir, get_ipython_dir, get_py_filename, unquote_filename, ensure_dir_exists
66 from IPython.utils.pickleshare import PickleShareDB
66 from IPython.utils.pickleshare import PickleShareDB
67 from IPython.utils.process import system, getoutput
67 from IPython.utils.process import system, getoutput
68 from IPython.utils.py3compat import (builtin_mod, unicode_type, string_types,
68 from IPython.utils.py3compat import (builtin_mod, unicode_type, string_types,
69 with_metaclass, iteritems)
69 with_metaclass, iteritems)
70 from IPython.utils.strdispatch import StrDispatch
70 from IPython.utils.strdispatch import StrDispatch
71 from IPython.utils.syspathcontext import prepended_to_syspath
71 from IPython.utils.syspathcontext import prepended_to_syspath
72 from IPython.utils.text import (format_screen, LSString, SList,
72 from IPython.utils.text import (format_screen, LSString, SList,
73 DollarFormatter)
73 DollarFormatter)
74 from IPython.utils.traitlets import (Integer, CBool, CaselessStrEnum, Enum,
74 from IPython.utils.traitlets import (Integer, CBool, CaselessStrEnum, Enum,
75 List, Unicode, Instance, Type)
75 List, Unicode, Instance, Type)
76 from IPython.utils.warn import warn, error
76 from IPython.utils.warn import warn, error
77 import IPython.core.hooks
77 import IPython.core.hooks
78
78
79 #-----------------------------------------------------------------------------
79 #-----------------------------------------------------------------------------
80 # Globals
80 # Globals
81 #-----------------------------------------------------------------------------
81 #-----------------------------------------------------------------------------
82
82
83 # compiled regexps for autoindent management
83 # compiled regexps for autoindent management
84 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
84 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
85
85
86 #-----------------------------------------------------------------------------
86 #-----------------------------------------------------------------------------
87 # Utilities
87 # Utilities
88 #-----------------------------------------------------------------------------
88 #-----------------------------------------------------------------------------
89
89
90 @undoc
90 @undoc
91 def softspace(file, newvalue):
91 def softspace(file, newvalue):
92 """Copied from code.py, to remove the dependency"""
92 """Copied from code.py, to remove the dependency"""
93
93
94 oldvalue = 0
94 oldvalue = 0
95 try:
95 try:
96 oldvalue = file.softspace
96 oldvalue = file.softspace
97 except AttributeError:
97 except AttributeError:
98 pass
98 pass
99 try:
99 try:
100 file.softspace = newvalue
100 file.softspace = newvalue
101 except (AttributeError, TypeError):
101 except (AttributeError, TypeError):
102 # "attribute-less object" or "read-only attributes"
102 # "attribute-less object" or "read-only attributes"
103 pass
103 pass
104 return oldvalue
104 return oldvalue
105
105
106 @undoc
106 @undoc
107 def no_op(*a, **kw): pass
107 def no_op(*a, **kw): pass
108
108
109 @undoc
109 @undoc
110 class NoOpContext(object):
110 class NoOpContext(object):
111 def __enter__(self): pass
111 def __enter__(self): pass
112 def __exit__(self, type, value, traceback): pass
112 def __exit__(self, type, value, traceback): pass
113 no_op_context = NoOpContext()
113 no_op_context = NoOpContext()
114
114
115 class SpaceInInput(Exception): pass
115 class SpaceInInput(Exception): pass
116
116
117 @undoc
117 @undoc
118 class Bunch: pass
118 class Bunch: pass
119
119
120
120
121 def get_default_colors():
121 def get_default_colors():
122 if sys.platform=='darwin':
122 if sys.platform=='darwin':
123 return "LightBG"
123 return "LightBG"
124 elif os.name=='nt':
124 elif os.name=='nt':
125 return 'Linux'
125 return 'Linux'
126 else:
126 else:
127 return 'Linux'
127 return 'Linux'
128
128
129
129
130 class SeparateUnicode(Unicode):
130 class SeparateUnicode(Unicode):
131 r"""A Unicode subclass to validate separate_in, separate_out, etc.
131 r"""A Unicode subclass to validate separate_in, separate_out, etc.
132
132
133 This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
133 This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
134 """
134 """
135
135
136 def validate(self, obj, value):
136 def validate(self, obj, value):
137 if value == '0': value = ''
137 if value == '0': value = ''
138 value = value.replace('\\n','\n')
138 value = value.replace('\\n','\n')
139 return super(SeparateUnicode, self).validate(obj, value)
139 return super(SeparateUnicode, self).validate(obj, value)
140
140
141
141
142 class ReadlineNoRecord(object):
142 class ReadlineNoRecord(object):
143 """Context manager to execute some code, then reload readline history
143 """Context manager to execute some code, then reload readline history
144 so that interactive input to the code doesn't appear when pressing up."""
144 so that interactive input to the code doesn't appear when pressing up."""
145 def __init__(self, shell):
145 def __init__(self, shell):
146 self.shell = shell
146 self.shell = shell
147 self._nested_level = 0
147 self._nested_level = 0
148
148
149 def __enter__(self):
149 def __enter__(self):
150 if self._nested_level == 0:
150 if self._nested_level == 0:
151 try:
151 try:
152 self.orig_length = self.current_length()
152 self.orig_length = self.current_length()
153 self.readline_tail = self.get_readline_tail()
153 self.readline_tail = self.get_readline_tail()
154 except (AttributeError, IndexError): # Can fail with pyreadline
154 except (AttributeError, IndexError): # Can fail with pyreadline
155 self.orig_length, self.readline_tail = 999999, []
155 self.orig_length, self.readline_tail = 999999, []
156 self._nested_level += 1
156 self._nested_level += 1
157
157
158 def __exit__(self, type, value, traceback):
158 def __exit__(self, type, value, traceback):
159 self._nested_level -= 1
159 self._nested_level -= 1
160 if self._nested_level == 0:
160 if self._nested_level == 0:
161 # Try clipping the end if it's got longer
161 # Try clipping the end if it's got longer
162 try:
162 try:
163 e = self.current_length() - self.orig_length
163 e = self.current_length() - self.orig_length
164 if e > 0:
164 if e > 0:
165 for _ in range(e):
165 for _ in range(e):
166 self.shell.readline.remove_history_item(self.orig_length)
166 self.shell.readline.remove_history_item(self.orig_length)
167
167
168 # If it still doesn't match, just reload readline history.
168 # If it still doesn't match, just reload readline history.
169 if self.current_length() != self.orig_length \
169 if self.current_length() != self.orig_length \
170 or self.get_readline_tail() != self.readline_tail:
170 or self.get_readline_tail() != self.readline_tail:
171 self.shell.refill_readline_hist()
171 self.shell.refill_readline_hist()
172 except (AttributeError, IndexError):
172 except (AttributeError, IndexError):
173 pass
173 pass
174 # Returning False will cause exceptions to propagate
174 # Returning False will cause exceptions to propagate
175 return False
175 return False
176
176
177 def current_length(self):
177 def current_length(self):
178 return self.shell.readline.get_current_history_length()
178 return self.shell.readline.get_current_history_length()
179
179
180 def get_readline_tail(self, n=10):
180 def get_readline_tail(self, n=10):
181 """Get the last n items in readline history."""
181 """Get the last n items in readline history."""
182 end = self.shell.readline.get_current_history_length() + 1
182 end = self.shell.readline.get_current_history_length() + 1
183 start = max(end-n, 1)
183 start = max(end-n, 1)
184 ghi = self.shell.readline.get_history_item
184 ghi = self.shell.readline.get_history_item
185 return [ghi(x) for x in range(start, end)]
185 return [ghi(x) for x in range(start, end)]
186
186
187
187
188 @undoc
188 @undoc
189 class DummyMod(object):
189 class DummyMod(object):
190 """A dummy module used for IPython's interactive module when
190 """A dummy module used for IPython's interactive module when
191 a namespace must be assigned to the module's __dict__."""
191 a namespace must be assigned to the module's __dict__."""
192 pass
192 pass
193
193
194 #-----------------------------------------------------------------------------
194 #-----------------------------------------------------------------------------
195 # Main IPython class
195 # Main IPython class
196 #-----------------------------------------------------------------------------
196 #-----------------------------------------------------------------------------
197
197
198 class InteractiveShell(SingletonConfigurable):
198 class InteractiveShell(SingletonConfigurable):
199 """An enhanced, interactive shell for Python."""
199 """An enhanced, interactive shell for Python."""
200
200
201 _instance = None
201 _instance = None
202
202
203 ast_transformers = List([], config=True, help=
203 ast_transformers = List([], config=True, help=
204 """
204 """
205 A list of ast.NodeTransformer subclass instances, which will be applied
205 A list of ast.NodeTransformer subclass instances, which will be applied
206 to user input before code is run.
206 to user input before code is run.
207 """
207 """
208 )
208 )
209
209
210 autocall = Enum((0,1,2), default_value=0, config=True, help=
210 autocall = Enum((0,1,2), default_value=0, config=True, help=
211 """
211 """
212 Make IPython automatically call any callable object even if you didn't
212 Make IPython automatically call any callable object even if you didn't
213 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
213 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
214 automatically. The value can be '0' to disable the feature, '1' for
214 automatically. The value can be '0' to disable the feature, '1' for
215 'smart' autocall, where it is not applied if there are no more
215 'smart' autocall, where it is not applied if there are no more
216 arguments on the line, and '2' for 'full' autocall, where all callable
216 arguments on the line, and '2' for 'full' autocall, where all callable
217 objects are automatically called (even if no arguments are present).
217 objects are automatically called (even if no arguments are present).
218 """
218 """
219 )
219 )
220 # TODO: remove all autoindent logic and put into frontends.
220 # TODO: remove all autoindent logic and put into frontends.
221 # We can't do this yet because even runlines uses the autoindent.
221 # We can't do this yet because even runlines uses the autoindent.
222 autoindent = CBool(True, config=True, help=
222 autoindent = CBool(True, config=True, help=
223 """
223 """
224 Autoindent IPython code entered interactively.
224 Autoindent IPython code entered interactively.
225 """
225 """
226 )
226 )
227 automagic = CBool(True, config=True, help=
227 automagic = CBool(True, config=True, help=
228 """
228 """
229 Enable magic commands to be called without the leading %.
229 Enable magic commands to be called without the leading %.
230 """
230 """
231 )
231 )
232
232
233 banner = Unicode('')
233 banner = Unicode('')
234
234
235 banner1 = Unicode(default_banner, config=True,
235 banner1 = Unicode(default_banner, config=True,
236 help="""The part of the banner to be printed before the profile"""
236 help="""The part of the banner to be printed before the profile"""
237 )
237 )
238 banner2 = Unicode('', config=True,
238 banner2 = Unicode('', config=True,
239 help="""The part of the banner to be printed after the profile"""
239 help="""The part of the banner to be printed after the profile"""
240 )
240 )
241
241
242 cache_size = Integer(1000, config=True, help=
242 cache_size = Integer(1000, config=True, help=
243 """
243 """
244 Set the size of the output cache. The default is 1000, you can
244 Set the size of the output cache. The default is 1000, you can
245 change it permanently in your config file. Setting it to 0 completely
245 change it permanently in your config file. Setting it to 0 completely
246 disables the caching system, and the minimum value accepted is 20 (if
246 disables the caching system, and the minimum value accepted is 20 (if
247 you provide a value less than 20, it is reset to 0 and a warning is
247 you provide a value less than 20, it is reset to 0 and a warning is
248 issued). This limit is defined because otherwise you'll spend more
248 issued). This limit is defined because otherwise you'll spend more
249 time re-flushing a too small cache than working
249 time re-flushing a too small cache than working
250 """
250 """
251 )
251 )
252 color_info = CBool(True, config=True, help=
252 color_info = CBool(True, config=True, help=
253 """
253 """
254 Use colors for displaying information about objects. Because this
254 Use colors for displaying information about objects. Because this
255 information is passed through a pager (like 'less'), and some pagers
255 information is passed through a pager (like 'less'), and some pagers
256 get confused with color codes, this capability can be turned off.
256 get confused with color codes, this capability can be turned off.
257 """
257 """
258 )
258 )
259 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
259 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
260 default_value=get_default_colors(), config=True,
260 default_value=get_default_colors(), config=True,
261 help="Set the color scheme (NoColor, Linux, or LightBG)."
261 help="Set the color scheme (NoColor, Linux, or LightBG)."
262 )
262 )
263 colors_force = CBool(False, help=
263 colors_force = CBool(False, help=
264 """
264 """
265 Force use of ANSI color codes, regardless of OS and readline
265 Force use of ANSI color codes, regardless of OS and readline
266 availability.
266 availability.
267 """
267 """
268 # FIXME: This is essentially a hack to allow ZMQShell to show colors
268 # FIXME: This is essentially a hack to allow ZMQShell to show colors
269 # without readline on Win32. When the ZMQ formatting system is
269 # without readline on Win32. When the ZMQ formatting system is
270 # refactored, this should be removed.
270 # refactored, this should be removed.
271 )
271 )
272 debug = CBool(False, config=True)
272 debug = CBool(False, config=True)
273 deep_reload = CBool(False, config=True, help=
273 deep_reload = CBool(False, config=True, help=
274 """
274 """
275 Enable deep (recursive) reloading by default. IPython can use the
275 Enable deep (recursive) reloading by default. IPython can use the
276 deep_reload module which reloads changes in modules recursively (it
276 deep_reload module which reloads changes in modules recursively (it
277 replaces the reload() function, so you don't need to change anything to
277 replaces the reload() function, so you don't need to change anything to
278 use it). deep_reload() forces a full reload of modules whose code may
278 use it). deep_reload() forces a full reload of modules whose code may
279 have changed, which the default reload() function does not. When
279 have changed, which the default reload() function does not. When
280 deep_reload is off, IPython will use the normal reload(), but
280 deep_reload is off, IPython will use the normal reload(), but
281 deep_reload will still be available as dreload().
281 deep_reload will still be available as dreload().
282 """
282 """
283 )
283 )
284 disable_failing_post_execute = CBool(False, config=True,
284 disable_failing_post_execute = CBool(False, config=True,
285 help="Don't call post-execute functions that have failed in the past."
285 help="Don't call post-execute functions that have failed in the past."
286 )
286 )
287 display_formatter = Instance(DisplayFormatter)
287 display_formatter = Instance(DisplayFormatter)
288 displayhook_class = Type(DisplayHook)
288 displayhook_class = Type(DisplayHook)
289 display_pub_class = Type(DisplayPublisher)
289 display_pub_class = Type(DisplayPublisher)
290 data_pub_class = None
290 data_pub_class = None
291
291
292 exit_now = CBool(False)
292 exit_now = CBool(False)
293 exiter = Instance(ExitAutocall)
293 exiter = Instance(ExitAutocall)
294 def _exiter_default(self):
294 def _exiter_default(self):
295 return ExitAutocall(self)
295 return ExitAutocall(self)
296 # Monotonically increasing execution counter
296 # Monotonically increasing execution counter
297 execution_count = Integer(1)
297 execution_count = Integer(1)
298 filename = Unicode("<ipython console>")
298 filename = Unicode("<ipython console>")
299 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
299 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
300
300
301 # Input splitter, to transform input line by line and detect when a block
301 # Input splitter, to transform input line by line and detect when a block
302 # is ready to be executed.
302 # is ready to be executed.
303 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
303 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
304 (), {'line_input_checker': True})
304 (), {'line_input_checker': True})
305
305
306 # This InputSplitter instance is used to transform completed cells before
306 # This InputSplitter instance is used to transform completed cells before
307 # running them. It allows cell magics to contain blank lines.
307 # running them. It allows cell magics to contain blank lines.
308 input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
308 input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
309 (), {'line_input_checker': False})
309 (), {'line_input_checker': False})
310
310
311 logstart = CBool(False, config=True, help=
311 logstart = CBool(False, config=True, help=
312 """
312 """
313 Start logging to the default log file.
313 Start logging to the default log file.
314 """
314 """
315 )
315 )
316 logfile = Unicode('', config=True, help=
316 logfile = Unicode('', config=True, help=
317 """
317 """
318 The name of the logfile to use.
318 The name of the logfile to use.
319 """
319 """
320 )
320 )
321 logappend = Unicode('', config=True, help=
321 logappend = Unicode('', config=True, help=
322 """
322 """
323 Start logging to the given file in append mode.
323 Start logging to the given file in append mode.
324 """
324 """
325 )
325 )
326 object_info_string_level = Enum((0,1,2), default_value=0,
326 object_info_string_level = Enum((0,1,2), default_value=0,
327 config=True)
327 config=True)
328 pdb = CBool(False, config=True, help=
328 pdb = CBool(False, config=True, help=
329 """
329 """
330 Automatically call the pdb debugger after every exception.
330 Automatically call the pdb debugger after every exception.
331 """
331 """
332 )
332 )
333 multiline_history = CBool(sys.platform != 'win32', config=True,
333 multiline_history = CBool(sys.platform != 'win32', config=True,
334 help="Save multi-line entries as one entry in readline history"
334 help="Save multi-line entries as one entry in readline history"
335 )
335 )
336
336
337 # deprecated prompt traits:
337 # deprecated prompt traits:
338
338
339 prompt_in1 = Unicode('In [\\#]: ', config=True,
339 prompt_in1 = Unicode('In [\\#]: ', config=True,
340 help="Deprecated, use PromptManager.in_template")
340 help="Deprecated, use PromptManager.in_template")
341 prompt_in2 = Unicode(' .\\D.: ', config=True,
341 prompt_in2 = Unicode(' .\\D.: ', config=True,
342 help="Deprecated, use PromptManager.in2_template")
342 help="Deprecated, use PromptManager.in2_template")
343 prompt_out = Unicode('Out[\\#]: ', config=True,
343 prompt_out = Unicode('Out[\\#]: ', config=True,
344 help="Deprecated, use PromptManager.out_template")
344 help="Deprecated, use PromptManager.out_template")
345 prompts_pad_left = CBool(True, config=True,
345 prompts_pad_left = CBool(True, config=True,
346 help="Deprecated, use PromptManager.justify")
346 help="Deprecated, use PromptManager.justify")
347
347
348 def _prompt_trait_changed(self, name, old, new):
348 def _prompt_trait_changed(self, name, old, new):
349 table = {
349 table = {
350 'prompt_in1' : 'in_template',
350 'prompt_in1' : 'in_template',
351 'prompt_in2' : 'in2_template',
351 'prompt_in2' : 'in2_template',
352 'prompt_out' : 'out_template',
352 'prompt_out' : 'out_template',
353 'prompts_pad_left' : 'justify',
353 'prompts_pad_left' : 'justify',
354 }
354 }
355 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(
355 warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(
356 name=name, newname=table[name])
356 name=name, newname=table[name])
357 )
357 )
358 # protect against weird cases where self.config may not exist:
358 # protect against weird cases where self.config may not exist:
359 if self.config is not None:
359 if self.config is not None:
360 # propagate to corresponding PromptManager trait
360 # propagate to corresponding PromptManager trait
361 setattr(self.config.PromptManager, table[name], new)
361 setattr(self.config.PromptManager, table[name], new)
362
362
363 _prompt_in1_changed = _prompt_trait_changed
363 _prompt_in1_changed = _prompt_trait_changed
364 _prompt_in2_changed = _prompt_trait_changed
364 _prompt_in2_changed = _prompt_trait_changed
365 _prompt_out_changed = _prompt_trait_changed
365 _prompt_out_changed = _prompt_trait_changed
366 _prompt_pad_left_changed = _prompt_trait_changed
366 _prompt_pad_left_changed = _prompt_trait_changed
367
367
368 show_rewritten_input = CBool(True, config=True,
368 show_rewritten_input = CBool(True, config=True,
369 help="Show rewritten input, e.g. for autocall."
369 help="Show rewritten input, e.g. for autocall."
370 )
370 )
371
371
372 quiet = CBool(False, config=True)
372 quiet = CBool(False, config=True)
373
373
374 history_length = Integer(10000, config=True)
374 history_length = Integer(10000, config=True)
375
375
376 # The readline stuff will eventually be moved to the terminal subclass
376 # The readline stuff will eventually be moved to the terminal subclass
377 # but for now, we can't do that as readline is welded in everywhere.
377 # but for now, we can't do that as readline is welded in everywhere.
378 readline_use = CBool(True, config=True)
378 readline_use = CBool(True, config=True)
379 readline_remove_delims = Unicode('-/~', config=True)
379 readline_remove_delims = Unicode('-/~', config=True)
380 readline_delims = Unicode() # set by init_readline()
380 readline_delims = Unicode() # set by init_readline()
381 # don't use \M- bindings by default, because they
381 # don't use \M- bindings by default, because they
382 # conflict with 8-bit encodings. See gh-58,gh-88
382 # conflict with 8-bit encodings. See gh-58,gh-88
383 readline_parse_and_bind = List([
383 readline_parse_and_bind = List([
384 'tab: complete',
384 'tab: complete',
385 '"\C-l": clear-screen',
385 '"\C-l": clear-screen',
386 'set show-all-if-ambiguous on',
386 'set show-all-if-ambiguous on',
387 '"\C-o": tab-insert',
387 '"\C-o": tab-insert',
388 '"\C-r": reverse-search-history',
388 '"\C-r": reverse-search-history',
389 '"\C-s": forward-search-history',
389 '"\C-s": forward-search-history',
390 '"\C-p": history-search-backward',
390 '"\C-p": history-search-backward',
391 '"\C-n": history-search-forward',
391 '"\C-n": history-search-forward',
392 '"\e[A": history-search-backward',
392 '"\e[A": history-search-backward',
393 '"\e[B": history-search-forward',
393 '"\e[B": history-search-forward',
394 '"\C-k": kill-line',
394 '"\C-k": kill-line',
395 '"\C-u": unix-line-discard',
395 '"\C-u": unix-line-discard',
396 ], config=True)
396 ], config=True)
397
397
398 _custom_readline_config = False
398 _custom_readline_config = False
399
399
400 def _readline_parse_and_bind_changed(self, name, old, new):
400 def _readline_parse_and_bind_changed(self, name, old, new):
401 # notice that readline config is customized
401 # notice that readline config is customized
402 # indicates that it should have higher priority than inputrc
402 # indicates that it should have higher priority than inputrc
403 self._custom_readline_config = True
403 self._custom_readline_config = True
404
404
405 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
405 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
406 default_value='last_expr', config=True,
406 default_value='last_expr', config=True,
407 help="""
407 help="""
408 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
408 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
409 run interactively (displaying output from expressions).""")
409 run interactively (displaying output from expressions).""")
410
410
411 # TODO: this part of prompt management should be moved to the frontends.
411 # TODO: this part of prompt management should be moved to the frontends.
412 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
412 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
413 separate_in = SeparateUnicode('\n', config=True)
413 separate_in = SeparateUnicode('\n', config=True)
414 separate_out = SeparateUnicode('', config=True)
414 separate_out = SeparateUnicode('', config=True)
415 separate_out2 = SeparateUnicode('', config=True)
415 separate_out2 = SeparateUnicode('', config=True)
416 wildcards_case_sensitive = CBool(True, config=True)
416 wildcards_case_sensitive = CBool(True, config=True)
417 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
417 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
418 default_value='Context', config=True)
418 default_value='Context', config=True)
419
419
420 # Subcomponents of InteractiveShell
420 # Subcomponents of InteractiveShell
421 alias_manager = Instance('IPython.core.alias.AliasManager')
421 alias_manager = Instance('IPython.core.alias.AliasManager')
422 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
422 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
423 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
423 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
424 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
424 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
425 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
425 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
426 payload_manager = Instance('IPython.core.payload.PayloadManager')
426 payload_manager = Instance('IPython.core.payload.PayloadManager')
427 history_manager = Instance('IPython.core.history.HistoryManager')
427 history_manager = Instance('IPython.core.history.HistoryAccessorBase')
428 magics_manager = Instance('IPython.core.magic.MagicsManager')
428 magics_manager = Instance('IPython.core.magic.MagicsManager')
429
429
430 profile_dir = Instance('IPython.core.application.ProfileDir')
430 profile_dir = Instance('IPython.core.application.ProfileDir')
431 @property
431 @property
432 def profile(self):
432 def profile(self):
433 if self.profile_dir is not None:
433 if self.profile_dir is not None:
434 name = os.path.basename(self.profile_dir.location)
434 name = os.path.basename(self.profile_dir.location)
435 return name.replace('profile_','')
435 return name.replace('profile_','')
436
436
437
437
438 # Private interface
438 # Private interface
439 _post_execute = Instance(dict)
439 _post_execute = Instance(dict)
440
440
441 # Tracks any GUI loop loaded for pylab
441 # Tracks any GUI loop loaded for pylab
442 pylab_gui_select = None
442 pylab_gui_select = None
443
443
444 def __init__(self, ipython_dir=None, profile_dir=None,
444 def __init__(self, ipython_dir=None, profile_dir=None,
445 user_module=None, user_ns=None,
445 user_module=None, user_ns=None,
446 custom_exceptions=((), None), **kwargs):
446 custom_exceptions=((), None), **kwargs):
447
447
448 # This is where traits with a config_key argument are updated
448 # This is where traits with a config_key argument are updated
449 # from the values on config.
449 # from the values on config.
450 super(InteractiveShell, self).__init__(**kwargs)
450 super(InteractiveShell, self).__init__(**kwargs)
451 self.configurables = [self]
451 self.configurables = [self]
452
452
453 # These are relatively independent and stateless
453 # These are relatively independent and stateless
454 self.init_ipython_dir(ipython_dir)
454 self.init_ipython_dir(ipython_dir)
455 self.init_profile_dir(profile_dir)
455 self.init_profile_dir(profile_dir)
456 self.init_instance_attrs()
456 self.init_instance_attrs()
457 self.init_environment()
457 self.init_environment()
458
458
459 # Check if we're in a virtualenv, and set up sys.path.
459 # Check if we're in a virtualenv, and set up sys.path.
460 self.init_virtualenv()
460 self.init_virtualenv()
461
461
462 # Create namespaces (user_ns, user_global_ns, etc.)
462 # Create namespaces (user_ns, user_global_ns, etc.)
463 self.init_create_namespaces(user_module, user_ns)
463 self.init_create_namespaces(user_module, user_ns)
464 # This has to be done after init_create_namespaces because it uses
464 # This has to be done after init_create_namespaces because it uses
465 # something in self.user_ns, but before init_sys_modules, which
465 # something in self.user_ns, but before init_sys_modules, which
466 # is the first thing to modify sys.
466 # is the first thing to modify sys.
467 # TODO: When we override sys.stdout and sys.stderr before this class
467 # TODO: When we override sys.stdout and sys.stderr before this class
468 # is created, we are saving the overridden ones here. Not sure if this
468 # is created, we are saving the overridden ones here. Not sure if this
469 # is what we want to do.
469 # is what we want to do.
470 self.save_sys_module_state()
470 self.save_sys_module_state()
471 self.init_sys_modules()
471 self.init_sys_modules()
472
472
473 # While we're trying to have each part of the code directly access what
473 # While we're trying to have each part of the code directly access what
474 # it needs without keeping redundant references to objects, we have too
474 # it needs without keeping redundant references to objects, we have too
475 # much legacy code that expects ip.db to exist.
475 # much legacy code that expects ip.db to exist.
476 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
476 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
477
477
478 self.init_history()
478 self.init_history()
479 self.init_encoding()
479 self.init_encoding()
480 self.init_prefilter()
480 self.init_prefilter()
481
481
482 self.init_syntax_highlighting()
482 self.init_syntax_highlighting()
483 self.init_hooks()
483 self.init_hooks()
484 self.init_events()
484 self.init_events()
485 self.init_pushd_popd_magic()
485 self.init_pushd_popd_magic()
486 # self.init_traceback_handlers use to be here, but we moved it below
486 # self.init_traceback_handlers use to be here, but we moved it below
487 # because it and init_io have to come after init_readline.
487 # because it and init_io have to come after init_readline.
488 self.init_user_ns()
488 self.init_user_ns()
489 self.init_logger()
489 self.init_logger()
490 self.init_builtins()
490 self.init_builtins()
491
491
492 # The following was in post_config_initialization
492 # The following was in post_config_initialization
493 self.init_inspector()
493 self.init_inspector()
494 # init_readline() must come before init_io(), because init_io uses
494 # init_readline() must come before init_io(), because init_io uses
495 # readline related things.
495 # readline related things.
496 self.init_readline()
496 self.init_readline()
497 # We save this here in case user code replaces raw_input, but it needs
497 # We save this here in case user code replaces raw_input, but it needs
498 # to be after init_readline(), because PyPy's readline works by replacing
498 # to be after init_readline(), because PyPy's readline works by replacing
499 # raw_input.
499 # raw_input.
500 if py3compat.PY3:
500 if py3compat.PY3:
501 self.raw_input_original = input
501 self.raw_input_original = input
502 else:
502 else:
503 self.raw_input_original = raw_input
503 self.raw_input_original = raw_input
504 # init_completer must come after init_readline, because it needs to
504 # init_completer must come after init_readline, because it needs to
505 # know whether readline is present or not system-wide to configure the
505 # know whether readline is present or not system-wide to configure the
506 # completers, since the completion machinery can now operate
506 # completers, since the completion machinery can now operate
507 # independently of readline (e.g. over the network)
507 # independently of readline (e.g. over the network)
508 self.init_completer()
508 self.init_completer()
509 # TODO: init_io() needs to happen before init_traceback handlers
509 # TODO: init_io() needs to happen before init_traceback handlers
510 # because the traceback handlers hardcode the stdout/stderr streams.
510 # because the traceback handlers hardcode the stdout/stderr streams.
511 # This logic in in debugger.Pdb and should eventually be changed.
511 # This logic in in debugger.Pdb and should eventually be changed.
512 self.init_io()
512 self.init_io()
513 self.init_traceback_handlers(custom_exceptions)
513 self.init_traceback_handlers(custom_exceptions)
514 self.init_prompts()
514 self.init_prompts()
515 self.init_display_formatter()
515 self.init_display_formatter()
516 self.init_display_pub()
516 self.init_display_pub()
517 self.init_data_pub()
517 self.init_data_pub()
518 self.init_displayhook()
518 self.init_displayhook()
519 self.init_latextool()
519 self.init_latextool()
520 self.init_magics()
520 self.init_magics()
521 self.init_alias()
521 self.init_alias()
522 self.init_logstart()
522 self.init_logstart()
523 self.init_pdb()
523 self.init_pdb()
524 self.init_extension_manager()
524 self.init_extension_manager()
525 self.init_payload()
525 self.init_payload()
526 self.hooks.late_startup_hook()
526 self.hooks.late_startup_hook()
527 self.events.trigger('shell_initialized', self)
527 self.events.trigger('shell_initialized', self)
528 atexit.register(self.atexit_operations)
528 atexit.register(self.atexit_operations)
529
529
530 def get_ipython(self):
530 def get_ipython(self):
531 """Return the currently running IPython instance."""
531 """Return the currently running IPython instance."""
532 return self
532 return self
533
533
534 #-------------------------------------------------------------------------
534 #-------------------------------------------------------------------------
535 # Trait changed handlers
535 # Trait changed handlers
536 #-------------------------------------------------------------------------
536 #-------------------------------------------------------------------------
537
537
538 def _ipython_dir_changed(self, name, new):
538 def _ipython_dir_changed(self, name, new):
539 ensure_dir_exists(new)
539 ensure_dir_exists(new)
540
540
541 def set_autoindent(self,value=None):
541 def set_autoindent(self,value=None):
542 """Set the autoindent flag, checking for readline support.
542 """Set the autoindent flag, checking for readline support.
543
543
544 If called with no arguments, it acts as a toggle."""
544 If called with no arguments, it acts as a toggle."""
545
545
546 if value != 0 and not self.has_readline:
546 if value != 0 and not self.has_readline:
547 if os.name == 'posix':
547 if os.name == 'posix':
548 warn("The auto-indent feature requires the readline library")
548 warn("The auto-indent feature requires the readline library")
549 self.autoindent = 0
549 self.autoindent = 0
550 return
550 return
551 if value is None:
551 if value is None:
552 self.autoindent = not self.autoindent
552 self.autoindent = not self.autoindent
553 else:
553 else:
554 self.autoindent = value
554 self.autoindent = value
555
555
556 #-------------------------------------------------------------------------
556 #-------------------------------------------------------------------------
557 # init_* methods called by __init__
557 # init_* methods called by __init__
558 #-------------------------------------------------------------------------
558 #-------------------------------------------------------------------------
559
559
560 def init_ipython_dir(self, ipython_dir):
560 def init_ipython_dir(self, ipython_dir):
561 if ipython_dir is not None:
561 if ipython_dir is not None:
562 self.ipython_dir = ipython_dir
562 self.ipython_dir = ipython_dir
563 return
563 return
564
564
565 self.ipython_dir = get_ipython_dir()
565 self.ipython_dir = get_ipython_dir()
566
566
567 def init_profile_dir(self, profile_dir):
567 def init_profile_dir(self, profile_dir):
568 if profile_dir is not None:
568 if profile_dir is not None:
569 self.profile_dir = profile_dir
569 self.profile_dir = profile_dir
570 return
570 return
571 self.profile_dir =\
571 self.profile_dir =\
572 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
572 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
573
573
574 def init_instance_attrs(self):
574 def init_instance_attrs(self):
575 self.more = False
575 self.more = False
576
576
577 # command compiler
577 # command compiler
578 self.compile = CachingCompiler()
578 self.compile = CachingCompiler()
579
579
580 # Make an empty namespace, which extension writers can rely on both
580 # Make an empty namespace, which extension writers can rely on both
581 # existing and NEVER being used by ipython itself. This gives them a
581 # existing and NEVER being used by ipython itself. This gives them a
582 # convenient location for storing additional information and state
582 # convenient location for storing additional information and state
583 # their extensions may require, without fear of collisions with other
583 # their extensions may require, without fear of collisions with other
584 # ipython names that may develop later.
584 # ipython names that may develop later.
585 self.meta = Struct()
585 self.meta = Struct()
586
586
587 # Temporary files used for various purposes. Deleted at exit.
587 # Temporary files used for various purposes. Deleted at exit.
588 self.tempfiles = []
588 self.tempfiles = []
589 self.tempdirs = []
589 self.tempdirs = []
590
590
591 # Keep track of readline usage (later set by init_readline)
591 # Keep track of readline usage (later set by init_readline)
592 self.has_readline = False
592 self.has_readline = False
593
593
594 # keep track of where we started running (mainly for crash post-mortem)
594 # keep track of where we started running (mainly for crash post-mortem)
595 # This is not being used anywhere currently.
595 # This is not being used anywhere currently.
596 self.starting_dir = py3compat.getcwd()
596 self.starting_dir = py3compat.getcwd()
597
597
598 # Indentation management
598 # Indentation management
599 self.indent_current_nsp = 0
599 self.indent_current_nsp = 0
600
600
601 # Dict to track post-execution functions that have been registered
601 # Dict to track post-execution functions that have been registered
602 self._post_execute = {}
602 self._post_execute = {}
603
603
604 def init_environment(self):
604 def init_environment(self):
605 """Any changes we need to make to the user's environment."""
605 """Any changes we need to make to the user's environment."""
606 pass
606 pass
607
607
608 def init_encoding(self):
608 def init_encoding(self):
609 # Get system encoding at startup time. Certain terminals (like Emacs
609 # Get system encoding at startup time. Certain terminals (like Emacs
610 # under Win32 have it set to None, and we need to have a known valid
610 # under Win32 have it set to None, and we need to have a known valid
611 # encoding to use in the raw_input() method
611 # encoding to use in the raw_input() method
612 try:
612 try:
613 self.stdin_encoding = sys.stdin.encoding or 'ascii'
613 self.stdin_encoding = sys.stdin.encoding or 'ascii'
614 except AttributeError:
614 except AttributeError:
615 self.stdin_encoding = 'ascii'
615 self.stdin_encoding = 'ascii'
616
616
617 def init_syntax_highlighting(self):
617 def init_syntax_highlighting(self):
618 # Python source parser/formatter for syntax highlighting
618 # Python source parser/formatter for syntax highlighting
619 pyformat = PyColorize.Parser().format
619 pyformat = PyColorize.Parser().format
620 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
620 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
621
621
622 def init_pushd_popd_magic(self):
622 def init_pushd_popd_magic(self):
623 # for pushd/popd management
623 # for pushd/popd management
624 self.home_dir = get_home_dir()
624 self.home_dir = get_home_dir()
625
625
626 self.dir_stack = []
626 self.dir_stack = []
627
627
628 def init_logger(self):
628 def init_logger(self):
629 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
629 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
630 logmode='rotate')
630 logmode='rotate')
631
631
632 def init_logstart(self):
632 def init_logstart(self):
633 """Initialize logging in case it was requested at the command line.
633 """Initialize logging in case it was requested at the command line.
634 """
634 """
635 if self.logappend:
635 if self.logappend:
636 self.magic('logstart %s append' % self.logappend)
636 self.magic('logstart %s append' % self.logappend)
637 elif self.logfile:
637 elif self.logfile:
638 self.magic('logstart %s' % self.logfile)
638 self.magic('logstart %s' % self.logfile)
639 elif self.logstart:
639 elif self.logstart:
640 self.magic('logstart')
640 self.magic('logstart')
641
641
642 def init_builtins(self):
642 def init_builtins(self):
643 # A single, static flag that we set to True. Its presence indicates
643 # A single, static flag that we set to True. Its presence indicates
644 # that an IPython shell has been created, and we make no attempts at
644 # that an IPython shell has been created, and we make no attempts at
645 # removing on exit or representing the existence of more than one
645 # removing on exit or representing the existence of more than one
646 # IPython at a time.
646 # IPython at a time.
647 builtin_mod.__dict__['__IPYTHON__'] = True
647 builtin_mod.__dict__['__IPYTHON__'] = True
648
648
649 # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to
649 # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to
650 # manage on enter/exit, but with all our shells it's virtually
650 # manage on enter/exit, but with all our shells it's virtually
651 # impossible to get all the cases right. We're leaving the name in for
651 # impossible to get all the cases right. We're leaving the name in for
652 # those who adapted their codes to check for this flag, but will
652 # those who adapted their codes to check for this flag, but will
653 # eventually remove it after a few more releases.
653 # eventually remove it after a few more releases.
654 builtin_mod.__dict__['__IPYTHON__active'] = \
654 builtin_mod.__dict__['__IPYTHON__active'] = \
655 'Deprecated, check for __IPYTHON__'
655 'Deprecated, check for __IPYTHON__'
656
656
657 self.builtin_trap = BuiltinTrap(shell=self)
657 self.builtin_trap = BuiltinTrap(shell=self)
658
658
659 def init_inspector(self):
659 def init_inspector(self):
660 # Object inspector
660 # Object inspector
661 self.inspector = oinspect.Inspector(oinspect.InspectColors,
661 self.inspector = oinspect.Inspector(oinspect.InspectColors,
662 PyColorize.ANSICodeColors,
662 PyColorize.ANSICodeColors,
663 'NoColor',
663 'NoColor',
664 self.object_info_string_level)
664 self.object_info_string_level)
665
665
666 def init_io(self):
666 def init_io(self):
667 # This will just use sys.stdout and sys.stderr. If you want to
667 # This will just use sys.stdout and sys.stderr. If you want to
668 # override sys.stdout and sys.stderr themselves, you need to do that
668 # override sys.stdout and sys.stderr themselves, you need to do that
669 # *before* instantiating this class, because io holds onto
669 # *before* instantiating this class, because io holds onto
670 # references to the underlying streams.
670 # references to the underlying streams.
671 if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:
671 if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:
672 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
672 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
673 else:
673 else:
674 io.stdout = io.IOStream(sys.stdout)
674 io.stdout = io.IOStream(sys.stdout)
675 io.stderr = io.IOStream(sys.stderr)
675 io.stderr = io.IOStream(sys.stderr)
676
676
677 def init_prompts(self):
677 def init_prompts(self):
678 self.prompt_manager = PromptManager(shell=self, parent=self)
678 self.prompt_manager = PromptManager(shell=self, parent=self)
679 self.configurables.append(self.prompt_manager)
679 self.configurables.append(self.prompt_manager)
680 # Set system prompts, so that scripts can decide if they are running
680 # Set system prompts, so that scripts can decide if they are running
681 # interactively.
681 # interactively.
682 sys.ps1 = 'In : '
682 sys.ps1 = 'In : '
683 sys.ps2 = '...: '
683 sys.ps2 = '...: '
684 sys.ps3 = 'Out: '
684 sys.ps3 = 'Out: '
685
685
686 def init_display_formatter(self):
686 def init_display_formatter(self):
687 self.display_formatter = DisplayFormatter(parent=self)
687 self.display_formatter = DisplayFormatter(parent=self)
688 self.configurables.append(self.display_formatter)
688 self.configurables.append(self.display_formatter)
689
689
690 def init_display_pub(self):
690 def init_display_pub(self):
691 self.display_pub = self.display_pub_class(parent=self)
691 self.display_pub = self.display_pub_class(parent=self)
692 self.configurables.append(self.display_pub)
692 self.configurables.append(self.display_pub)
693
693
694 def init_data_pub(self):
694 def init_data_pub(self):
695 if not self.data_pub_class:
695 if not self.data_pub_class:
696 self.data_pub = None
696 self.data_pub = None
697 return
697 return
698 self.data_pub = self.data_pub_class(parent=self)
698 self.data_pub = self.data_pub_class(parent=self)
699 self.configurables.append(self.data_pub)
699 self.configurables.append(self.data_pub)
700
700
701 def init_displayhook(self):
701 def init_displayhook(self):
702 # Initialize displayhook, set in/out prompts and printing system
702 # Initialize displayhook, set in/out prompts and printing system
703 self.displayhook = self.displayhook_class(
703 self.displayhook = self.displayhook_class(
704 parent=self,
704 parent=self,
705 shell=self,
705 shell=self,
706 cache_size=self.cache_size,
706 cache_size=self.cache_size,
707 )
707 )
708 self.configurables.append(self.displayhook)
708 self.configurables.append(self.displayhook)
709 # This is a context manager that installs/revmoes the displayhook at
709 # This is a context manager that installs/revmoes the displayhook at
710 # the appropriate time.
710 # the appropriate time.
711 self.display_trap = DisplayTrap(hook=self.displayhook)
711 self.display_trap = DisplayTrap(hook=self.displayhook)
712
712
713 def init_latextool(self):
713 def init_latextool(self):
714 """Configure LaTeXTool."""
714 """Configure LaTeXTool."""
715 cfg = LaTeXTool.instance(parent=self)
715 cfg = LaTeXTool.instance(parent=self)
716 if cfg not in self.configurables:
716 if cfg not in self.configurables:
717 self.configurables.append(cfg)
717 self.configurables.append(cfg)
718
718
719 def init_virtualenv(self):
719 def init_virtualenv(self):
720 """Add a virtualenv to sys.path so the user can import modules from it.
720 """Add a virtualenv to sys.path so the user can import modules from it.
721 This isn't perfect: it doesn't use the Python interpreter with which the
721 This isn't perfect: it doesn't use the Python interpreter with which the
722 virtualenv was built, and it ignores the --no-site-packages option. A
722 virtualenv was built, and it ignores the --no-site-packages option. A
723 warning will appear suggesting the user installs IPython in the
723 warning will appear suggesting the user installs IPython in the
724 virtualenv, but for many cases, it probably works well enough.
724 virtualenv, but for many cases, it probably works well enough.
725
725
726 Adapted from code snippets online.
726 Adapted from code snippets online.
727
727
728 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
728 http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
729 """
729 """
730 if 'VIRTUAL_ENV' not in os.environ:
730 if 'VIRTUAL_ENV' not in os.environ:
731 # Not in a virtualenv
731 # Not in a virtualenv
732 return
732 return
733
733
734 # venv detection:
734 # venv detection:
735 # stdlib venv may symlink sys.executable, so we can't use realpath.
735 # stdlib venv may symlink sys.executable, so we can't use realpath.
736 # but others can symlink *to* the venv Python, so we can't just use sys.executable.
736 # but others can symlink *to* the venv Python, so we can't just use sys.executable.
737 # So we just check every item in the symlink tree (generally <= 3)
737 # So we just check every item in the symlink tree (generally <= 3)
738 p = os.path.normcase(sys.executable)
738 p = os.path.normcase(sys.executable)
739 paths = [p]
739 paths = [p]
740 while os.path.islink(p):
740 while os.path.islink(p):
741 p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))
741 p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))
742 paths.append(p)
742 paths.append(p)
743 p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])
743 p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])
744 if any(p.startswith(p_venv) for p in paths):
744 if any(p.startswith(p_venv) for p in paths):
745 # Running properly in the virtualenv, don't need to do anything
745 # Running properly in the virtualenv, don't need to do anything
746 return
746 return
747
747
748 warn("Attempting to work in a virtualenv. If you encounter problems, please "
748 warn("Attempting to work in a virtualenv. If you encounter problems, please "
749 "install IPython inside the virtualenv.")
749 "install IPython inside the virtualenv.")
750 if sys.platform == "win32":
750 if sys.platform == "win32":
751 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
751 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages')
752 else:
752 else:
753 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
753 virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',
754 'python%d.%d' % sys.version_info[:2], 'site-packages')
754 'python%d.%d' % sys.version_info[:2], 'site-packages')
755
755
756 import site
756 import site
757 sys.path.insert(0, virtual_env)
757 sys.path.insert(0, virtual_env)
758 site.addsitedir(virtual_env)
758 site.addsitedir(virtual_env)
759
759
760 #-------------------------------------------------------------------------
760 #-------------------------------------------------------------------------
761 # Things related to injections into the sys module
761 # Things related to injections into the sys module
762 #-------------------------------------------------------------------------
762 #-------------------------------------------------------------------------
763
763
764 def save_sys_module_state(self):
764 def save_sys_module_state(self):
765 """Save the state of hooks in the sys module.
765 """Save the state of hooks in the sys module.
766
766
767 This has to be called after self.user_module is created.
767 This has to be called after self.user_module is created.
768 """
768 """
769 self._orig_sys_module_state = {}
769 self._orig_sys_module_state = {}
770 self._orig_sys_module_state['stdin'] = sys.stdin
770 self._orig_sys_module_state['stdin'] = sys.stdin
771 self._orig_sys_module_state['stdout'] = sys.stdout
771 self._orig_sys_module_state['stdout'] = sys.stdout
772 self._orig_sys_module_state['stderr'] = sys.stderr
772 self._orig_sys_module_state['stderr'] = sys.stderr
773 self._orig_sys_module_state['excepthook'] = sys.excepthook
773 self._orig_sys_module_state['excepthook'] = sys.excepthook
774 self._orig_sys_modules_main_name = self.user_module.__name__
774 self._orig_sys_modules_main_name = self.user_module.__name__
775 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
775 self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
776
776
777 def restore_sys_module_state(self):
777 def restore_sys_module_state(self):
778 """Restore the state of the sys module."""
778 """Restore the state of the sys module."""
779 try:
779 try:
780 for k, v in iteritems(self._orig_sys_module_state):
780 for k, v in iteritems(self._orig_sys_module_state):
781 setattr(sys, k, v)
781 setattr(sys, k, v)
782 except AttributeError:
782 except AttributeError:
783 pass
783 pass
784 # Reset what what done in self.init_sys_modules
784 # Reset what what done in self.init_sys_modules
785 if self._orig_sys_modules_main_mod is not None:
785 if self._orig_sys_modules_main_mod is not None:
786 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
786 sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
787
787
788 #-------------------------------------------------------------------------
788 #-------------------------------------------------------------------------
789 # Things related to the banner
789 # Things related to the banner
790 #-------------------------------------------------------------------------
790 #-------------------------------------------------------------------------
791
791
792 @property
792 @property
793 def banner(self):
793 def banner(self):
794 banner = self.banner1
794 banner = self.banner1
795 if self.profile and self.profile != 'default':
795 if self.profile and self.profile != 'default':
796 banner += '\nIPython profile: %s\n' % self.profile
796 banner += '\nIPython profile: %s\n' % self.profile
797 if self.banner2:
797 if self.banner2:
798 banner += '\n' + self.banner2
798 banner += '\n' + self.banner2
799 return banner
799 return banner
800
800
801 def show_banner(self, banner=None):
801 def show_banner(self, banner=None):
802 if banner is None:
802 if banner is None:
803 banner = self.banner
803 banner = self.banner
804 self.write(banner)
804 self.write(banner)
805
805
806 #-------------------------------------------------------------------------
806 #-------------------------------------------------------------------------
807 # Things related to hooks
807 # Things related to hooks
808 #-------------------------------------------------------------------------
808 #-------------------------------------------------------------------------
809
809
810 def init_hooks(self):
810 def init_hooks(self):
811 # hooks holds pointers used for user-side customizations
811 # hooks holds pointers used for user-side customizations
812 self.hooks = Struct()
812 self.hooks = Struct()
813
813
814 self.strdispatchers = {}
814 self.strdispatchers = {}
815
815
816 # Set all default hooks, defined in the IPython.hooks module.
816 # Set all default hooks, defined in the IPython.hooks module.
817 hooks = IPython.core.hooks
817 hooks = IPython.core.hooks
818 for hook_name in hooks.__all__:
818 for hook_name in hooks.__all__:
819 # default hooks have priority 100, i.e. low; user hooks should have
819 # default hooks have priority 100, i.e. low; user hooks should have
820 # 0-100 priority
820 # 0-100 priority
821 self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)
821 self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)
822
822
823 def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,
823 def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,
824 _warn_deprecated=True):
824 _warn_deprecated=True):
825 """set_hook(name,hook) -> sets an internal IPython hook.
825 """set_hook(name,hook) -> sets an internal IPython hook.
826
826
827 IPython exposes some of its internal API as user-modifiable hooks. By
827 IPython exposes some of its internal API as user-modifiable hooks. By
828 adding your function to one of these hooks, you can modify IPython's
828 adding your function to one of these hooks, you can modify IPython's
829 behavior to call at runtime your own routines."""
829 behavior to call at runtime your own routines."""
830
830
831 # At some point in the future, this should validate the hook before it
831 # At some point in the future, this should validate the hook before it
832 # accepts it. Probably at least check that the hook takes the number
832 # accepts it. Probably at least check that the hook takes the number
833 # of args it's supposed to.
833 # of args it's supposed to.
834
834
835 f = types.MethodType(hook,self)
835 f = types.MethodType(hook,self)
836
836
837 # check if the hook is for strdispatcher first
837 # check if the hook is for strdispatcher first
838 if str_key is not None:
838 if str_key is not None:
839 sdp = self.strdispatchers.get(name, StrDispatch())
839 sdp = self.strdispatchers.get(name, StrDispatch())
840 sdp.add_s(str_key, f, priority )
840 sdp.add_s(str_key, f, priority )
841 self.strdispatchers[name] = sdp
841 self.strdispatchers[name] = sdp
842 return
842 return
843 if re_key is not None:
843 if re_key is not None:
844 sdp = self.strdispatchers.get(name, StrDispatch())
844 sdp = self.strdispatchers.get(name, StrDispatch())
845 sdp.add_re(re.compile(re_key), f, priority )
845 sdp.add_re(re.compile(re_key), f, priority )
846 self.strdispatchers[name] = sdp
846 self.strdispatchers[name] = sdp
847 return
847 return
848
848
849 dp = getattr(self.hooks, name, None)
849 dp = getattr(self.hooks, name, None)
850 if name not in IPython.core.hooks.__all__:
850 if name not in IPython.core.hooks.__all__:
851 print("Warning! Hook '%s' is not one of %s" % \
851 print("Warning! Hook '%s' is not one of %s" % \
852 (name, IPython.core.hooks.__all__ ))
852 (name, IPython.core.hooks.__all__ ))
853
853
854 if _warn_deprecated and (name in IPython.core.hooks.deprecated):
854 if _warn_deprecated and (name in IPython.core.hooks.deprecated):
855 alternative = IPython.core.hooks.deprecated[name]
855 alternative = IPython.core.hooks.deprecated[name]
856 warn("Hook {} is deprecated. Use {} instead.".format(name, alternative))
856 warn("Hook {} is deprecated. Use {} instead.".format(name, alternative))
857
857
858 if not dp:
858 if not dp:
859 dp = IPython.core.hooks.CommandChainDispatcher()
859 dp = IPython.core.hooks.CommandChainDispatcher()
860
860
861 try:
861 try:
862 dp.add(f,priority)
862 dp.add(f,priority)
863 except AttributeError:
863 except AttributeError:
864 # it was not commandchain, plain old func - replace
864 # it was not commandchain, plain old func - replace
865 dp = f
865 dp = f
866
866
867 setattr(self.hooks,name, dp)
867 setattr(self.hooks,name, dp)
868
868
869 #-------------------------------------------------------------------------
869 #-------------------------------------------------------------------------
870 # Things related to events
870 # Things related to events
871 #-------------------------------------------------------------------------
871 #-------------------------------------------------------------------------
872
872
873 def init_events(self):
873 def init_events(self):
874 self.events = EventManager(self, available_events)
874 self.events = EventManager(self, available_events)
875
875
876 self.events.register("pre_execute", self._clear_warning_registry)
876 self.events.register("pre_execute", self._clear_warning_registry)
877
877
878 def register_post_execute(self, func):
878 def register_post_execute(self, func):
879 """DEPRECATED: Use ip.events.register('post_run_cell', func)
879 """DEPRECATED: Use ip.events.register('post_run_cell', func)
880
880
881 Register a function for calling after code execution.
881 Register a function for calling after code execution.
882 """
882 """
883 warn("ip.register_post_execute is deprecated, use "
883 warn("ip.register_post_execute is deprecated, use "
884 "ip.events.register('post_run_cell', func) instead.")
884 "ip.events.register('post_run_cell', func) instead.")
885 self.events.register('post_run_cell', func)
885 self.events.register('post_run_cell', func)
886
886
887 def _clear_warning_registry(self):
887 def _clear_warning_registry(self):
888 # clear the warning registry, so that different code blocks with
888 # clear the warning registry, so that different code blocks with
889 # overlapping line number ranges don't cause spurious suppression of
889 # overlapping line number ranges don't cause spurious suppression of
890 # warnings (see gh-6611 for details)
890 # warnings (see gh-6611 for details)
891 if "__warningregistry__" in self.user_global_ns:
891 if "__warningregistry__" in self.user_global_ns:
892 del self.user_global_ns["__warningregistry__"]
892 del self.user_global_ns["__warningregistry__"]
893
893
894 #-------------------------------------------------------------------------
894 #-------------------------------------------------------------------------
895 # Things related to the "main" module
895 # Things related to the "main" module
896 #-------------------------------------------------------------------------
896 #-------------------------------------------------------------------------
897
897
898 def new_main_mod(self, filename, modname):
898 def new_main_mod(self, filename, modname):
899 """Return a new 'main' module object for user code execution.
899 """Return a new 'main' module object for user code execution.
900
900
901 ``filename`` should be the path of the script which will be run in the
901 ``filename`` should be the path of the script which will be run in the
902 module. Requests with the same filename will get the same module, with
902 module. Requests with the same filename will get the same module, with
903 its namespace cleared.
903 its namespace cleared.
904
904
905 ``modname`` should be the module name - normally either '__main__' or
905 ``modname`` should be the module name - normally either '__main__' or
906 the basename of the file without the extension.
906 the basename of the file without the extension.
907
907
908 When scripts are executed via %run, we must keep a reference to their
908 When scripts are executed via %run, we must keep a reference to their
909 __main__ module around so that Python doesn't
909 __main__ module around so that Python doesn't
910 clear it, rendering references to module globals useless.
910 clear it, rendering references to module globals useless.
911
911
912 This method keeps said reference in a private dict, keyed by the
912 This method keeps said reference in a private dict, keyed by the
913 absolute path of the script. This way, for multiple executions of the
913 absolute path of the script. This way, for multiple executions of the
914 same script we only keep one copy of the namespace (the last one),
914 same script we only keep one copy of the namespace (the last one),
915 thus preventing memory leaks from old references while allowing the
915 thus preventing memory leaks from old references while allowing the
916 objects from the last execution to be accessible.
916 objects from the last execution to be accessible.
917 """
917 """
918 filename = os.path.abspath(filename)
918 filename = os.path.abspath(filename)
919 try:
919 try:
920 main_mod = self._main_mod_cache[filename]
920 main_mod = self._main_mod_cache[filename]
921 except KeyError:
921 except KeyError:
922 main_mod = self._main_mod_cache[filename] = types.ModuleType(
922 main_mod = self._main_mod_cache[filename] = types.ModuleType(
923 py3compat.cast_bytes_py2(modname),
923 py3compat.cast_bytes_py2(modname),
924 doc="Module created for script run in IPython")
924 doc="Module created for script run in IPython")
925 else:
925 else:
926 main_mod.__dict__.clear()
926 main_mod.__dict__.clear()
927 main_mod.__name__ = modname
927 main_mod.__name__ = modname
928
928
929 main_mod.__file__ = filename
929 main_mod.__file__ = filename
930 # It seems pydoc (and perhaps others) needs any module instance to
930 # It seems pydoc (and perhaps others) needs any module instance to
931 # implement a __nonzero__ method
931 # implement a __nonzero__ method
932 main_mod.__nonzero__ = lambda : True
932 main_mod.__nonzero__ = lambda : True
933
933
934 return main_mod
934 return main_mod
935
935
936 def clear_main_mod_cache(self):
936 def clear_main_mod_cache(self):
937 """Clear the cache of main modules.
937 """Clear the cache of main modules.
938
938
939 Mainly for use by utilities like %reset.
939 Mainly for use by utilities like %reset.
940
940
941 Examples
941 Examples
942 --------
942 --------
943
943
944 In [15]: import IPython
944 In [15]: import IPython
945
945
946 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
946 In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
947
947
948 In [17]: len(_ip._main_mod_cache) > 0
948 In [17]: len(_ip._main_mod_cache) > 0
949 Out[17]: True
949 Out[17]: True
950
950
951 In [18]: _ip.clear_main_mod_cache()
951 In [18]: _ip.clear_main_mod_cache()
952
952
953 In [19]: len(_ip._main_mod_cache) == 0
953 In [19]: len(_ip._main_mod_cache) == 0
954 Out[19]: True
954 Out[19]: True
955 """
955 """
956 self._main_mod_cache.clear()
956 self._main_mod_cache.clear()
957
957
958 #-------------------------------------------------------------------------
958 #-------------------------------------------------------------------------
959 # Things related to debugging
959 # Things related to debugging
960 #-------------------------------------------------------------------------
960 #-------------------------------------------------------------------------
961
961
962 def init_pdb(self):
962 def init_pdb(self):
963 # Set calling of pdb on exceptions
963 # Set calling of pdb on exceptions
964 # self.call_pdb is a property
964 # self.call_pdb is a property
965 self.call_pdb = self.pdb
965 self.call_pdb = self.pdb
966
966
967 def _get_call_pdb(self):
967 def _get_call_pdb(self):
968 return self._call_pdb
968 return self._call_pdb
969
969
970 def _set_call_pdb(self,val):
970 def _set_call_pdb(self,val):
971
971
972 if val not in (0,1,False,True):
972 if val not in (0,1,False,True):
973 raise ValueError('new call_pdb value must be boolean')
973 raise ValueError('new call_pdb value must be boolean')
974
974
975 # store value in instance
975 # store value in instance
976 self._call_pdb = val
976 self._call_pdb = val
977
977
978 # notify the actual exception handlers
978 # notify the actual exception handlers
979 self.InteractiveTB.call_pdb = val
979 self.InteractiveTB.call_pdb = val
980
980
981 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
981 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
982 'Control auto-activation of pdb at exceptions')
982 'Control auto-activation of pdb at exceptions')
983
983
984 def debugger(self,force=False):
984 def debugger(self,force=False):
985 """Call the pydb/pdb debugger.
985 """Call the pydb/pdb debugger.
986
986
987 Keywords:
987 Keywords:
988
988
989 - force(False): by default, this routine checks the instance call_pdb
989 - force(False): by default, this routine checks the instance call_pdb
990 flag and does not actually invoke the debugger if the flag is false.
990 flag and does not actually invoke the debugger if the flag is false.
991 The 'force' option forces the debugger to activate even if the flag
991 The 'force' option forces the debugger to activate even if the flag
992 is false.
992 is false.
993 """
993 """
994
994
995 if not (force or self.call_pdb):
995 if not (force or self.call_pdb):
996 return
996 return
997
997
998 if not hasattr(sys,'last_traceback'):
998 if not hasattr(sys,'last_traceback'):
999 error('No traceback has been produced, nothing to debug.')
999 error('No traceback has been produced, nothing to debug.')
1000 return
1000 return
1001
1001
1002 # use pydb if available
1002 # use pydb if available
1003 if debugger.has_pydb:
1003 if debugger.has_pydb:
1004 from pydb import pm
1004 from pydb import pm
1005 else:
1005 else:
1006 # fallback to our internal debugger
1006 # fallback to our internal debugger
1007 pm = lambda : self.InteractiveTB.debugger(force=True)
1007 pm = lambda : self.InteractiveTB.debugger(force=True)
1008
1008
1009 with self.readline_no_record:
1009 with self.readline_no_record:
1010 pm()
1010 pm()
1011
1011
1012 #-------------------------------------------------------------------------
1012 #-------------------------------------------------------------------------
1013 # Things related to IPython's various namespaces
1013 # Things related to IPython's various namespaces
1014 #-------------------------------------------------------------------------
1014 #-------------------------------------------------------------------------
1015 default_user_namespaces = True
1015 default_user_namespaces = True
1016
1016
1017 def init_create_namespaces(self, user_module=None, user_ns=None):
1017 def init_create_namespaces(self, user_module=None, user_ns=None):
1018 # Create the namespace where the user will operate. user_ns is
1018 # Create the namespace where the user will operate. user_ns is
1019 # normally the only one used, and it is passed to the exec calls as
1019 # normally the only one used, and it is passed to the exec calls as
1020 # the locals argument. But we do carry a user_global_ns namespace
1020 # the locals argument. But we do carry a user_global_ns namespace
1021 # given as the exec 'globals' argument, This is useful in embedding
1021 # given as the exec 'globals' argument, This is useful in embedding
1022 # situations where the ipython shell opens in a context where the
1022 # situations where the ipython shell opens in a context where the
1023 # distinction between locals and globals is meaningful. For
1023 # distinction between locals and globals is meaningful. For
1024 # non-embedded contexts, it is just the same object as the user_ns dict.
1024 # non-embedded contexts, it is just the same object as the user_ns dict.
1025
1025
1026 # FIXME. For some strange reason, __builtins__ is showing up at user
1026 # FIXME. For some strange reason, __builtins__ is showing up at user
1027 # level as a dict instead of a module. This is a manual fix, but I
1027 # level as a dict instead of a module. This is a manual fix, but I
1028 # should really track down where the problem is coming from. Alex
1028 # should really track down where the problem is coming from. Alex
1029 # Schmolck reported this problem first.
1029 # Schmolck reported this problem first.
1030
1030
1031 # A useful post by Alex Martelli on this topic:
1031 # A useful post by Alex Martelli on this topic:
1032 # Re: inconsistent value from __builtins__
1032 # Re: inconsistent value from __builtins__
1033 # Von: Alex Martelli <aleaxit@yahoo.com>
1033 # Von: Alex Martelli <aleaxit@yahoo.com>
1034 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
1034 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
1035 # Gruppen: comp.lang.python
1035 # Gruppen: comp.lang.python
1036
1036
1037 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
1037 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
1038 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
1038 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
1039 # > <type 'dict'>
1039 # > <type 'dict'>
1040 # > >>> print type(__builtins__)
1040 # > >>> print type(__builtins__)
1041 # > <type 'module'>
1041 # > <type 'module'>
1042 # > Is this difference in return value intentional?
1042 # > Is this difference in return value intentional?
1043
1043
1044 # Well, it's documented that '__builtins__' can be either a dictionary
1044 # Well, it's documented that '__builtins__' can be either a dictionary
1045 # or a module, and it's been that way for a long time. Whether it's
1045 # or a module, and it's been that way for a long time. Whether it's
1046 # intentional (or sensible), I don't know. In any case, the idea is
1046 # intentional (or sensible), I don't know. In any case, the idea is
1047 # that if you need to access the built-in namespace directly, you
1047 # that if you need to access the built-in namespace directly, you
1048 # should start with "import __builtin__" (note, no 's') which will
1048 # should start with "import __builtin__" (note, no 's') which will
1049 # definitely give you a module. Yeah, it's somewhat confusing:-(.
1049 # definitely give you a module. Yeah, it's somewhat confusing:-(.
1050
1050
1051 # These routines return a properly built module and dict as needed by
1051 # These routines return a properly built module and dict as needed by
1052 # the rest of the code, and can also be used by extension writers to
1052 # the rest of the code, and can also be used by extension writers to
1053 # generate properly initialized namespaces.
1053 # generate properly initialized namespaces.
1054 if (user_ns is not None) or (user_module is not None):
1054 if (user_ns is not None) or (user_module is not None):
1055 self.default_user_namespaces = False
1055 self.default_user_namespaces = False
1056 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
1056 self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
1057
1057
1058 # A record of hidden variables we have added to the user namespace, so
1058 # A record of hidden variables we have added to the user namespace, so
1059 # we can list later only variables defined in actual interactive use.
1059 # we can list later only variables defined in actual interactive use.
1060 self.user_ns_hidden = {}
1060 self.user_ns_hidden = {}
1061
1061
1062 # Now that FakeModule produces a real module, we've run into a nasty
1062 # Now that FakeModule produces a real module, we've run into a nasty
1063 # problem: after script execution (via %run), the module where the user
1063 # problem: after script execution (via %run), the module where the user
1064 # code ran is deleted. Now that this object is a true module (needed
1064 # code ran is deleted. Now that this object is a true module (needed
1065 # so docetst and other tools work correctly), the Python module
1065 # so docetst and other tools work correctly), the Python module
1066 # teardown mechanism runs over it, and sets to None every variable
1066 # teardown mechanism runs over it, and sets to None every variable
1067 # present in that module. Top-level references to objects from the
1067 # present in that module. Top-level references to objects from the
1068 # script survive, because the user_ns is updated with them. However,
1068 # script survive, because the user_ns is updated with them. However,
1069 # calling functions defined in the script that use other things from
1069 # calling functions defined in the script that use other things from
1070 # the script will fail, because the function's closure had references
1070 # the script will fail, because the function's closure had references
1071 # to the original objects, which are now all None. So we must protect
1071 # to the original objects, which are now all None. So we must protect
1072 # these modules from deletion by keeping a cache.
1072 # these modules from deletion by keeping a cache.
1073 #
1073 #
1074 # To avoid keeping stale modules around (we only need the one from the
1074 # To avoid keeping stale modules around (we only need the one from the
1075 # last run), we use a dict keyed with the full path to the script, so
1075 # last run), we use a dict keyed with the full path to the script, so
1076 # only the last version of the module is held in the cache. Note,
1076 # only the last version of the module is held in the cache. Note,
1077 # however, that we must cache the module *namespace contents* (their
1077 # however, that we must cache the module *namespace contents* (their
1078 # __dict__). Because if we try to cache the actual modules, old ones
1078 # __dict__). Because if we try to cache the actual modules, old ones
1079 # (uncached) could be destroyed while still holding references (such as
1079 # (uncached) could be destroyed while still holding references (such as
1080 # those held by GUI objects that tend to be long-lived)>
1080 # those held by GUI objects that tend to be long-lived)>
1081 #
1081 #
1082 # The %reset command will flush this cache. See the cache_main_mod()
1082 # The %reset command will flush this cache. See the cache_main_mod()
1083 # and clear_main_mod_cache() methods for details on use.
1083 # and clear_main_mod_cache() methods for details on use.
1084
1084
1085 # This is the cache used for 'main' namespaces
1085 # This is the cache used for 'main' namespaces
1086 self._main_mod_cache = {}
1086 self._main_mod_cache = {}
1087
1087
1088 # A table holding all the namespaces IPython deals with, so that
1088 # A table holding all the namespaces IPython deals with, so that
1089 # introspection facilities can search easily.
1089 # introspection facilities can search easily.
1090 self.ns_table = {'user_global':self.user_module.__dict__,
1090 self.ns_table = {'user_global':self.user_module.__dict__,
1091 'user_local':self.user_ns,
1091 'user_local':self.user_ns,
1092 'builtin':builtin_mod.__dict__
1092 'builtin':builtin_mod.__dict__
1093 }
1093 }
1094
1094
1095 @property
1095 @property
1096 def user_global_ns(self):
1096 def user_global_ns(self):
1097 return self.user_module.__dict__
1097 return self.user_module.__dict__
1098
1098
1099 def prepare_user_module(self, user_module=None, user_ns=None):
1099 def prepare_user_module(self, user_module=None, user_ns=None):
1100 """Prepare the module and namespace in which user code will be run.
1100 """Prepare the module and namespace in which user code will be run.
1101
1101
1102 When IPython is started normally, both parameters are None: a new module
1102 When IPython is started normally, both parameters are None: a new module
1103 is created automatically, and its __dict__ used as the namespace.
1103 is created automatically, and its __dict__ used as the namespace.
1104
1104
1105 If only user_module is provided, its __dict__ is used as the namespace.
1105 If only user_module is provided, its __dict__ is used as the namespace.
1106 If only user_ns is provided, a dummy module is created, and user_ns
1106 If only user_ns is provided, a dummy module is created, and user_ns
1107 becomes the global namespace. If both are provided (as they may be
1107 becomes the global namespace. If both are provided (as they may be
1108 when embedding), user_ns is the local namespace, and user_module
1108 when embedding), user_ns is the local namespace, and user_module
1109 provides the global namespace.
1109 provides the global namespace.
1110
1110
1111 Parameters
1111 Parameters
1112 ----------
1112 ----------
1113 user_module : module, optional
1113 user_module : module, optional
1114 The current user module in which IPython is being run. If None,
1114 The current user module in which IPython is being run. If None,
1115 a clean module will be created.
1115 a clean module will be created.
1116 user_ns : dict, optional
1116 user_ns : dict, optional
1117 A namespace in which to run interactive commands.
1117 A namespace in which to run interactive commands.
1118
1118
1119 Returns
1119 Returns
1120 -------
1120 -------
1121 A tuple of user_module and user_ns, each properly initialised.
1121 A tuple of user_module and user_ns, each properly initialised.
1122 """
1122 """
1123 if user_module is None and user_ns is not None:
1123 if user_module is None and user_ns is not None:
1124 user_ns.setdefault("__name__", "__main__")
1124 user_ns.setdefault("__name__", "__main__")
1125 user_module = DummyMod()
1125 user_module = DummyMod()
1126 user_module.__dict__ = user_ns
1126 user_module.__dict__ = user_ns
1127
1127
1128 if user_module is None:
1128 if user_module is None:
1129 user_module = types.ModuleType("__main__",
1129 user_module = types.ModuleType("__main__",
1130 doc="Automatically created module for IPython interactive environment")
1130 doc="Automatically created module for IPython interactive environment")
1131
1131
1132 # We must ensure that __builtin__ (without the final 's') is always
1132 # We must ensure that __builtin__ (without the final 's') is always
1133 # available and pointing to the __builtin__ *module*. For more details:
1133 # available and pointing to the __builtin__ *module*. For more details:
1134 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1134 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1135 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1135 user_module.__dict__.setdefault('__builtin__', builtin_mod)
1136 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1136 user_module.__dict__.setdefault('__builtins__', builtin_mod)
1137
1137
1138 if user_ns is None:
1138 if user_ns is None:
1139 user_ns = user_module.__dict__
1139 user_ns = user_module.__dict__
1140
1140
1141 return user_module, user_ns
1141 return user_module, user_ns
1142
1142
1143 def init_sys_modules(self):
1143 def init_sys_modules(self):
1144 # We need to insert into sys.modules something that looks like a
1144 # We need to insert into sys.modules something that looks like a
1145 # module but which accesses the IPython namespace, for shelve and
1145 # module but which accesses the IPython namespace, for shelve and
1146 # pickle to work interactively. Normally they rely on getting
1146 # pickle to work interactively. Normally they rely on getting
1147 # everything out of __main__, but for embedding purposes each IPython
1147 # everything out of __main__, but for embedding purposes each IPython
1148 # instance has its own private namespace, so we can't go shoving
1148 # instance has its own private namespace, so we can't go shoving
1149 # everything into __main__.
1149 # everything into __main__.
1150
1150
1151 # note, however, that we should only do this for non-embedded
1151 # note, however, that we should only do this for non-embedded
1152 # ipythons, which really mimic the __main__.__dict__ with their own
1152 # ipythons, which really mimic the __main__.__dict__ with their own
1153 # namespace. Embedded instances, on the other hand, should not do
1153 # namespace. Embedded instances, on the other hand, should not do
1154 # this because they need to manage the user local/global namespaces
1154 # this because they need to manage the user local/global namespaces
1155 # only, but they live within a 'normal' __main__ (meaning, they
1155 # only, but they live within a 'normal' __main__ (meaning, they
1156 # shouldn't overtake the execution environment of the script they're
1156 # shouldn't overtake the execution environment of the script they're
1157 # embedded in).
1157 # embedded in).
1158
1158
1159 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1159 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1160 main_name = self.user_module.__name__
1160 main_name = self.user_module.__name__
1161 sys.modules[main_name] = self.user_module
1161 sys.modules[main_name] = self.user_module
1162
1162
1163 def init_user_ns(self):
1163 def init_user_ns(self):
1164 """Initialize all user-visible namespaces to their minimum defaults.
1164 """Initialize all user-visible namespaces to their minimum defaults.
1165
1165
1166 Certain history lists are also initialized here, as they effectively
1166 Certain history lists are also initialized here, as they effectively
1167 act as user namespaces.
1167 act as user namespaces.
1168
1168
1169 Notes
1169 Notes
1170 -----
1170 -----
1171 All data structures here are only filled in, they are NOT reset by this
1171 All data structures here are only filled in, they are NOT reset by this
1172 method. If they were not empty before, data will simply be added to
1172 method. If they were not empty before, data will simply be added to
1173 therm.
1173 therm.
1174 """
1174 """
1175 # This function works in two parts: first we put a few things in
1175 # This function works in two parts: first we put a few things in
1176 # user_ns, and we sync that contents into user_ns_hidden so that these
1176 # user_ns, and we sync that contents into user_ns_hidden so that these
1177 # initial variables aren't shown by %who. After the sync, we add the
1177 # initial variables aren't shown by %who. After the sync, we add the
1178 # rest of what we *do* want the user to see with %who even on a new
1178 # rest of what we *do* want the user to see with %who even on a new
1179 # session (probably nothing, so theye really only see their own stuff)
1179 # session (probably nothing, so theye really only see their own stuff)
1180
1180
1181 # The user dict must *always* have a __builtin__ reference to the
1181 # The user dict must *always* have a __builtin__ reference to the
1182 # Python standard __builtin__ namespace, which must be imported.
1182 # Python standard __builtin__ namespace, which must be imported.
1183 # This is so that certain operations in prompt evaluation can be
1183 # This is so that certain operations in prompt evaluation can be
1184 # reliably executed with builtins. Note that we can NOT use
1184 # reliably executed with builtins. Note that we can NOT use
1185 # __builtins__ (note the 's'), because that can either be a dict or a
1185 # __builtins__ (note the 's'), because that can either be a dict or a
1186 # module, and can even mutate at runtime, depending on the context
1186 # module, and can even mutate at runtime, depending on the context
1187 # (Python makes no guarantees on it). In contrast, __builtin__ is
1187 # (Python makes no guarantees on it). In contrast, __builtin__ is
1188 # always a module object, though it must be explicitly imported.
1188 # always a module object, though it must be explicitly imported.
1189
1189
1190 # For more details:
1190 # For more details:
1191 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1191 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1192 ns = dict()
1192 ns = dict()
1193
1193
1194 # make global variables for user access to the histories
1194 # make global variables for user access to the histories
1195 ns['_ih'] = self.history_manager.input_hist_parsed
1195 ns['_ih'] = self.history_manager.input_hist_parsed
1196 ns['_oh'] = self.history_manager.output_hist
1196 ns['_oh'] = self.history_manager.output_hist
1197 ns['_dh'] = self.history_manager.dir_hist
1197 ns['_dh'] = self.history_manager.dir_hist
1198
1198
1199 ns['_sh'] = shadowns
1199 ns['_sh'] = shadowns
1200
1200
1201 # user aliases to input and output histories. These shouldn't show up
1201 # user aliases to input and output histories. These shouldn't show up
1202 # in %who, as they can have very large reprs.
1202 # in %who, as they can have very large reprs.
1203 ns['In'] = self.history_manager.input_hist_parsed
1203 ns['In'] = self.history_manager.input_hist_parsed
1204 ns['Out'] = self.history_manager.output_hist
1204 ns['Out'] = self.history_manager.output_hist
1205
1205
1206 # Store myself as the public api!!!
1206 # Store myself as the public api!!!
1207 ns['get_ipython'] = self.get_ipython
1207 ns['get_ipython'] = self.get_ipython
1208
1208
1209 ns['exit'] = self.exiter
1209 ns['exit'] = self.exiter
1210 ns['quit'] = self.exiter
1210 ns['quit'] = self.exiter
1211
1211
1212 # Sync what we've added so far to user_ns_hidden so these aren't seen
1212 # Sync what we've added so far to user_ns_hidden so these aren't seen
1213 # by %who
1213 # by %who
1214 self.user_ns_hidden.update(ns)
1214 self.user_ns_hidden.update(ns)
1215
1215
1216 # Anything put into ns now would show up in %who. Think twice before
1216 # Anything put into ns now would show up in %who. Think twice before
1217 # putting anything here, as we really want %who to show the user their
1217 # putting anything here, as we really want %who to show the user their
1218 # stuff, not our variables.
1218 # stuff, not our variables.
1219
1219
1220 # Finally, update the real user's namespace
1220 # Finally, update the real user's namespace
1221 self.user_ns.update(ns)
1221 self.user_ns.update(ns)
1222
1222
1223 @property
1223 @property
1224 def all_ns_refs(self):
1224 def all_ns_refs(self):
1225 """Get a list of references to all the namespace dictionaries in which
1225 """Get a list of references to all the namespace dictionaries in which
1226 IPython might store a user-created object.
1226 IPython might store a user-created object.
1227
1227
1228 Note that this does not include the displayhook, which also caches
1228 Note that this does not include the displayhook, which also caches
1229 objects from the output."""
1229 objects from the output."""
1230 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1230 return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
1231 [m.__dict__ for m in self._main_mod_cache.values()]
1231 [m.__dict__ for m in self._main_mod_cache.values()]
1232
1232
1233 def reset(self, new_session=True):
1233 def reset(self, new_session=True):
1234 """Clear all internal namespaces, and attempt to release references to
1234 """Clear all internal namespaces, and attempt to release references to
1235 user objects.
1235 user objects.
1236
1236
1237 If new_session is True, a new history session will be opened.
1237 If new_session is True, a new history session will be opened.
1238 """
1238 """
1239 # Clear histories
1239 # Clear histories
1240 self.history_manager.reset(new_session)
1240 self.history_manager.reset(new_session)
1241 # Reset counter used to index all histories
1241 # Reset counter used to index all histories
1242 if new_session:
1242 if new_session:
1243 self.execution_count = 1
1243 self.execution_count = 1
1244
1244
1245 # Flush cached output items
1245 # Flush cached output items
1246 if self.displayhook.do_full_cache:
1246 if self.displayhook.do_full_cache:
1247 self.displayhook.flush()
1247 self.displayhook.flush()
1248
1248
1249 # The main execution namespaces must be cleared very carefully,
1249 # The main execution namespaces must be cleared very carefully,
1250 # skipping the deletion of the builtin-related keys, because doing so
1250 # skipping the deletion of the builtin-related keys, because doing so
1251 # would cause errors in many object's __del__ methods.
1251 # would cause errors in many object's __del__ methods.
1252 if self.user_ns is not self.user_global_ns:
1252 if self.user_ns is not self.user_global_ns:
1253 self.user_ns.clear()
1253 self.user_ns.clear()
1254 ns = self.user_global_ns
1254 ns = self.user_global_ns
1255 drop_keys = set(ns.keys())
1255 drop_keys = set(ns.keys())
1256 drop_keys.discard('__builtin__')
1256 drop_keys.discard('__builtin__')
1257 drop_keys.discard('__builtins__')
1257 drop_keys.discard('__builtins__')
1258 drop_keys.discard('__name__')
1258 drop_keys.discard('__name__')
1259 for k in drop_keys:
1259 for k in drop_keys:
1260 del ns[k]
1260 del ns[k]
1261
1261
1262 self.user_ns_hidden.clear()
1262 self.user_ns_hidden.clear()
1263
1263
1264 # Restore the user namespaces to minimal usability
1264 # Restore the user namespaces to minimal usability
1265 self.init_user_ns()
1265 self.init_user_ns()
1266
1266
1267 # Restore the default and user aliases
1267 # Restore the default and user aliases
1268 self.alias_manager.clear_aliases()
1268 self.alias_manager.clear_aliases()
1269 self.alias_manager.init_aliases()
1269 self.alias_manager.init_aliases()
1270
1270
1271 # Flush the private list of module references kept for script
1271 # Flush the private list of module references kept for script
1272 # execution protection
1272 # execution protection
1273 self.clear_main_mod_cache()
1273 self.clear_main_mod_cache()
1274
1274
1275 def del_var(self, varname, by_name=False):
1275 def del_var(self, varname, by_name=False):
1276 """Delete a variable from the various namespaces, so that, as
1276 """Delete a variable from the various namespaces, so that, as
1277 far as possible, we're not keeping any hidden references to it.
1277 far as possible, we're not keeping any hidden references to it.
1278
1278
1279 Parameters
1279 Parameters
1280 ----------
1280 ----------
1281 varname : str
1281 varname : str
1282 The name of the variable to delete.
1282 The name of the variable to delete.
1283 by_name : bool
1283 by_name : bool
1284 If True, delete variables with the given name in each
1284 If True, delete variables with the given name in each
1285 namespace. If False (default), find the variable in the user
1285 namespace. If False (default), find the variable in the user
1286 namespace, and delete references to it.
1286 namespace, and delete references to it.
1287 """
1287 """
1288 if varname in ('__builtin__', '__builtins__'):
1288 if varname in ('__builtin__', '__builtins__'):
1289 raise ValueError("Refusing to delete %s" % varname)
1289 raise ValueError("Refusing to delete %s" % varname)
1290
1290
1291 ns_refs = self.all_ns_refs
1291 ns_refs = self.all_ns_refs
1292
1292
1293 if by_name: # Delete by name
1293 if by_name: # Delete by name
1294 for ns in ns_refs:
1294 for ns in ns_refs:
1295 try:
1295 try:
1296 del ns[varname]
1296 del ns[varname]
1297 except KeyError:
1297 except KeyError:
1298 pass
1298 pass
1299 else: # Delete by object
1299 else: # Delete by object
1300 try:
1300 try:
1301 obj = self.user_ns[varname]
1301 obj = self.user_ns[varname]
1302 except KeyError:
1302 except KeyError:
1303 raise NameError("name '%s' is not defined" % varname)
1303 raise NameError("name '%s' is not defined" % varname)
1304 # Also check in output history
1304 # Also check in output history
1305 ns_refs.append(self.history_manager.output_hist)
1305 ns_refs.append(self.history_manager.output_hist)
1306 for ns in ns_refs:
1306 for ns in ns_refs:
1307 to_delete = [n for n, o in iteritems(ns) if o is obj]
1307 to_delete = [n for n, o in iteritems(ns) if o is obj]
1308 for name in to_delete:
1308 for name in to_delete:
1309 del ns[name]
1309 del ns[name]
1310
1310
1311 # displayhook keeps extra references, but not in a dictionary
1311 # displayhook keeps extra references, but not in a dictionary
1312 for name in ('_', '__', '___'):
1312 for name in ('_', '__', '___'):
1313 if getattr(self.displayhook, name) is obj:
1313 if getattr(self.displayhook, name) is obj:
1314 setattr(self.displayhook, name, None)
1314 setattr(self.displayhook, name, None)
1315
1315
1316 def reset_selective(self, regex=None):
1316 def reset_selective(self, regex=None):
1317 """Clear selective variables from internal namespaces based on a
1317 """Clear selective variables from internal namespaces based on a
1318 specified regular expression.
1318 specified regular expression.
1319
1319
1320 Parameters
1320 Parameters
1321 ----------
1321 ----------
1322 regex : string or compiled pattern, optional
1322 regex : string or compiled pattern, optional
1323 A regular expression pattern that will be used in searching
1323 A regular expression pattern that will be used in searching
1324 variable names in the users namespaces.
1324 variable names in the users namespaces.
1325 """
1325 """
1326 if regex is not None:
1326 if regex is not None:
1327 try:
1327 try:
1328 m = re.compile(regex)
1328 m = re.compile(regex)
1329 except TypeError:
1329 except TypeError:
1330 raise TypeError('regex must be a string or compiled pattern')
1330 raise TypeError('regex must be a string or compiled pattern')
1331 # Search for keys in each namespace that match the given regex
1331 # Search for keys in each namespace that match the given regex
1332 # If a match is found, delete the key/value pair.
1332 # If a match is found, delete the key/value pair.
1333 for ns in self.all_ns_refs:
1333 for ns in self.all_ns_refs:
1334 for var in ns:
1334 for var in ns:
1335 if m.search(var):
1335 if m.search(var):
1336 del ns[var]
1336 del ns[var]
1337
1337
1338 def push(self, variables, interactive=True):
1338 def push(self, variables, interactive=True):
1339 """Inject a group of variables into the IPython user namespace.
1339 """Inject a group of variables into the IPython user namespace.
1340
1340
1341 Parameters
1341 Parameters
1342 ----------
1342 ----------
1343 variables : dict, str or list/tuple of str
1343 variables : dict, str or list/tuple of str
1344 The variables to inject into the user's namespace. If a dict, a
1344 The variables to inject into the user's namespace. If a dict, a
1345 simple update is done. If a str, the string is assumed to have
1345 simple update is done. If a str, the string is assumed to have
1346 variable names separated by spaces. A list/tuple of str can also
1346 variable names separated by spaces. A list/tuple of str can also
1347 be used to give the variable names. If just the variable names are
1347 be used to give the variable names. If just the variable names are
1348 give (list/tuple/str) then the variable values looked up in the
1348 give (list/tuple/str) then the variable values looked up in the
1349 callers frame.
1349 callers frame.
1350 interactive : bool
1350 interactive : bool
1351 If True (default), the variables will be listed with the ``who``
1351 If True (default), the variables will be listed with the ``who``
1352 magic.
1352 magic.
1353 """
1353 """
1354 vdict = None
1354 vdict = None
1355
1355
1356 # We need a dict of name/value pairs to do namespace updates.
1356 # We need a dict of name/value pairs to do namespace updates.
1357 if isinstance(variables, dict):
1357 if isinstance(variables, dict):
1358 vdict = variables
1358 vdict = variables
1359 elif isinstance(variables, string_types+(list, tuple)):
1359 elif isinstance(variables, string_types+(list, tuple)):
1360 if isinstance(variables, string_types):
1360 if isinstance(variables, string_types):
1361 vlist = variables.split()
1361 vlist = variables.split()
1362 else:
1362 else:
1363 vlist = variables
1363 vlist = variables
1364 vdict = {}
1364 vdict = {}
1365 cf = sys._getframe(1)
1365 cf = sys._getframe(1)
1366 for name in vlist:
1366 for name in vlist:
1367 try:
1367 try:
1368 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1368 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1369 except:
1369 except:
1370 print('Could not get variable %s from %s' %
1370 print('Could not get variable %s from %s' %
1371 (name,cf.f_code.co_name))
1371 (name,cf.f_code.co_name))
1372 else:
1372 else:
1373 raise ValueError('variables must be a dict/str/list/tuple')
1373 raise ValueError('variables must be a dict/str/list/tuple')
1374
1374
1375 # Propagate variables to user namespace
1375 # Propagate variables to user namespace
1376 self.user_ns.update(vdict)
1376 self.user_ns.update(vdict)
1377
1377
1378 # And configure interactive visibility
1378 # And configure interactive visibility
1379 user_ns_hidden = self.user_ns_hidden
1379 user_ns_hidden = self.user_ns_hidden
1380 if interactive:
1380 if interactive:
1381 for name in vdict:
1381 for name in vdict:
1382 user_ns_hidden.pop(name, None)
1382 user_ns_hidden.pop(name, None)
1383 else:
1383 else:
1384 user_ns_hidden.update(vdict)
1384 user_ns_hidden.update(vdict)
1385
1385
1386 def drop_by_id(self, variables):
1386 def drop_by_id(self, variables):
1387 """Remove a dict of variables from the user namespace, if they are the
1387 """Remove a dict of variables from the user namespace, if they are the
1388 same as the values in the dictionary.
1388 same as the values in the dictionary.
1389
1389
1390 This is intended for use by extensions: variables that they've added can
1390 This is intended for use by extensions: variables that they've added can
1391 be taken back out if they are unloaded, without removing any that the
1391 be taken back out if they are unloaded, without removing any that the
1392 user has overwritten.
1392 user has overwritten.
1393
1393
1394 Parameters
1394 Parameters
1395 ----------
1395 ----------
1396 variables : dict
1396 variables : dict
1397 A dictionary mapping object names (as strings) to the objects.
1397 A dictionary mapping object names (as strings) to the objects.
1398 """
1398 """
1399 for name, obj in iteritems(variables):
1399 for name, obj in iteritems(variables):
1400 if name in self.user_ns and self.user_ns[name] is obj:
1400 if name in self.user_ns and self.user_ns[name] is obj:
1401 del self.user_ns[name]
1401 del self.user_ns[name]
1402 self.user_ns_hidden.pop(name, None)
1402 self.user_ns_hidden.pop(name, None)
1403
1403
1404 #-------------------------------------------------------------------------
1404 #-------------------------------------------------------------------------
1405 # Things related to object introspection
1405 # Things related to object introspection
1406 #-------------------------------------------------------------------------
1406 #-------------------------------------------------------------------------
1407
1407
1408 def _ofind(self, oname, namespaces=None):
1408 def _ofind(self, oname, namespaces=None):
1409 """Find an object in the available namespaces.
1409 """Find an object in the available namespaces.
1410
1410
1411 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1411 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1412
1412
1413 Has special code to detect magic functions.
1413 Has special code to detect magic functions.
1414 """
1414 """
1415 oname = oname.strip()
1415 oname = oname.strip()
1416 #print '1- oname: <%r>' % oname # dbg
1416 #print '1- oname: <%r>' % oname # dbg
1417 if not oname.startswith(ESC_MAGIC) and \
1417 if not oname.startswith(ESC_MAGIC) and \
1418 not oname.startswith(ESC_MAGIC2) and \
1418 not oname.startswith(ESC_MAGIC2) and \
1419 not py3compat.isidentifier(oname, dotted=True):
1419 not py3compat.isidentifier(oname, dotted=True):
1420 return dict(found=False)
1420 return dict(found=False)
1421
1421
1422 alias_ns = None
1422 alias_ns = None
1423 if namespaces is None:
1423 if namespaces is None:
1424 # Namespaces to search in:
1424 # Namespaces to search in:
1425 # Put them in a list. The order is important so that we
1425 # Put them in a list. The order is important so that we
1426 # find things in the same order that Python finds them.
1426 # find things in the same order that Python finds them.
1427 namespaces = [ ('Interactive', self.user_ns),
1427 namespaces = [ ('Interactive', self.user_ns),
1428 ('Interactive (global)', self.user_global_ns),
1428 ('Interactive (global)', self.user_global_ns),
1429 ('Python builtin', builtin_mod.__dict__),
1429 ('Python builtin', builtin_mod.__dict__),
1430 ]
1430 ]
1431
1431
1432 # initialize results to 'null'
1432 # initialize results to 'null'
1433 found = False; obj = None; ospace = None; ds = None;
1433 found = False; obj = None; ospace = None; ds = None;
1434 ismagic = False; isalias = False; parent = None
1434 ismagic = False; isalias = False; parent = None
1435
1435
1436 # We need to special-case 'print', which as of python2.6 registers as a
1436 # We need to special-case 'print', which as of python2.6 registers as a
1437 # function but should only be treated as one if print_function was
1437 # function but should only be treated as one if print_function was
1438 # loaded with a future import. In this case, just bail.
1438 # loaded with a future import. In this case, just bail.
1439 if (oname == 'print' and not py3compat.PY3 and not \
1439 if (oname == 'print' and not py3compat.PY3 and not \
1440 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1440 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1441 return {'found':found, 'obj':obj, 'namespace':ospace,
1441 return {'found':found, 'obj':obj, 'namespace':ospace,
1442 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1442 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1443
1443
1444 # Look for the given name by splitting it in parts. If the head is
1444 # Look for the given name by splitting it in parts. If the head is
1445 # found, then we look for all the remaining parts as members, and only
1445 # found, then we look for all the remaining parts as members, and only
1446 # declare success if we can find them all.
1446 # declare success if we can find them all.
1447 oname_parts = oname.split('.')
1447 oname_parts = oname.split('.')
1448 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1448 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1449 for nsname,ns in namespaces:
1449 for nsname,ns in namespaces:
1450 try:
1450 try:
1451 obj = ns[oname_head]
1451 obj = ns[oname_head]
1452 except KeyError:
1452 except KeyError:
1453 continue
1453 continue
1454 else:
1454 else:
1455 #print 'oname_rest:', oname_rest # dbg
1455 #print 'oname_rest:', oname_rest # dbg
1456 for idx, part in enumerate(oname_rest):
1456 for idx, part in enumerate(oname_rest):
1457 try:
1457 try:
1458 parent = obj
1458 parent = obj
1459 # The last part is looked up in a special way to avoid
1459 # The last part is looked up in a special way to avoid
1460 # descriptor invocation as it may raise or have side
1460 # descriptor invocation as it may raise or have side
1461 # effects.
1461 # effects.
1462 if idx == len(oname_rest) - 1:
1462 if idx == len(oname_rest) - 1:
1463 obj = self._getattr_property(obj, part)
1463 obj = self._getattr_property(obj, part)
1464 else:
1464 else:
1465 obj = getattr(obj, part)
1465 obj = getattr(obj, part)
1466 except:
1466 except:
1467 # Blanket except b/c some badly implemented objects
1467 # Blanket except b/c some badly implemented objects
1468 # allow __getattr__ to raise exceptions other than
1468 # allow __getattr__ to raise exceptions other than
1469 # AttributeError, which then crashes IPython.
1469 # AttributeError, which then crashes IPython.
1470 break
1470 break
1471 else:
1471 else:
1472 # If we finish the for loop (no break), we got all members
1472 # If we finish the for loop (no break), we got all members
1473 found = True
1473 found = True
1474 ospace = nsname
1474 ospace = nsname
1475 break # namespace loop
1475 break # namespace loop
1476
1476
1477 # Try to see if it's magic
1477 # Try to see if it's magic
1478 if not found:
1478 if not found:
1479 obj = None
1479 obj = None
1480 if oname.startswith(ESC_MAGIC2):
1480 if oname.startswith(ESC_MAGIC2):
1481 oname = oname.lstrip(ESC_MAGIC2)
1481 oname = oname.lstrip(ESC_MAGIC2)
1482 obj = self.find_cell_magic(oname)
1482 obj = self.find_cell_magic(oname)
1483 elif oname.startswith(ESC_MAGIC):
1483 elif oname.startswith(ESC_MAGIC):
1484 oname = oname.lstrip(ESC_MAGIC)
1484 oname = oname.lstrip(ESC_MAGIC)
1485 obj = self.find_line_magic(oname)
1485 obj = self.find_line_magic(oname)
1486 else:
1486 else:
1487 # search without prefix, so run? will find %run?
1487 # search without prefix, so run? will find %run?
1488 obj = self.find_line_magic(oname)
1488 obj = self.find_line_magic(oname)
1489 if obj is None:
1489 if obj is None:
1490 obj = self.find_cell_magic(oname)
1490 obj = self.find_cell_magic(oname)
1491 if obj is not None:
1491 if obj is not None:
1492 found = True
1492 found = True
1493 ospace = 'IPython internal'
1493 ospace = 'IPython internal'
1494 ismagic = True
1494 ismagic = True
1495
1495
1496 # Last try: special-case some literals like '', [], {}, etc:
1496 # Last try: special-case some literals like '', [], {}, etc:
1497 if not found and oname_head in ["''",'""','[]','{}','()']:
1497 if not found and oname_head in ["''",'""','[]','{}','()']:
1498 obj = eval(oname_head)
1498 obj = eval(oname_head)
1499 found = True
1499 found = True
1500 ospace = 'Interactive'
1500 ospace = 'Interactive'
1501
1501
1502 return {'found':found, 'obj':obj, 'namespace':ospace,
1502 return {'found':found, 'obj':obj, 'namespace':ospace,
1503 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1503 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1504
1504
1505 @staticmethod
1505 @staticmethod
1506 def _getattr_property(obj, attrname):
1506 def _getattr_property(obj, attrname):
1507 """Property-aware getattr to use in object finding.
1507 """Property-aware getattr to use in object finding.
1508
1508
1509 If attrname represents a property, return it unevaluated (in case it has
1509 If attrname represents a property, return it unevaluated (in case it has
1510 side effects or raises an error.
1510 side effects or raises an error.
1511
1511
1512 """
1512 """
1513 if not isinstance(obj, type):
1513 if not isinstance(obj, type):
1514 try:
1514 try:
1515 # `getattr(type(obj), attrname)` is not guaranteed to return
1515 # `getattr(type(obj), attrname)` is not guaranteed to return
1516 # `obj`, but does so for property:
1516 # `obj`, but does so for property:
1517 #
1517 #
1518 # property.__get__(self, None, cls) -> self
1518 # property.__get__(self, None, cls) -> self
1519 #
1519 #
1520 # The universal alternative is to traverse the mro manually
1520 # The universal alternative is to traverse the mro manually
1521 # searching for attrname in class dicts.
1521 # searching for attrname in class dicts.
1522 attr = getattr(type(obj), attrname)
1522 attr = getattr(type(obj), attrname)
1523 except AttributeError:
1523 except AttributeError:
1524 pass
1524 pass
1525 else:
1525 else:
1526 # This relies on the fact that data descriptors (with both
1526 # This relies on the fact that data descriptors (with both
1527 # __get__ & __set__ magic methods) take precedence over
1527 # __get__ & __set__ magic methods) take precedence over
1528 # instance-level attributes:
1528 # instance-level attributes:
1529 #
1529 #
1530 # class A(object):
1530 # class A(object):
1531 # @property
1531 # @property
1532 # def foobar(self): return 123
1532 # def foobar(self): return 123
1533 # a = A()
1533 # a = A()
1534 # a.__dict__['foobar'] = 345
1534 # a.__dict__['foobar'] = 345
1535 # a.foobar # == 123
1535 # a.foobar # == 123
1536 #
1536 #
1537 # So, a property may be returned right away.
1537 # So, a property may be returned right away.
1538 if isinstance(attr, property):
1538 if isinstance(attr, property):
1539 return attr
1539 return attr
1540
1540
1541 # Nothing helped, fall back.
1541 # Nothing helped, fall back.
1542 return getattr(obj, attrname)
1542 return getattr(obj, attrname)
1543
1543
1544 def _object_find(self, oname, namespaces=None):
1544 def _object_find(self, oname, namespaces=None):
1545 """Find an object and return a struct with info about it."""
1545 """Find an object and return a struct with info about it."""
1546 return Struct(self._ofind(oname, namespaces))
1546 return Struct(self._ofind(oname, namespaces))
1547
1547
1548 def _inspect(self, meth, oname, namespaces=None, **kw):
1548 def _inspect(self, meth, oname, namespaces=None, **kw):
1549 """Generic interface to the inspector system.
1549 """Generic interface to the inspector system.
1550
1550
1551 This function is meant to be called by pdef, pdoc & friends."""
1551 This function is meant to be called by pdef, pdoc & friends."""
1552 info = self._object_find(oname, namespaces)
1552 info = self._object_find(oname, namespaces)
1553 if info.found:
1553 if info.found:
1554 pmethod = getattr(self.inspector, meth)
1554 pmethod = getattr(self.inspector, meth)
1555 formatter = format_screen if info.ismagic else None
1555 formatter = format_screen if info.ismagic else None
1556 if meth == 'pdoc':
1556 if meth == 'pdoc':
1557 pmethod(info.obj, oname, formatter)
1557 pmethod(info.obj, oname, formatter)
1558 elif meth == 'pinfo':
1558 elif meth == 'pinfo':
1559 pmethod(info.obj, oname, formatter, info, **kw)
1559 pmethod(info.obj, oname, formatter, info, **kw)
1560 else:
1560 else:
1561 pmethod(info.obj, oname)
1561 pmethod(info.obj, oname)
1562 else:
1562 else:
1563 print('Object `%s` not found.' % oname)
1563 print('Object `%s` not found.' % oname)
1564 return 'not found' # so callers can take other action
1564 return 'not found' # so callers can take other action
1565
1565
1566 def object_inspect(self, oname, detail_level=0):
1566 def object_inspect(self, oname, detail_level=0):
1567 """Get object info about oname"""
1567 """Get object info about oname"""
1568 with self.builtin_trap:
1568 with self.builtin_trap:
1569 info = self._object_find(oname)
1569 info = self._object_find(oname)
1570 if info.found:
1570 if info.found:
1571 return self.inspector.info(info.obj, oname, info=info,
1571 return self.inspector.info(info.obj, oname, info=info,
1572 detail_level=detail_level
1572 detail_level=detail_level
1573 )
1573 )
1574 else:
1574 else:
1575 return oinspect.object_info(name=oname, found=False)
1575 return oinspect.object_info(name=oname, found=False)
1576
1576
1577 def object_inspect_text(self, oname, detail_level=0):
1577 def object_inspect_text(self, oname, detail_level=0):
1578 """Get object info as formatted text"""
1578 """Get object info as formatted text"""
1579 with self.builtin_trap:
1579 with self.builtin_trap:
1580 info = self._object_find(oname)
1580 info = self._object_find(oname)
1581 if info.found:
1581 if info.found:
1582 return self.inspector._format_info(info.obj, oname, info=info,
1582 return self.inspector._format_info(info.obj, oname, info=info,
1583 detail_level=detail_level
1583 detail_level=detail_level
1584 )
1584 )
1585 else:
1585 else:
1586 raise KeyError(oname)
1586 raise KeyError(oname)
1587
1587
1588 #-------------------------------------------------------------------------
1588 #-------------------------------------------------------------------------
1589 # Things related to history management
1589 # Things related to history management
1590 #-------------------------------------------------------------------------
1590 #-------------------------------------------------------------------------
1591
1591
1592 def init_history(self):
1592 def init_history(self):
1593 """Sets up the command history, and starts regular autosaves."""
1593 """Sets up the command history, and starts regular autosaves."""
1594 self.history_manager = HistoryManager(shell=self, parent=self)
1594 self.history_manager = HistoryManager(shell=self, parent=self)
1595 self.configurables.append(self.history_manager)
1595 self.configurables.append(self.history_manager)
1596
1596
1597 #-------------------------------------------------------------------------
1597 #-------------------------------------------------------------------------
1598 # Things related to exception handling and tracebacks (not debugging)
1598 # Things related to exception handling and tracebacks (not debugging)
1599 #-------------------------------------------------------------------------
1599 #-------------------------------------------------------------------------
1600
1600
1601 def init_traceback_handlers(self, custom_exceptions):
1601 def init_traceback_handlers(self, custom_exceptions):
1602 # Syntax error handler.
1602 # Syntax error handler.
1603 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1603 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1604
1604
1605 # The interactive one is initialized with an offset, meaning we always
1605 # The interactive one is initialized with an offset, meaning we always
1606 # want to remove the topmost item in the traceback, which is our own
1606 # want to remove the topmost item in the traceback, which is our own
1607 # internal code. Valid modes: ['Plain','Context','Verbose']
1607 # internal code. Valid modes: ['Plain','Context','Verbose']
1608 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1608 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1609 color_scheme='NoColor',
1609 color_scheme='NoColor',
1610 tb_offset = 1,
1610 tb_offset = 1,
1611 check_cache=check_linecache_ipython)
1611 check_cache=check_linecache_ipython)
1612
1612
1613 # The instance will store a pointer to the system-wide exception hook,
1613 # The instance will store a pointer to the system-wide exception hook,
1614 # so that runtime code (such as magics) can access it. This is because
1614 # so that runtime code (such as magics) can access it. This is because
1615 # during the read-eval loop, it may get temporarily overwritten.
1615 # during the read-eval loop, it may get temporarily overwritten.
1616 self.sys_excepthook = sys.excepthook
1616 self.sys_excepthook = sys.excepthook
1617
1617
1618 # and add any custom exception handlers the user may have specified
1618 # and add any custom exception handlers the user may have specified
1619 self.set_custom_exc(*custom_exceptions)
1619 self.set_custom_exc(*custom_exceptions)
1620
1620
1621 # Set the exception mode
1621 # Set the exception mode
1622 self.InteractiveTB.set_mode(mode=self.xmode)
1622 self.InteractiveTB.set_mode(mode=self.xmode)
1623
1623
1624 def set_custom_exc(self, exc_tuple, handler):
1624 def set_custom_exc(self, exc_tuple, handler):
1625 """set_custom_exc(exc_tuple,handler)
1625 """set_custom_exc(exc_tuple,handler)
1626
1626
1627 Set a custom exception handler, which will be called if any of the
1627 Set a custom exception handler, which will be called if any of the
1628 exceptions in exc_tuple occur in the mainloop (specifically, in the
1628 exceptions in exc_tuple occur in the mainloop (specifically, in the
1629 run_code() method).
1629 run_code() method).
1630
1630
1631 Parameters
1631 Parameters
1632 ----------
1632 ----------
1633
1633
1634 exc_tuple : tuple of exception classes
1634 exc_tuple : tuple of exception classes
1635 A *tuple* of exception classes, for which to call the defined
1635 A *tuple* of exception classes, for which to call the defined
1636 handler. It is very important that you use a tuple, and NOT A
1636 handler. It is very important that you use a tuple, and NOT A
1637 LIST here, because of the way Python's except statement works. If
1637 LIST here, because of the way Python's except statement works. If
1638 you only want to trap a single exception, use a singleton tuple::
1638 you only want to trap a single exception, use a singleton tuple::
1639
1639
1640 exc_tuple == (MyCustomException,)
1640 exc_tuple == (MyCustomException,)
1641
1641
1642 handler : callable
1642 handler : callable
1643 handler must have the following signature::
1643 handler must have the following signature::
1644
1644
1645 def my_handler(self, etype, value, tb, tb_offset=None):
1645 def my_handler(self, etype, value, tb, tb_offset=None):
1646 ...
1646 ...
1647 return structured_traceback
1647 return structured_traceback
1648
1648
1649 Your handler must return a structured traceback (a list of strings),
1649 Your handler must return a structured traceback (a list of strings),
1650 or None.
1650 or None.
1651
1651
1652 This will be made into an instance method (via types.MethodType)
1652 This will be made into an instance method (via types.MethodType)
1653 of IPython itself, and it will be called if any of the exceptions
1653 of IPython itself, and it will be called if any of the exceptions
1654 listed in the exc_tuple are caught. If the handler is None, an
1654 listed in the exc_tuple are caught. If the handler is None, an
1655 internal basic one is used, which just prints basic info.
1655 internal basic one is used, which just prints basic info.
1656
1656
1657 To protect IPython from crashes, if your handler ever raises an
1657 To protect IPython from crashes, if your handler ever raises an
1658 exception or returns an invalid result, it will be immediately
1658 exception or returns an invalid result, it will be immediately
1659 disabled.
1659 disabled.
1660
1660
1661 WARNING: by putting in your own exception handler into IPython's main
1661 WARNING: by putting in your own exception handler into IPython's main
1662 execution loop, you run a very good chance of nasty crashes. This
1662 execution loop, you run a very good chance of nasty crashes. This
1663 facility should only be used if you really know what you are doing."""
1663 facility should only be used if you really know what you are doing."""
1664
1664
1665 assert type(exc_tuple)==type(()) , \
1665 assert type(exc_tuple)==type(()) , \
1666 "The custom exceptions must be given AS A TUPLE."
1666 "The custom exceptions must be given AS A TUPLE."
1667
1667
1668 def dummy_handler(self,etype,value,tb,tb_offset=None):
1668 def dummy_handler(self,etype,value,tb,tb_offset=None):
1669 print('*** Simple custom exception handler ***')
1669 print('*** Simple custom exception handler ***')
1670 print('Exception type :',etype)
1670 print('Exception type :',etype)
1671 print('Exception value:',value)
1671 print('Exception value:',value)
1672 print('Traceback :',tb)
1672 print('Traceback :',tb)
1673 #print 'Source code :','\n'.join(self.buffer)
1673 #print 'Source code :','\n'.join(self.buffer)
1674
1674
1675 def validate_stb(stb):
1675 def validate_stb(stb):
1676 """validate structured traceback return type
1676 """validate structured traceback return type
1677
1677
1678 return type of CustomTB *should* be a list of strings, but allow
1678 return type of CustomTB *should* be a list of strings, but allow
1679 single strings or None, which are harmless.
1679 single strings or None, which are harmless.
1680
1680
1681 This function will *always* return a list of strings,
1681 This function will *always* return a list of strings,
1682 and will raise a TypeError if stb is inappropriate.
1682 and will raise a TypeError if stb is inappropriate.
1683 """
1683 """
1684 msg = "CustomTB must return list of strings, not %r" % stb
1684 msg = "CustomTB must return list of strings, not %r" % stb
1685 if stb is None:
1685 if stb is None:
1686 return []
1686 return []
1687 elif isinstance(stb, string_types):
1687 elif isinstance(stb, string_types):
1688 return [stb]
1688 return [stb]
1689 elif not isinstance(stb, list):
1689 elif not isinstance(stb, list):
1690 raise TypeError(msg)
1690 raise TypeError(msg)
1691 # it's a list
1691 # it's a list
1692 for line in stb:
1692 for line in stb:
1693 # check every element
1693 # check every element
1694 if not isinstance(line, string_types):
1694 if not isinstance(line, string_types):
1695 raise TypeError(msg)
1695 raise TypeError(msg)
1696 return stb
1696 return stb
1697
1697
1698 if handler is None:
1698 if handler is None:
1699 wrapped = dummy_handler
1699 wrapped = dummy_handler
1700 else:
1700 else:
1701 def wrapped(self,etype,value,tb,tb_offset=None):
1701 def wrapped(self,etype,value,tb,tb_offset=None):
1702 """wrap CustomTB handler, to protect IPython from user code
1702 """wrap CustomTB handler, to protect IPython from user code
1703
1703
1704 This makes it harder (but not impossible) for custom exception
1704 This makes it harder (but not impossible) for custom exception
1705 handlers to crash IPython.
1705 handlers to crash IPython.
1706 """
1706 """
1707 try:
1707 try:
1708 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1708 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1709 return validate_stb(stb)
1709 return validate_stb(stb)
1710 except:
1710 except:
1711 # clear custom handler immediately
1711 # clear custom handler immediately
1712 self.set_custom_exc((), None)
1712 self.set_custom_exc((), None)
1713 print("Custom TB Handler failed, unregistering", file=io.stderr)
1713 print("Custom TB Handler failed, unregistering", file=io.stderr)
1714 # show the exception in handler first
1714 # show the exception in handler first
1715 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1715 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1716 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1716 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1717 print("The original exception:", file=io.stdout)
1717 print("The original exception:", file=io.stdout)
1718 stb = self.InteractiveTB.structured_traceback(
1718 stb = self.InteractiveTB.structured_traceback(
1719 (etype,value,tb), tb_offset=tb_offset
1719 (etype,value,tb), tb_offset=tb_offset
1720 )
1720 )
1721 return stb
1721 return stb
1722
1722
1723 self.CustomTB = types.MethodType(wrapped,self)
1723 self.CustomTB = types.MethodType(wrapped,self)
1724 self.custom_exceptions = exc_tuple
1724 self.custom_exceptions = exc_tuple
1725
1725
1726 def excepthook(self, etype, value, tb):
1726 def excepthook(self, etype, value, tb):
1727 """One more defense for GUI apps that call sys.excepthook.
1727 """One more defense for GUI apps that call sys.excepthook.
1728
1728
1729 GUI frameworks like wxPython trap exceptions and call
1729 GUI frameworks like wxPython trap exceptions and call
1730 sys.excepthook themselves. I guess this is a feature that
1730 sys.excepthook themselves. I guess this is a feature that
1731 enables them to keep running after exceptions that would
1731 enables them to keep running after exceptions that would
1732 otherwise kill their mainloop. This is a bother for IPython
1732 otherwise kill their mainloop. This is a bother for IPython
1733 which excepts to catch all of the program exceptions with a try:
1733 which excepts to catch all of the program exceptions with a try:
1734 except: statement.
1734 except: statement.
1735
1735
1736 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1736 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1737 any app directly invokes sys.excepthook, it will look to the user like
1737 any app directly invokes sys.excepthook, it will look to the user like
1738 IPython crashed. In order to work around this, we can disable the
1738 IPython crashed. In order to work around this, we can disable the
1739 CrashHandler and replace it with this excepthook instead, which prints a
1739 CrashHandler and replace it with this excepthook instead, which prints a
1740 regular traceback using our InteractiveTB. In this fashion, apps which
1740 regular traceback using our InteractiveTB. In this fashion, apps which
1741 call sys.excepthook will generate a regular-looking exception from
1741 call sys.excepthook will generate a regular-looking exception from
1742 IPython, and the CrashHandler will only be triggered by real IPython
1742 IPython, and the CrashHandler will only be triggered by real IPython
1743 crashes.
1743 crashes.
1744
1744
1745 This hook should be used sparingly, only in places which are not likely
1745 This hook should be used sparingly, only in places which are not likely
1746 to be true IPython errors.
1746 to be true IPython errors.
1747 """
1747 """
1748 self.showtraceback((etype, value, tb), tb_offset=0)
1748 self.showtraceback((etype, value, tb), tb_offset=0)
1749
1749
1750 def _get_exc_info(self, exc_tuple=None):
1750 def _get_exc_info(self, exc_tuple=None):
1751 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1751 """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
1752
1752
1753 Ensures sys.last_type,value,traceback hold the exc_info we found,
1753 Ensures sys.last_type,value,traceback hold the exc_info we found,
1754 from whichever source.
1754 from whichever source.
1755
1755
1756 raises ValueError if none of these contain any information
1756 raises ValueError if none of these contain any information
1757 """
1757 """
1758 if exc_tuple is None:
1758 if exc_tuple is None:
1759 etype, value, tb = sys.exc_info()
1759 etype, value, tb = sys.exc_info()
1760 else:
1760 else:
1761 etype, value, tb = exc_tuple
1761 etype, value, tb = exc_tuple
1762
1762
1763 if etype is None:
1763 if etype is None:
1764 if hasattr(sys, 'last_type'):
1764 if hasattr(sys, 'last_type'):
1765 etype, value, tb = sys.last_type, sys.last_value, \
1765 etype, value, tb = sys.last_type, sys.last_value, \
1766 sys.last_traceback
1766 sys.last_traceback
1767
1767
1768 if etype is None:
1768 if etype is None:
1769 raise ValueError("No exception to find")
1769 raise ValueError("No exception to find")
1770
1770
1771 # Now store the exception info in sys.last_type etc.
1771 # Now store the exception info in sys.last_type etc.
1772 # WARNING: these variables are somewhat deprecated and not
1772 # WARNING: these variables are somewhat deprecated and not
1773 # necessarily safe to use in a threaded environment, but tools
1773 # necessarily safe to use in a threaded environment, but tools
1774 # like pdb depend on their existence, so let's set them. If we
1774 # like pdb depend on their existence, so let's set them. If we
1775 # find problems in the field, we'll need to revisit their use.
1775 # find problems in the field, we'll need to revisit their use.
1776 sys.last_type = etype
1776 sys.last_type = etype
1777 sys.last_value = value
1777 sys.last_value = value
1778 sys.last_traceback = tb
1778 sys.last_traceback = tb
1779
1779
1780 return etype, value, tb
1780 return etype, value, tb
1781
1781
1782 def show_usage_error(self, exc):
1782 def show_usage_error(self, exc):
1783 """Show a short message for UsageErrors
1783 """Show a short message for UsageErrors
1784
1784
1785 These are special exceptions that shouldn't show a traceback.
1785 These are special exceptions that shouldn't show a traceback.
1786 """
1786 """
1787 self.write_err("UsageError: %s" % exc)
1787 self.write_err("UsageError: %s" % exc)
1788
1788
1789 def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
1789 def showtraceback(self, exc_tuple=None, filename=None, tb_offset=None,
1790 exception_only=False):
1790 exception_only=False):
1791 """Display the exception that just occurred.
1791 """Display the exception that just occurred.
1792
1792
1793 If nothing is known about the exception, this is the method which
1793 If nothing is known about the exception, this is the method which
1794 should be used throughout the code for presenting user tracebacks,
1794 should be used throughout the code for presenting user tracebacks,
1795 rather than directly invoking the InteractiveTB object.
1795 rather than directly invoking the InteractiveTB object.
1796
1796
1797 A specific showsyntaxerror() also exists, but this method can take
1797 A specific showsyntaxerror() also exists, but this method can take
1798 care of calling it if needed, so unless you are explicitly catching a
1798 care of calling it if needed, so unless you are explicitly catching a
1799 SyntaxError exception, don't try to analyze the stack manually and
1799 SyntaxError exception, don't try to analyze the stack manually and
1800 simply call this method."""
1800 simply call this method."""
1801
1801
1802 try:
1802 try:
1803 try:
1803 try:
1804 etype, value, tb = self._get_exc_info(exc_tuple)
1804 etype, value, tb = self._get_exc_info(exc_tuple)
1805 except ValueError:
1805 except ValueError:
1806 self.write_err('No traceback available to show.\n')
1806 self.write_err('No traceback available to show.\n')
1807 return
1807 return
1808
1808
1809 if issubclass(etype, SyntaxError):
1809 if issubclass(etype, SyntaxError):
1810 # Though this won't be called by syntax errors in the input
1810 # Though this won't be called by syntax errors in the input
1811 # line, there may be SyntaxError cases with imported code.
1811 # line, there may be SyntaxError cases with imported code.
1812 self.showsyntaxerror(filename)
1812 self.showsyntaxerror(filename)
1813 elif etype is UsageError:
1813 elif etype is UsageError:
1814 self.show_usage_error(value)
1814 self.show_usage_error(value)
1815 else:
1815 else:
1816 if exception_only:
1816 if exception_only:
1817 stb = ['An exception has occurred, use %tb to see '
1817 stb = ['An exception has occurred, use %tb to see '
1818 'the full traceback.\n']
1818 'the full traceback.\n']
1819 stb.extend(self.InteractiveTB.get_exception_only(etype,
1819 stb.extend(self.InteractiveTB.get_exception_only(etype,
1820 value))
1820 value))
1821 else:
1821 else:
1822 try:
1822 try:
1823 # Exception classes can customise their traceback - we
1823 # Exception classes can customise their traceback - we
1824 # use this in IPython.parallel for exceptions occurring
1824 # use this in IPython.parallel for exceptions occurring
1825 # in the engines. This should return a list of strings.
1825 # in the engines. This should return a list of strings.
1826 stb = value._render_traceback_()
1826 stb = value._render_traceback_()
1827 except Exception:
1827 except Exception:
1828 stb = self.InteractiveTB.structured_traceback(etype,
1828 stb = self.InteractiveTB.structured_traceback(etype,
1829 value, tb, tb_offset=tb_offset)
1829 value, tb, tb_offset=tb_offset)
1830
1830
1831 self._showtraceback(etype, value, stb)
1831 self._showtraceback(etype, value, stb)
1832 if self.call_pdb:
1832 if self.call_pdb:
1833 # drop into debugger
1833 # drop into debugger
1834 self.debugger(force=True)
1834 self.debugger(force=True)
1835 return
1835 return
1836
1836
1837 # Actually show the traceback
1837 # Actually show the traceback
1838 self._showtraceback(etype, value, stb)
1838 self._showtraceback(etype, value, stb)
1839
1839
1840 except KeyboardInterrupt:
1840 except KeyboardInterrupt:
1841 self.write_err("\nKeyboardInterrupt\n")
1841 self.write_err("\nKeyboardInterrupt\n")
1842
1842
1843 def _showtraceback(self, etype, evalue, stb):
1843 def _showtraceback(self, etype, evalue, stb):
1844 """Actually show a traceback.
1844 """Actually show a traceback.
1845
1845
1846 Subclasses may override this method to put the traceback on a different
1846 Subclasses may override this method to put the traceback on a different
1847 place, like a side channel.
1847 place, like a side channel.
1848 """
1848 """
1849 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1849 print(self.InteractiveTB.stb2text(stb), file=io.stdout)
1850
1850
1851 def showsyntaxerror(self, filename=None):
1851 def showsyntaxerror(self, filename=None):
1852 """Display the syntax error that just occurred.
1852 """Display the syntax error that just occurred.
1853
1853
1854 This doesn't display a stack trace because there isn't one.
1854 This doesn't display a stack trace because there isn't one.
1855
1855
1856 If a filename is given, it is stuffed in the exception instead
1856 If a filename is given, it is stuffed in the exception instead
1857 of what was there before (because Python's parser always uses
1857 of what was there before (because Python's parser always uses
1858 "<string>" when reading from a string).
1858 "<string>" when reading from a string).
1859 """
1859 """
1860 etype, value, last_traceback = self._get_exc_info()
1860 etype, value, last_traceback = self._get_exc_info()
1861
1861
1862 if filename and issubclass(etype, SyntaxError):
1862 if filename and issubclass(etype, SyntaxError):
1863 try:
1863 try:
1864 value.filename = filename
1864 value.filename = filename
1865 except:
1865 except:
1866 # Not the format we expect; leave it alone
1866 # Not the format we expect; leave it alone
1867 pass
1867 pass
1868
1868
1869 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1869 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1870 self._showtraceback(etype, value, stb)
1870 self._showtraceback(etype, value, stb)
1871
1871
1872 # This is overridden in TerminalInteractiveShell to show a message about
1872 # This is overridden in TerminalInteractiveShell to show a message about
1873 # the %paste magic.
1873 # the %paste magic.
1874 def showindentationerror(self):
1874 def showindentationerror(self):
1875 """Called by run_cell when there's an IndentationError in code entered
1875 """Called by run_cell when there's an IndentationError in code entered
1876 at the prompt.
1876 at the prompt.
1877
1877
1878 This is overridden in TerminalInteractiveShell to show a message about
1878 This is overridden in TerminalInteractiveShell to show a message about
1879 the %paste magic."""
1879 the %paste magic."""
1880 self.showsyntaxerror()
1880 self.showsyntaxerror()
1881
1881
1882 #-------------------------------------------------------------------------
1882 #-------------------------------------------------------------------------
1883 # Things related to readline
1883 # Things related to readline
1884 #-------------------------------------------------------------------------
1884 #-------------------------------------------------------------------------
1885
1885
1886 def init_readline(self):
1886 def init_readline(self):
1887 """Command history completion/saving/reloading."""
1887 """Command history completion/saving/reloading."""
1888
1888
1889 if self.readline_use:
1889 if self.readline_use:
1890 import IPython.utils.rlineimpl as readline
1890 import IPython.utils.rlineimpl as readline
1891
1891
1892 self.rl_next_input = None
1892 self.rl_next_input = None
1893 self.rl_do_indent = False
1893 self.rl_do_indent = False
1894
1894
1895 if not self.readline_use or not readline.have_readline:
1895 if not self.readline_use or not readline.have_readline:
1896 self.has_readline = False
1896 self.has_readline = False
1897 self.readline = None
1897 self.readline = None
1898 # Set a number of methods that depend on readline to be no-op
1898 # Set a number of methods that depend on readline to be no-op
1899 self.readline_no_record = no_op_context
1899 self.readline_no_record = no_op_context
1900 self.set_readline_completer = no_op
1900 self.set_readline_completer = no_op
1901 self.set_custom_completer = no_op
1901 self.set_custom_completer = no_op
1902 if self.readline_use:
1902 if self.readline_use:
1903 warn('Readline services not available or not loaded.')
1903 warn('Readline services not available or not loaded.')
1904 else:
1904 else:
1905 self.has_readline = True
1905 self.has_readline = True
1906 self.readline = readline
1906 self.readline = readline
1907 sys.modules['readline'] = readline
1907 sys.modules['readline'] = readline
1908
1908
1909 # Platform-specific configuration
1909 # Platform-specific configuration
1910 if os.name == 'nt':
1910 if os.name == 'nt':
1911 # FIXME - check with Frederick to see if we can harmonize
1911 # FIXME - check with Frederick to see if we can harmonize
1912 # naming conventions with pyreadline to avoid this
1912 # naming conventions with pyreadline to avoid this
1913 # platform-dependent check
1913 # platform-dependent check
1914 self.readline_startup_hook = readline.set_pre_input_hook
1914 self.readline_startup_hook = readline.set_pre_input_hook
1915 else:
1915 else:
1916 self.readline_startup_hook = readline.set_startup_hook
1916 self.readline_startup_hook = readline.set_startup_hook
1917
1917
1918 # Readline config order:
1918 # Readline config order:
1919 # - IPython config (default value)
1919 # - IPython config (default value)
1920 # - custom inputrc
1920 # - custom inputrc
1921 # - IPython config (user customized)
1921 # - IPython config (user customized)
1922
1922
1923 # load IPython config before inputrc if default
1923 # load IPython config before inputrc if default
1924 # skip if libedit because parse_and_bind syntax is different
1924 # skip if libedit because parse_and_bind syntax is different
1925 if not self._custom_readline_config and not readline.uses_libedit:
1925 if not self._custom_readline_config and not readline.uses_libedit:
1926 for rlcommand in self.readline_parse_and_bind:
1926 for rlcommand in self.readline_parse_and_bind:
1927 readline.parse_and_bind(rlcommand)
1927 readline.parse_and_bind(rlcommand)
1928
1928
1929 # Load user's initrc file (readline config)
1929 # Load user's initrc file (readline config)
1930 # Or if libedit is used, load editrc.
1930 # Or if libedit is used, load editrc.
1931 inputrc_name = os.environ.get('INPUTRC')
1931 inputrc_name = os.environ.get('INPUTRC')
1932 if inputrc_name is None:
1932 if inputrc_name is None:
1933 inputrc_name = '.inputrc'
1933 inputrc_name = '.inputrc'
1934 if readline.uses_libedit:
1934 if readline.uses_libedit:
1935 inputrc_name = '.editrc'
1935 inputrc_name = '.editrc'
1936 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1936 inputrc_name = os.path.join(self.home_dir, inputrc_name)
1937 if os.path.isfile(inputrc_name):
1937 if os.path.isfile(inputrc_name):
1938 try:
1938 try:
1939 readline.read_init_file(inputrc_name)
1939 readline.read_init_file(inputrc_name)
1940 except:
1940 except:
1941 warn('Problems reading readline initialization file <%s>'
1941 warn('Problems reading readline initialization file <%s>'
1942 % inputrc_name)
1942 % inputrc_name)
1943
1943
1944 # load IPython config after inputrc if user has customized
1944 # load IPython config after inputrc if user has customized
1945 if self._custom_readline_config:
1945 if self._custom_readline_config:
1946 for rlcommand in self.readline_parse_and_bind:
1946 for rlcommand in self.readline_parse_and_bind:
1947 readline.parse_and_bind(rlcommand)
1947 readline.parse_and_bind(rlcommand)
1948
1948
1949 # Remove some chars from the delimiters list. If we encounter
1949 # Remove some chars from the delimiters list. If we encounter
1950 # unicode chars, discard them.
1950 # unicode chars, discard them.
1951 delims = readline.get_completer_delims()
1951 delims = readline.get_completer_delims()
1952 if not py3compat.PY3:
1952 if not py3compat.PY3:
1953 delims = delims.encode("ascii", "ignore")
1953 delims = delims.encode("ascii", "ignore")
1954 for d in self.readline_remove_delims:
1954 for d in self.readline_remove_delims:
1955 delims = delims.replace(d, "")
1955 delims = delims.replace(d, "")
1956 delims = delims.replace(ESC_MAGIC, '')
1956 delims = delims.replace(ESC_MAGIC, '')
1957 readline.set_completer_delims(delims)
1957 readline.set_completer_delims(delims)
1958 # Store these so we can restore them if something like rpy2 modifies
1958 # Store these so we can restore them if something like rpy2 modifies
1959 # them.
1959 # them.
1960 self.readline_delims = delims
1960 self.readline_delims = delims
1961 # otherwise we end up with a monster history after a while:
1961 # otherwise we end up with a monster history after a while:
1962 readline.set_history_length(self.history_length)
1962 readline.set_history_length(self.history_length)
1963
1963
1964 self.refill_readline_hist()
1964 self.refill_readline_hist()
1965 self.readline_no_record = ReadlineNoRecord(self)
1965 self.readline_no_record = ReadlineNoRecord(self)
1966
1966
1967 # Configure auto-indent for all platforms
1967 # Configure auto-indent for all platforms
1968 self.set_autoindent(self.autoindent)
1968 self.set_autoindent(self.autoindent)
1969
1969
1970 def refill_readline_hist(self):
1970 def refill_readline_hist(self):
1971 # Load the last 1000 lines from history
1971 # Load the last 1000 lines from history
1972 self.readline.clear_history()
1972 self.readline.clear_history()
1973 stdin_encoding = sys.stdin.encoding or "utf-8"
1973 stdin_encoding = sys.stdin.encoding or "utf-8"
1974 last_cell = u""
1974 last_cell = u""
1975 for _, _, cell in self.history_manager.get_tail(1000,
1975 for _, _, cell in self.history_manager.get_tail(1000,
1976 include_latest=True):
1976 include_latest=True):
1977 # Ignore blank lines and consecutive duplicates
1977 # Ignore blank lines and consecutive duplicates
1978 cell = cell.rstrip()
1978 cell = cell.rstrip()
1979 if cell and (cell != last_cell):
1979 if cell and (cell != last_cell):
1980 try:
1980 try:
1981 if self.multiline_history:
1981 if self.multiline_history:
1982 self.readline.add_history(py3compat.unicode_to_str(cell,
1982 self.readline.add_history(py3compat.unicode_to_str(cell,
1983 stdin_encoding))
1983 stdin_encoding))
1984 else:
1984 else:
1985 for line in cell.splitlines():
1985 for line in cell.splitlines():
1986 self.readline.add_history(py3compat.unicode_to_str(line,
1986 self.readline.add_history(py3compat.unicode_to_str(line,
1987 stdin_encoding))
1987 stdin_encoding))
1988 last_cell = cell
1988 last_cell = cell
1989
1989
1990 except TypeError:
1990 except TypeError:
1991 # The history DB can get corrupted so it returns strings
1991 # The history DB can get corrupted so it returns strings
1992 # containing null bytes, which readline objects to.
1992 # containing null bytes, which readline objects to.
1993 continue
1993 continue
1994
1994
1995 @skip_doctest
1995 @skip_doctest
1996 def set_next_input(self, s):
1996 def set_next_input(self, s):
1997 """ Sets the 'default' input string for the next command line.
1997 """ Sets the 'default' input string for the next command line.
1998
1998
1999 Requires readline.
1999 Requires readline.
2000
2000
2001 Example::
2001 Example::
2002
2002
2003 In [1]: _ip.set_next_input("Hello Word")
2003 In [1]: _ip.set_next_input("Hello Word")
2004 In [2]: Hello Word_ # cursor is here
2004 In [2]: Hello Word_ # cursor is here
2005 """
2005 """
2006 self.rl_next_input = py3compat.cast_bytes_py2(s)
2006 self.rl_next_input = py3compat.cast_bytes_py2(s)
2007
2007
2008 # Maybe move this to the terminal subclass?
2008 # Maybe move this to the terminal subclass?
2009 def pre_readline(self):
2009 def pre_readline(self):
2010 """readline hook to be used at the start of each line.
2010 """readline hook to be used at the start of each line.
2011
2011
2012 Currently it handles auto-indent only."""
2012 Currently it handles auto-indent only."""
2013
2013
2014 if self.rl_do_indent:
2014 if self.rl_do_indent:
2015 self.readline.insert_text(self._indent_current_str())
2015 self.readline.insert_text(self._indent_current_str())
2016 if self.rl_next_input is not None:
2016 if self.rl_next_input is not None:
2017 self.readline.insert_text(self.rl_next_input)
2017 self.readline.insert_text(self.rl_next_input)
2018 self.rl_next_input = None
2018 self.rl_next_input = None
2019
2019
2020 def _indent_current_str(self):
2020 def _indent_current_str(self):
2021 """return the current level of indentation as a string"""
2021 """return the current level of indentation as a string"""
2022 return self.input_splitter.indent_spaces * ' '
2022 return self.input_splitter.indent_spaces * ' '
2023
2023
2024 #-------------------------------------------------------------------------
2024 #-------------------------------------------------------------------------
2025 # Things related to text completion
2025 # Things related to text completion
2026 #-------------------------------------------------------------------------
2026 #-------------------------------------------------------------------------
2027
2027
2028 def init_completer(self):
2028 def init_completer(self):
2029 """Initialize the completion machinery.
2029 """Initialize the completion machinery.
2030
2030
2031 This creates completion machinery that can be used by client code,
2031 This creates completion machinery that can be used by client code,
2032 either interactively in-process (typically triggered by the readline
2032 either interactively in-process (typically triggered by the readline
2033 library), programatically (such as in test suites) or out-of-prcess
2033 library), programatically (such as in test suites) or out-of-prcess
2034 (typically over the network by remote frontends).
2034 (typically over the network by remote frontends).
2035 """
2035 """
2036 from IPython.core.completer import IPCompleter
2036 from IPython.core.completer import IPCompleter
2037 from IPython.core.completerlib import (module_completer,
2037 from IPython.core.completerlib import (module_completer,
2038 magic_run_completer, cd_completer, reset_completer)
2038 magic_run_completer, cd_completer, reset_completer)
2039
2039
2040 self.Completer = IPCompleter(shell=self,
2040 self.Completer = IPCompleter(shell=self,
2041 namespace=self.user_ns,
2041 namespace=self.user_ns,
2042 global_namespace=self.user_global_ns,
2042 global_namespace=self.user_global_ns,
2043 use_readline=self.has_readline,
2043 use_readline=self.has_readline,
2044 parent=self,
2044 parent=self,
2045 )
2045 )
2046 self.configurables.append(self.Completer)
2046 self.configurables.append(self.Completer)
2047
2047
2048 # Add custom completers to the basic ones built into IPCompleter
2048 # Add custom completers to the basic ones built into IPCompleter
2049 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
2049 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
2050 self.strdispatchers['complete_command'] = sdisp
2050 self.strdispatchers['complete_command'] = sdisp
2051 self.Completer.custom_completers = sdisp
2051 self.Completer.custom_completers = sdisp
2052
2052
2053 self.set_hook('complete_command', module_completer, str_key = 'import')
2053 self.set_hook('complete_command', module_completer, str_key = 'import')
2054 self.set_hook('complete_command', module_completer, str_key = 'from')
2054 self.set_hook('complete_command', module_completer, str_key = 'from')
2055 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
2055 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
2056 self.set_hook('complete_command', cd_completer, str_key = '%cd')
2056 self.set_hook('complete_command', cd_completer, str_key = '%cd')
2057 self.set_hook('complete_command', reset_completer, str_key = '%reset')
2057 self.set_hook('complete_command', reset_completer, str_key = '%reset')
2058
2058
2059 # Only configure readline if we truly are using readline. IPython can
2059 # Only configure readline if we truly are using readline. IPython can
2060 # do tab-completion over the network, in GUIs, etc, where readline
2060 # do tab-completion over the network, in GUIs, etc, where readline
2061 # itself may be absent
2061 # itself may be absent
2062 if self.has_readline:
2062 if self.has_readline:
2063 self.set_readline_completer()
2063 self.set_readline_completer()
2064
2064
2065 def complete(self, text, line=None, cursor_pos=None):
2065 def complete(self, text, line=None, cursor_pos=None):
2066 """Return the completed text and a list of completions.
2066 """Return the completed text and a list of completions.
2067
2067
2068 Parameters
2068 Parameters
2069 ----------
2069 ----------
2070
2070
2071 text : string
2071 text : string
2072 A string of text to be completed on. It can be given as empty and
2072 A string of text to be completed on. It can be given as empty and
2073 instead a line/position pair are given. In this case, the
2073 instead a line/position pair are given. In this case, the
2074 completer itself will split the line like readline does.
2074 completer itself will split the line like readline does.
2075
2075
2076 line : string, optional
2076 line : string, optional
2077 The complete line that text is part of.
2077 The complete line that text is part of.
2078
2078
2079 cursor_pos : int, optional
2079 cursor_pos : int, optional
2080 The position of the cursor on the input line.
2080 The position of the cursor on the input line.
2081
2081
2082 Returns
2082 Returns
2083 -------
2083 -------
2084 text : string
2084 text : string
2085 The actual text that was completed.
2085 The actual text that was completed.
2086
2086
2087 matches : list
2087 matches : list
2088 A sorted list with all possible completions.
2088 A sorted list with all possible completions.
2089
2089
2090 The optional arguments allow the completion to take more context into
2090 The optional arguments allow the completion to take more context into
2091 account, and are part of the low-level completion API.
2091 account, and are part of the low-level completion API.
2092
2092
2093 This is a wrapper around the completion mechanism, similar to what
2093 This is a wrapper around the completion mechanism, similar to what
2094 readline does at the command line when the TAB key is hit. By
2094 readline does at the command line when the TAB key is hit. By
2095 exposing it as a method, it can be used by other non-readline
2095 exposing it as a method, it can be used by other non-readline
2096 environments (such as GUIs) for text completion.
2096 environments (such as GUIs) for text completion.
2097
2097
2098 Simple usage example:
2098 Simple usage example:
2099
2099
2100 In [1]: x = 'hello'
2100 In [1]: x = 'hello'
2101
2101
2102 In [2]: _ip.complete('x.l')
2102 In [2]: _ip.complete('x.l')
2103 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
2103 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
2104 """
2104 """
2105
2105
2106 # Inject names into __builtin__ so we can complete on the added names.
2106 # Inject names into __builtin__ so we can complete on the added names.
2107 with self.builtin_trap:
2107 with self.builtin_trap:
2108 return self.Completer.complete(text, line, cursor_pos)
2108 return self.Completer.complete(text, line, cursor_pos)
2109
2109
2110 def set_custom_completer(self, completer, pos=0):
2110 def set_custom_completer(self, completer, pos=0):
2111 """Adds a new custom completer function.
2111 """Adds a new custom completer function.
2112
2112
2113 The position argument (defaults to 0) is the index in the completers
2113 The position argument (defaults to 0) is the index in the completers
2114 list where you want the completer to be inserted."""
2114 list where you want the completer to be inserted."""
2115
2115
2116 newcomp = types.MethodType(completer,self.Completer)
2116 newcomp = types.MethodType(completer,self.Completer)
2117 self.Completer.matchers.insert(pos,newcomp)
2117 self.Completer.matchers.insert(pos,newcomp)
2118
2118
2119 def set_readline_completer(self):
2119 def set_readline_completer(self):
2120 """Reset readline's completer to be our own."""
2120 """Reset readline's completer to be our own."""
2121 self.readline.set_completer(self.Completer.rlcomplete)
2121 self.readline.set_completer(self.Completer.rlcomplete)
2122
2122
2123 def set_completer_frame(self, frame=None):
2123 def set_completer_frame(self, frame=None):
2124 """Set the frame of the completer."""
2124 """Set the frame of the completer."""
2125 if frame:
2125 if frame:
2126 self.Completer.namespace = frame.f_locals
2126 self.Completer.namespace = frame.f_locals
2127 self.Completer.global_namespace = frame.f_globals
2127 self.Completer.global_namespace = frame.f_globals
2128 else:
2128 else:
2129 self.Completer.namespace = self.user_ns
2129 self.Completer.namespace = self.user_ns
2130 self.Completer.global_namespace = self.user_global_ns
2130 self.Completer.global_namespace = self.user_global_ns
2131
2131
2132 #-------------------------------------------------------------------------
2132 #-------------------------------------------------------------------------
2133 # Things related to magics
2133 # Things related to magics
2134 #-------------------------------------------------------------------------
2134 #-------------------------------------------------------------------------
2135
2135
2136 def init_magics(self):
2136 def init_magics(self):
2137 from IPython.core import magics as m
2137 from IPython.core import magics as m
2138 self.magics_manager = magic.MagicsManager(shell=self,
2138 self.magics_manager = magic.MagicsManager(shell=self,
2139 parent=self,
2139 parent=self,
2140 user_magics=m.UserMagics(self))
2140 user_magics=m.UserMagics(self))
2141 self.configurables.append(self.magics_manager)
2141 self.configurables.append(self.magics_manager)
2142
2142
2143 # Expose as public API from the magics manager
2143 # Expose as public API from the magics manager
2144 self.register_magics = self.magics_manager.register
2144 self.register_magics = self.magics_manager.register
2145 self.define_magic = self.magics_manager.define_magic
2145 self.define_magic = self.magics_manager.define_magic
2146
2146
2147 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2147 self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
2148 m.ConfigMagics, m.DeprecatedMagics, m.DisplayMagics, m.ExecutionMagics,
2148 m.ConfigMagics, m.DeprecatedMagics, m.DisplayMagics, m.ExecutionMagics,
2149 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2149 m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
2150 m.NamespaceMagics, m.OSMagics, m.PylabMagics, m.ScriptMagics,
2150 m.NamespaceMagics, m.OSMagics, m.PylabMagics, m.ScriptMagics,
2151 )
2151 )
2152
2152
2153 # Register Magic Aliases
2153 # Register Magic Aliases
2154 mman = self.magics_manager
2154 mman = self.magics_manager
2155 # FIXME: magic aliases should be defined by the Magics classes
2155 # FIXME: magic aliases should be defined by the Magics classes
2156 # or in MagicsManager, not here
2156 # or in MagicsManager, not here
2157 mman.register_alias('ed', 'edit')
2157 mman.register_alias('ed', 'edit')
2158 mman.register_alias('hist', 'history')
2158 mman.register_alias('hist', 'history')
2159 mman.register_alias('rep', 'recall')
2159 mman.register_alias('rep', 'recall')
2160 mman.register_alias('SVG', 'svg', 'cell')
2160 mman.register_alias('SVG', 'svg', 'cell')
2161 mman.register_alias('HTML', 'html', 'cell')
2161 mman.register_alias('HTML', 'html', 'cell')
2162 mman.register_alias('file', 'writefile', 'cell')
2162 mman.register_alias('file', 'writefile', 'cell')
2163
2163
2164 # FIXME: Move the color initialization to the DisplayHook, which
2164 # FIXME: Move the color initialization to the DisplayHook, which
2165 # should be split into a prompt manager and displayhook. We probably
2165 # should be split into a prompt manager and displayhook. We probably
2166 # even need a centralize colors management object.
2166 # even need a centralize colors management object.
2167 self.magic('colors %s' % self.colors)
2167 self.magic('colors %s' % self.colors)
2168
2168
2169 # Defined here so that it's included in the documentation
2169 # Defined here so that it's included in the documentation
2170 @functools.wraps(magic.MagicsManager.register_function)
2170 @functools.wraps(magic.MagicsManager.register_function)
2171 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2171 def register_magic_function(self, func, magic_kind='line', magic_name=None):
2172 self.magics_manager.register_function(func,
2172 self.magics_manager.register_function(func,
2173 magic_kind=magic_kind, magic_name=magic_name)
2173 magic_kind=magic_kind, magic_name=magic_name)
2174
2174
2175 def run_line_magic(self, magic_name, line):
2175 def run_line_magic(self, magic_name, line):
2176 """Execute the given line magic.
2176 """Execute the given line magic.
2177
2177
2178 Parameters
2178 Parameters
2179 ----------
2179 ----------
2180 magic_name : str
2180 magic_name : str
2181 Name of the desired magic function, without '%' prefix.
2181 Name of the desired magic function, without '%' prefix.
2182
2182
2183 line : str
2183 line : str
2184 The rest of the input line as a single string.
2184 The rest of the input line as a single string.
2185 """
2185 """
2186 fn = self.find_line_magic(magic_name)
2186 fn = self.find_line_magic(magic_name)
2187 if fn is None:
2187 if fn is None:
2188 cm = self.find_cell_magic(magic_name)
2188 cm = self.find_cell_magic(magic_name)
2189 etpl = "Line magic function `%%%s` not found%s."
2189 etpl = "Line magic function `%%%s` not found%s."
2190 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2190 extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
2191 'did you mean that instead?)' % magic_name )
2191 'did you mean that instead?)' % magic_name )
2192 error(etpl % (magic_name, extra))
2192 error(etpl % (magic_name, extra))
2193 else:
2193 else:
2194 # Note: this is the distance in the stack to the user's frame.
2194 # Note: this is the distance in the stack to the user's frame.
2195 # This will need to be updated if the internal calling logic gets
2195 # This will need to be updated if the internal calling logic gets
2196 # refactored, or else we'll be expanding the wrong variables.
2196 # refactored, or else we'll be expanding the wrong variables.
2197 stack_depth = 2
2197 stack_depth = 2
2198 magic_arg_s = self.var_expand(line, stack_depth)
2198 magic_arg_s = self.var_expand(line, stack_depth)
2199 # Put magic args in a list so we can call with f(*a) syntax
2199 # Put magic args in a list so we can call with f(*a) syntax
2200 args = [magic_arg_s]
2200 args = [magic_arg_s]
2201 kwargs = {}
2201 kwargs = {}
2202 # Grab local namespace if we need it:
2202 # Grab local namespace if we need it:
2203 if getattr(fn, "needs_local_scope", False):
2203 if getattr(fn, "needs_local_scope", False):
2204 kwargs['local_ns'] = sys._getframe(stack_depth).f_locals
2204 kwargs['local_ns'] = sys._getframe(stack_depth).f_locals
2205 with self.builtin_trap:
2205 with self.builtin_trap:
2206 result = fn(*args,**kwargs)
2206 result = fn(*args,**kwargs)
2207 return result
2207 return result
2208
2208
2209 def run_cell_magic(self, magic_name, line, cell):
2209 def run_cell_magic(self, magic_name, line, cell):
2210 """Execute the given cell magic.
2210 """Execute the given cell magic.
2211
2211
2212 Parameters
2212 Parameters
2213 ----------
2213 ----------
2214 magic_name : str
2214 magic_name : str
2215 Name of the desired magic function, without '%' prefix.
2215 Name of the desired magic function, without '%' prefix.
2216
2216
2217 line : str
2217 line : str
2218 The rest of the first input line as a single string.
2218 The rest of the first input line as a single string.
2219
2219
2220 cell : str
2220 cell : str
2221 The body of the cell as a (possibly multiline) string.
2221 The body of the cell as a (possibly multiline) string.
2222 """
2222 """
2223 fn = self.find_cell_magic(magic_name)
2223 fn = self.find_cell_magic(magic_name)
2224 if fn is None:
2224 if fn is None:
2225 lm = self.find_line_magic(magic_name)
2225 lm = self.find_line_magic(magic_name)
2226 etpl = "Cell magic `%%{0}` not found{1}."
2226 etpl = "Cell magic `%%{0}` not found{1}."
2227 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2227 extra = '' if lm is None else (' (But line magic `%{0}` exists, '
2228 'did you mean that instead?)'.format(magic_name))
2228 'did you mean that instead?)'.format(magic_name))
2229 error(etpl.format(magic_name, extra))
2229 error(etpl.format(magic_name, extra))
2230 elif cell == '':
2230 elif cell == '':
2231 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2231 message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
2232 if self.find_line_magic(magic_name) is not None:
2232 if self.find_line_magic(magic_name) is not None:
2233 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2233 message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
2234 raise UsageError(message)
2234 raise UsageError(message)
2235 else:
2235 else:
2236 # Note: this is the distance in the stack to the user's frame.
2236 # Note: this is the distance in the stack to the user's frame.
2237 # This will need to be updated if the internal calling logic gets
2237 # This will need to be updated if the internal calling logic gets
2238 # refactored, or else we'll be expanding the wrong variables.
2238 # refactored, or else we'll be expanding the wrong variables.
2239 stack_depth = 2
2239 stack_depth = 2
2240 magic_arg_s = self.var_expand(line, stack_depth)
2240 magic_arg_s = self.var_expand(line, stack_depth)
2241 with self.builtin_trap:
2241 with self.builtin_trap:
2242 result = fn(magic_arg_s, cell)
2242 result = fn(magic_arg_s, cell)
2243 return result
2243 return result
2244
2244
2245 def find_line_magic(self, magic_name):
2245 def find_line_magic(self, magic_name):
2246 """Find and return a line magic by name.
2246 """Find and return a line magic by name.
2247
2247
2248 Returns None if the magic isn't found."""
2248 Returns None if the magic isn't found."""
2249 return self.magics_manager.magics['line'].get(magic_name)
2249 return self.magics_manager.magics['line'].get(magic_name)
2250
2250
2251 def find_cell_magic(self, magic_name):
2251 def find_cell_magic(self, magic_name):
2252 """Find and return a cell magic by name.
2252 """Find and return a cell magic by name.
2253
2253
2254 Returns None if the magic isn't found."""
2254 Returns None if the magic isn't found."""
2255 return self.magics_manager.magics['cell'].get(magic_name)
2255 return self.magics_manager.magics['cell'].get(magic_name)
2256
2256
2257 def find_magic(self, magic_name, magic_kind='line'):
2257 def find_magic(self, magic_name, magic_kind='line'):
2258 """Find and return a magic of the given type by name.
2258 """Find and return a magic of the given type by name.
2259
2259
2260 Returns None if the magic isn't found."""
2260 Returns None if the magic isn't found."""
2261 return self.magics_manager.magics[magic_kind].get(magic_name)
2261 return self.magics_manager.magics[magic_kind].get(magic_name)
2262
2262
2263 def magic(self, arg_s):
2263 def magic(self, arg_s):
2264 """DEPRECATED. Use run_line_magic() instead.
2264 """DEPRECATED. Use run_line_magic() instead.
2265
2265
2266 Call a magic function by name.
2266 Call a magic function by name.
2267
2267
2268 Input: a string containing the name of the magic function to call and
2268 Input: a string containing the name of the magic function to call and
2269 any additional arguments to be passed to the magic.
2269 any additional arguments to be passed to the magic.
2270
2270
2271 magic('name -opt foo bar') is equivalent to typing at the ipython
2271 magic('name -opt foo bar') is equivalent to typing at the ipython
2272 prompt:
2272 prompt:
2273
2273
2274 In[1]: %name -opt foo bar
2274 In[1]: %name -opt foo bar
2275
2275
2276 To call a magic without arguments, simply use magic('name').
2276 To call a magic without arguments, simply use magic('name').
2277
2277
2278 This provides a proper Python function to call IPython's magics in any
2278 This provides a proper Python function to call IPython's magics in any
2279 valid Python code you can type at the interpreter, including loops and
2279 valid Python code you can type at the interpreter, including loops and
2280 compound statements.
2280 compound statements.
2281 """
2281 """
2282 # TODO: should we issue a loud deprecation warning here?
2282 # TODO: should we issue a loud deprecation warning here?
2283 magic_name, _, magic_arg_s = arg_s.partition(' ')
2283 magic_name, _, magic_arg_s = arg_s.partition(' ')
2284 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2284 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
2285 return self.run_line_magic(magic_name, magic_arg_s)
2285 return self.run_line_magic(magic_name, magic_arg_s)
2286
2286
2287 #-------------------------------------------------------------------------
2287 #-------------------------------------------------------------------------
2288 # Things related to macros
2288 # Things related to macros
2289 #-------------------------------------------------------------------------
2289 #-------------------------------------------------------------------------
2290
2290
2291 def define_macro(self, name, themacro):
2291 def define_macro(self, name, themacro):
2292 """Define a new macro
2292 """Define a new macro
2293
2293
2294 Parameters
2294 Parameters
2295 ----------
2295 ----------
2296 name : str
2296 name : str
2297 The name of the macro.
2297 The name of the macro.
2298 themacro : str or Macro
2298 themacro : str or Macro
2299 The action to do upon invoking the macro. If a string, a new
2299 The action to do upon invoking the macro. If a string, a new
2300 Macro object is created by passing the string to it.
2300 Macro object is created by passing the string to it.
2301 """
2301 """
2302
2302
2303 from IPython.core import macro
2303 from IPython.core import macro
2304
2304
2305 if isinstance(themacro, string_types):
2305 if isinstance(themacro, string_types):
2306 themacro = macro.Macro(themacro)
2306 themacro = macro.Macro(themacro)
2307 if not isinstance(themacro, macro.Macro):
2307 if not isinstance(themacro, macro.Macro):
2308 raise ValueError('A macro must be a string or a Macro instance.')
2308 raise ValueError('A macro must be a string or a Macro instance.')
2309 self.user_ns[name] = themacro
2309 self.user_ns[name] = themacro
2310
2310
2311 #-------------------------------------------------------------------------
2311 #-------------------------------------------------------------------------
2312 # Things related to the running of system commands
2312 # Things related to the running of system commands
2313 #-------------------------------------------------------------------------
2313 #-------------------------------------------------------------------------
2314
2314
2315 def system_piped(self, cmd):
2315 def system_piped(self, cmd):
2316 """Call the given cmd in a subprocess, piping stdout/err
2316 """Call the given cmd in a subprocess, piping stdout/err
2317
2317
2318 Parameters
2318 Parameters
2319 ----------
2319 ----------
2320 cmd : str
2320 cmd : str
2321 Command to execute (can not end in '&', as background processes are
2321 Command to execute (can not end in '&', as background processes are
2322 not supported. Should not be a command that expects input
2322 not supported. Should not be a command that expects input
2323 other than simple text.
2323 other than simple text.
2324 """
2324 """
2325 if cmd.rstrip().endswith('&'):
2325 if cmd.rstrip().endswith('&'):
2326 # this is *far* from a rigorous test
2326 # this is *far* from a rigorous test
2327 # We do not support backgrounding processes because we either use
2327 # We do not support backgrounding processes because we either use
2328 # pexpect or pipes to read from. Users can always just call
2328 # pexpect or pipes to read from. Users can always just call
2329 # os.system() or use ip.system=ip.system_raw
2329 # os.system() or use ip.system=ip.system_raw
2330 # if they really want a background process.
2330 # if they really want a background process.
2331 raise OSError("Background processes not supported.")
2331 raise OSError("Background processes not supported.")
2332
2332
2333 # we explicitly do NOT return the subprocess status code, because
2333 # we explicitly do NOT return the subprocess status code, because
2334 # a non-None value would trigger :func:`sys.displayhook` calls.
2334 # a non-None value would trigger :func:`sys.displayhook` calls.
2335 # Instead, we store the exit_code in user_ns.
2335 # Instead, we store the exit_code in user_ns.
2336 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2336 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
2337
2337
2338 def system_raw(self, cmd):
2338 def system_raw(self, cmd):
2339 """Call the given cmd in a subprocess using os.system on Windows or
2339 """Call the given cmd in a subprocess using os.system on Windows or
2340 subprocess.call using the system shell on other platforms.
2340 subprocess.call using the system shell on other platforms.
2341
2341
2342 Parameters
2342 Parameters
2343 ----------
2343 ----------
2344 cmd : str
2344 cmd : str
2345 Command to execute.
2345 Command to execute.
2346 """
2346 """
2347 cmd = self.var_expand(cmd, depth=1)
2347 cmd = self.var_expand(cmd, depth=1)
2348 # protect os.system from UNC paths on Windows, which it can't handle:
2348 # protect os.system from UNC paths on Windows, which it can't handle:
2349 if sys.platform == 'win32':
2349 if sys.platform == 'win32':
2350 from IPython.utils._process_win32 import AvoidUNCPath
2350 from IPython.utils._process_win32 import AvoidUNCPath
2351 with AvoidUNCPath() as path:
2351 with AvoidUNCPath() as path:
2352 if path is not None:
2352 if path is not None:
2353 cmd = '"pushd %s &&"%s' % (path, cmd)
2353 cmd = '"pushd %s &&"%s' % (path, cmd)
2354 cmd = py3compat.unicode_to_str(cmd)
2354 cmd = py3compat.unicode_to_str(cmd)
2355 try:
2355 try:
2356 ec = os.system(cmd)
2356 ec = os.system(cmd)
2357 except KeyboardInterrupt:
2357 except KeyboardInterrupt:
2358 self.write_err("\nKeyboardInterrupt\n")
2358 self.write_err("\nKeyboardInterrupt\n")
2359 ec = -2
2359 ec = -2
2360 else:
2360 else:
2361 cmd = py3compat.unicode_to_str(cmd)
2361 cmd = py3compat.unicode_to_str(cmd)
2362 # For posix the result of the subprocess.call() below is an exit
2362 # For posix the result of the subprocess.call() below is an exit
2363 # code, which by convention is zero for success, positive for
2363 # code, which by convention is zero for success, positive for
2364 # program failure. Exit codes above 128 are reserved for signals,
2364 # program failure. Exit codes above 128 are reserved for signals,
2365 # and the formula for converting a signal to an exit code is usually
2365 # and the formula for converting a signal to an exit code is usually
2366 # signal_number+128. To more easily differentiate between exit
2366 # signal_number+128. To more easily differentiate between exit
2367 # codes and signals, ipython uses negative numbers. For instance
2367 # codes and signals, ipython uses negative numbers. For instance
2368 # since control-c is signal 2 but exit code 130, ipython's
2368 # since control-c is signal 2 but exit code 130, ipython's
2369 # _exit_code variable will read -2. Note that some shells like
2369 # _exit_code variable will read -2. Note that some shells like
2370 # csh and fish don't follow sh/bash conventions for exit codes.
2370 # csh and fish don't follow sh/bash conventions for exit codes.
2371 executable = os.environ.get('SHELL', None)
2371 executable = os.environ.get('SHELL', None)
2372 try:
2372 try:
2373 # Use env shell instead of default /bin/sh
2373 # Use env shell instead of default /bin/sh
2374 ec = subprocess.call(cmd, shell=True, executable=executable)
2374 ec = subprocess.call(cmd, shell=True, executable=executable)
2375 except KeyboardInterrupt:
2375 except KeyboardInterrupt:
2376 # intercept control-C; a long traceback is not useful here
2376 # intercept control-C; a long traceback is not useful here
2377 self.write_err("\nKeyboardInterrupt\n")
2377 self.write_err("\nKeyboardInterrupt\n")
2378 ec = 130
2378 ec = 130
2379 if ec > 128:
2379 if ec > 128:
2380 ec = -(ec - 128)
2380 ec = -(ec - 128)
2381
2381
2382 # We explicitly do NOT return the subprocess status code, because
2382 # We explicitly do NOT return the subprocess status code, because
2383 # a non-None value would trigger :func:`sys.displayhook` calls.
2383 # a non-None value would trigger :func:`sys.displayhook` calls.
2384 # Instead, we store the exit_code in user_ns. Note the semantics
2384 # Instead, we store the exit_code in user_ns. Note the semantics
2385 # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
2385 # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
2386 # but raising SystemExit(_exit_code) will give status 254!
2386 # but raising SystemExit(_exit_code) will give status 254!
2387 self.user_ns['_exit_code'] = ec
2387 self.user_ns['_exit_code'] = ec
2388
2388
2389 # use piped system by default, because it is better behaved
2389 # use piped system by default, because it is better behaved
2390 system = system_piped
2390 system = system_piped
2391
2391
2392 def getoutput(self, cmd, split=True, depth=0):
2392 def getoutput(self, cmd, split=True, depth=0):
2393 """Get output (possibly including stderr) from a subprocess.
2393 """Get output (possibly including stderr) from a subprocess.
2394
2394
2395 Parameters
2395 Parameters
2396 ----------
2396 ----------
2397 cmd : str
2397 cmd : str
2398 Command to execute (can not end in '&', as background processes are
2398 Command to execute (can not end in '&', as background processes are
2399 not supported.
2399 not supported.
2400 split : bool, optional
2400 split : bool, optional
2401 If True, split the output into an IPython SList. Otherwise, an
2401 If True, split the output into an IPython SList. Otherwise, an
2402 IPython LSString is returned. These are objects similar to normal
2402 IPython LSString is returned. These are objects similar to normal
2403 lists and strings, with a few convenience attributes for easier
2403 lists and strings, with a few convenience attributes for easier
2404 manipulation of line-based output. You can use '?' on them for
2404 manipulation of line-based output. You can use '?' on them for
2405 details.
2405 details.
2406 depth : int, optional
2406 depth : int, optional
2407 How many frames above the caller are the local variables which should
2407 How many frames above the caller are the local variables which should
2408 be expanded in the command string? The default (0) assumes that the
2408 be expanded in the command string? The default (0) assumes that the
2409 expansion variables are in the stack frame calling this function.
2409 expansion variables are in the stack frame calling this function.
2410 """
2410 """
2411 if cmd.rstrip().endswith('&'):
2411 if cmd.rstrip().endswith('&'):
2412 # this is *far* from a rigorous test
2412 # this is *far* from a rigorous test
2413 raise OSError("Background processes not supported.")
2413 raise OSError("Background processes not supported.")
2414 out = getoutput(self.var_expand(cmd, depth=depth+1))
2414 out = getoutput(self.var_expand(cmd, depth=depth+1))
2415 if split:
2415 if split:
2416 out = SList(out.splitlines())
2416 out = SList(out.splitlines())
2417 else:
2417 else:
2418 out = LSString(out)
2418 out = LSString(out)
2419 return out
2419 return out
2420
2420
2421 #-------------------------------------------------------------------------
2421 #-------------------------------------------------------------------------
2422 # Things related to aliases
2422 # Things related to aliases
2423 #-------------------------------------------------------------------------
2423 #-------------------------------------------------------------------------
2424
2424
2425 def init_alias(self):
2425 def init_alias(self):
2426 self.alias_manager = AliasManager(shell=self, parent=self)
2426 self.alias_manager = AliasManager(shell=self, parent=self)
2427 self.configurables.append(self.alias_manager)
2427 self.configurables.append(self.alias_manager)
2428
2428
2429 #-------------------------------------------------------------------------
2429 #-------------------------------------------------------------------------
2430 # Things related to extensions
2430 # Things related to extensions
2431 #-------------------------------------------------------------------------
2431 #-------------------------------------------------------------------------
2432
2432
2433 def init_extension_manager(self):
2433 def init_extension_manager(self):
2434 self.extension_manager = ExtensionManager(shell=self, parent=self)
2434 self.extension_manager = ExtensionManager(shell=self, parent=self)
2435 self.configurables.append(self.extension_manager)
2435 self.configurables.append(self.extension_manager)
2436
2436
2437 #-------------------------------------------------------------------------
2437 #-------------------------------------------------------------------------
2438 # Things related to payloads
2438 # Things related to payloads
2439 #-------------------------------------------------------------------------
2439 #-------------------------------------------------------------------------
2440
2440
2441 def init_payload(self):
2441 def init_payload(self):
2442 self.payload_manager = PayloadManager(parent=self)
2442 self.payload_manager = PayloadManager(parent=self)
2443 self.configurables.append(self.payload_manager)
2443 self.configurables.append(self.payload_manager)
2444
2444
2445 #-------------------------------------------------------------------------
2445 #-------------------------------------------------------------------------
2446 # Things related to the prefilter
2446 # Things related to the prefilter
2447 #-------------------------------------------------------------------------
2447 #-------------------------------------------------------------------------
2448
2448
2449 def init_prefilter(self):
2449 def init_prefilter(self):
2450 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2450 self.prefilter_manager = PrefilterManager(shell=self, parent=self)
2451 self.configurables.append(self.prefilter_manager)
2451 self.configurables.append(self.prefilter_manager)
2452 # Ultimately this will be refactored in the new interpreter code, but
2452 # Ultimately this will be refactored in the new interpreter code, but
2453 # for now, we should expose the main prefilter method (there's legacy
2453 # for now, we should expose the main prefilter method (there's legacy
2454 # code out there that may rely on this).
2454 # code out there that may rely on this).
2455 self.prefilter = self.prefilter_manager.prefilter_lines
2455 self.prefilter = self.prefilter_manager.prefilter_lines
2456
2456
2457 def auto_rewrite_input(self, cmd):
2457 def auto_rewrite_input(self, cmd):
2458 """Print to the screen the rewritten form of the user's command.
2458 """Print to the screen the rewritten form of the user's command.
2459
2459
2460 This shows visual feedback by rewriting input lines that cause
2460 This shows visual feedback by rewriting input lines that cause
2461 automatic calling to kick in, like::
2461 automatic calling to kick in, like::
2462
2462
2463 /f x
2463 /f x
2464
2464
2465 into::
2465 into::
2466
2466
2467 ------> f(x)
2467 ------> f(x)
2468
2468
2469 after the user's input prompt. This helps the user understand that the
2469 after the user's input prompt. This helps the user understand that the
2470 input line was transformed automatically by IPython.
2470 input line was transformed automatically by IPython.
2471 """
2471 """
2472 if not self.show_rewritten_input:
2472 if not self.show_rewritten_input:
2473 return
2473 return
2474
2474
2475 rw = self.prompt_manager.render('rewrite') + cmd
2475 rw = self.prompt_manager.render('rewrite') + cmd
2476
2476
2477 try:
2477 try:
2478 # plain ascii works better w/ pyreadline, on some machines, so
2478 # plain ascii works better w/ pyreadline, on some machines, so
2479 # we use it and only print uncolored rewrite if we have unicode
2479 # we use it and only print uncolored rewrite if we have unicode
2480 rw = str(rw)
2480 rw = str(rw)
2481 print(rw, file=io.stdout)
2481 print(rw, file=io.stdout)
2482 except UnicodeEncodeError:
2482 except UnicodeEncodeError:
2483 print("------> " + cmd)
2483 print("------> " + cmd)
2484
2484
2485 #-------------------------------------------------------------------------
2485 #-------------------------------------------------------------------------
2486 # Things related to extracting values/expressions from kernel and user_ns
2486 # Things related to extracting values/expressions from kernel and user_ns
2487 #-------------------------------------------------------------------------
2487 #-------------------------------------------------------------------------
2488
2488
2489 def _user_obj_error(self):
2489 def _user_obj_error(self):
2490 """return simple exception dict
2490 """return simple exception dict
2491
2491
2492 for use in user_expressions
2492 for use in user_expressions
2493 """
2493 """
2494
2494
2495 etype, evalue, tb = self._get_exc_info()
2495 etype, evalue, tb = self._get_exc_info()
2496 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2496 stb = self.InteractiveTB.get_exception_only(etype, evalue)
2497
2497
2498 exc_info = {
2498 exc_info = {
2499 u'status' : 'error',
2499 u'status' : 'error',
2500 u'traceback' : stb,
2500 u'traceback' : stb,
2501 u'ename' : unicode_type(etype.__name__),
2501 u'ename' : unicode_type(etype.__name__),
2502 u'evalue' : py3compat.safe_unicode(evalue),
2502 u'evalue' : py3compat.safe_unicode(evalue),
2503 }
2503 }
2504
2504
2505 return exc_info
2505 return exc_info
2506
2506
2507 def _format_user_obj(self, obj):
2507 def _format_user_obj(self, obj):
2508 """format a user object to display dict
2508 """format a user object to display dict
2509
2509
2510 for use in user_expressions
2510 for use in user_expressions
2511 """
2511 """
2512
2512
2513 data, md = self.display_formatter.format(obj)
2513 data, md = self.display_formatter.format(obj)
2514 value = {
2514 value = {
2515 'status' : 'ok',
2515 'status' : 'ok',
2516 'data' : data,
2516 'data' : data,
2517 'metadata' : md,
2517 'metadata' : md,
2518 }
2518 }
2519 return value
2519 return value
2520
2520
2521 def user_expressions(self, expressions):
2521 def user_expressions(self, expressions):
2522 """Evaluate a dict of expressions in the user's namespace.
2522 """Evaluate a dict of expressions in the user's namespace.
2523
2523
2524 Parameters
2524 Parameters
2525 ----------
2525 ----------
2526 expressions : dict
2526 expressions : dict
2527 A dict with string keys and string values. The expression values
2527 A dict with string keys and string values. The expression values
2528 should be valid Python expressions, each of which will be evaluated
2528 should be valid Python expressions, each of which will be evaluated
2529 in the user namespace.
2529 in the user namespace.
2530
2530
2531 Returns
2531 Returns
2532 -------
2532 -------
2533 A dict, keyed like the input expressions dict, with the rich mime-typed
2533 A dict, keyed like the input expressions dict, with the rich mime-typed
2534 display_data of each value.
2534 display_data of each value.
2535 """
2535 """
2536 out = {}
2536 out = {}
2537 user_ns = self.user_ns
2537 user_ns = self.user_ns
2538 global_ns = self.user_global_ns
2538 global_ns = self.user_global_ns
2539
2539
2540 for key, expr in iteritems(expressions):
2540 for key, expr in iteritems(expressions):
2541 try:
2541 try:
2542 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2542 value = self._format_user_obj(eval(expr, global_ns, user_ns))
2543 except:
2543 except:
2544 value = self._user_obj_error()
2544 value = self._user_obj_error()
2545 out[key] = value
2545 out[key] = value
2546 return out
2546 return out
2547
2547
2548 #-------------------------------------------------------------------------
2548 #-------------------------------------------------------------------------
2549 # Things related to the running of code
2549 # Things related to the running of code
2550 #-------------------------------------------------------------------------
2550 #-------------------------------------------------------------------------
2551
2551
2552 def ex(self, cmd):
2552 def ex(self, cmd):
2553 """Execute a normal python statement in user namespace."""
2553 """Execute a normal python statement in user namespace."""
2554 with self.builtin_trap:
2554 with self.builtin_trap:
2555 exec(cmd, self.user_global_ns, self.user_ns)
2555 exec(cmd, self.user_global_ns, self.user_ns)
2556
2556
2557 def ev(self, expr):
2557 def ev(self, expr):
2558 """Evaluate python expression expr in user namespace.
2558 """Evaluate python expression expr in user namespace.
2559
2559
2560 Returns the result of evaluation
2560 Returns the result of evaluation
2561 """
2561 """
2562 with self.builtin_trap:
2562 with self.builtin_trap:
2563 return eval(expr, self.user_global_ns, self.user_ns)
2563 return eval(expr, self.user_global_ns, self.user_ns)
2564
2564
2565 def safe_execfile(self, fname, *where, **kw):
2565 def safe_execfile(self, fname, *where, **kw):
2566 """A safe version of the builtin execfile().
2566 """A safe version of the builtin execfile().
2567
2567
2568 This version will never throw an exception, but instead print
2568 This version will never throw an exception, but instead print
2569 helpful error messages to the screen. This only works on pure
2569 helpful error messages to the screen. This only works on pure
2570 Python files with the .py extension.
2570 Python files with the .py extension.
2571
2571
2572 Parameters
2572 Parameters
2573 ----------
2573 ----------
2574 fname : string
2574 fname : string
2575 The name of the file to be executed.
2575 The name of the file to be executed.
2576 where : tuple
2576 where : tuple
2577 One or two namespaces, passed to execfile() as (globals,locals).
2577 One or two namespaces, passed to execfile() as (globals,locals).
2578 If only one is given, it is passed as both.
2578 If only one is given, it is passed as both.
2579 exit_ignore : bool (False)
2579 exit_ignore : bool (False)
2580 If True, then silence SystemExit for non-zero status (it is always
2580 If True, then silence SystemExit for non-zero status (it is always
2581 silenced for zero status, as it is so common).
2581 silenced for zero status, as it is so common).
2582 raise_exceptions : bool (False)
2582 raise_exceptions : bool (False)
2583 If True raise exceptions everywhere. Meant for testing.
2583 If True raise exceptions everywhere. Meant for testing.
2584 shell_futures : bool (False)
2584 shell_futures : bool (False)
2585 If True, the code will share future statements with the interactive
2585 If True, the code will share future statements with the interactive
2586 shell. It will both be affected by previous __future__ imports, and
2586 shell. It will both be affected by previous __future__ imports, and
2587 any __future__ imports in the code will affect the shell. If False,
2587 any __future__ imports in the code will affect the shell. If False,
2588 __future__ imports are not shared in either direction.
2588 __future__ imports are not shared in either direction.
2589
2589
2590 """
2590 """
2591 kw.setdefault('exit_ignore', False)
2591 kw.setdefault('exit_ignore', False)
2592 kw.setdefault('raise_exceptions', False)
2592 kw.setdefault('raise_exceptions', False)
2593 kw.setdefault('shell_futures', False)
2593 kw.setdefault('shell_futures', False)
2594
2594
2595 fname = os.path.abspath(os.path.expanduser(fname))
2595 fname = os.path.abspath(os.path.expanduser(fname))
2596
2596
2597 # Make sure we can open the file
2597 # Make sure we can open the file
2598 try:
2598 try:
2599 with open(fname) as thefile:
2599 with open(fname) as thefile:
2600 pass
2600 pass
2601 except:
2601 except:
2602 warn('Could not open file <%s> for safe execution.' % fname)
2602 warn('Could not open file <%s> for safe execution.' % fname)
2603 return
2603 return
2604
2604
2605 # Find things also in current directory. This is needed to mimic the
2605 # Find things also in current directory. This is needed to mimic the
2606 # behavior of running a script from the system command line, where
2606 # behavior of running a script from the system command line, where
2607 # Python inserts the script's directory into sys.path
2607 # Python inserts the script's directory into sys.path
2608 dname = os.path.dirname(fname)
2608 dname = os.path.dirname(fname)
2609
2609
2610 with prepended_to_syspath(dname):
2610 with prepended_to_syspath(dname):
2611 try:
2611 try:
2612 glob, loc = (where + (None, ))[:2]
2612 glob, loc = (where + (None, ))[:2]
2613 py3compat.execfile(
2613 py3compat.execfile(
2614 fname, glob, loc,
2614 fname, glob, loc,
2615 self.compile if kw['shell_futures'] else None)
2615 self.compile if kw['shell_futures'] else None)
2616 except SystemExit as status:
2616 except SystemExit as status:
2617 # If the call was made with 0 or None exit status (sys.exit(0)
2617 # If the call was made with 0 or None exit status (sys.exit(0)
2618 # or sys.exit() ), don't bother showing a traceback, as both of
2618 # or sys.exit() ), don't bother showing a traceback, as both of
2619 # these are considered normal by the OS:
2619 # these are considered normal by the OS:
2620 # > python -c'import sys;sys.exit(0)'; echo $?
2620 # > python -c'import sys;sys.exit(0)'; echo $?
2621 # 0
2621 # 0
2622 # > python -c'import sys;sys.exit()'; echo $?
2622 # > python -c'import sys;sys.exit()'; echo $?
2623 # 0
2623 # 0
2624 # For other exit status, we show the exception unless
2624 # For other exit status, we show the exception unless
2625 # explicitly silenced, but only in short form.
2625 # explicitly silenced, but only in short form.
2626 if kw['raise_exceptions']:
2626 if kw['raise_exceptions']:
2627 raise
2627 raise
2628 if status.code and not kw['exit_ignore']:
2628 if status.code and not kw['exit_ignore']:
2629 self.showtraceback(exception_only=True)
2629 self.showtraceback(exception_only=True)
2630 except:
2630 except:
2631 if kw['raise_exceptions']:
2631 if kw['raise_exceptions']:
2632 raise
2632 raise
2633 # tb offset is 2 because we wrap execfile
2633 # tb offset is 2 because we wrap execfile
2634 self.showtraceback(tb_offset=2)
2634 self.showtraceback(tb_offset=2)
2635
2635
2636 def safe_execfile_ipy(self, fname, shell_futures=False):
2636 def safe_execfile_ipy(self, fname, shell_futures=False):
2637 """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
2637 """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
2638
2638
2639 Parameters
2639 Parameters
2640 ----------
2640 ----------
2641 fname : str
2641 fname : str
2642 The name of the file to execute. The filename must have a
2642 The name of the file to execute. The filename must have a
2643 .ipy or .ipynb extension.
2643 .ipy or .ipynb extension.
2644 shell_futures : bool (False)
2644 shell_futures : bool (False)
2645 If True, the code will share future statements with the interactive
2645 If True, the code will share future statements with the interactive
2646 shell. It will both be affected by previous __future__ imports, and
2646 shell. It will both be affected by previous __future__ imports, and
2647 any __future__ imports in the code will affect the shell. If False,
2647 any __future__ imports in the code will affect the shell. If False,
2648 __future__ imports are not shared in either direction.
2648 __future__ imports are not shared in either direction.
2649 """
2649 """
2650 fname = os.path.abspath(os.path.expanduser(fname))
2650 fname = os.path.abspath(os.path.expanduser(fname))
2651
2651
2652 # Make sure we can open the file
2652 # Make sure we can open the file
2653 try:
2653 try:
2654 with open(fname) as thefile:
2654 with open(fname) as thefile:
2655 pass
2655 pass
2656 except:
2656 except:
2657 warn('Could not open file <%s> for safe execution.' % fname)
2657 warn('Could not open file <%s> for safe execution.' % fname)
2658 return
2658 return
2659
2659
2660 # Find things also in current directory. This is needed to mimic the
2660 # Find things also in current directory. This is needed to mimic the
2661 # behavior of running a script from the system command line, where
2661 # behavior of running a script from the system command line, where
2662 # Python inserts the script's directory into sys.path
2662 # Python inserts the script's directory into sys.path
2663 dname = os.path.dirname(fname)
2663 dname = os.path.dirname(fname)
2664
2664
2665 def get_cells():
2665 def get_cells():
2666 """generator for sequence of code blocks to run"""
2666 """generator for sequence of code blocks to run"""
2667 if fname.endswith('.ipynb'):
2667 if fname.endswith('.ipynb'):
2668 from IPython.nbformat import read
2668 from IPython.nbformat import read
2669 with io_open(fname) as f:
2669 with io_open(fname) as f:
2670 nb = read(f, as_version=4)
2670 nb = read(f, as_version=4)
2671 if not nb.cells:
2671 if not nb.cells:
2672 return
2672 return
2673 for cell in nb.cells:
2673 for cell in nb.cells:
2674 if cell.cell_type == 'code':
2674 if cell.cell_type == 'code':
2675 yield cell.source
2675 yield cell.source
2676 else:
2676 else:
2677 with open(fname) as f:
2677 with open(fname) as f:
2678 yield f.read()
2678 yield f.read()
2679
2679
2680 with prepended_to_syspath(dname):
2680 with prepended_to_syspath(dname):
2681 try:
2681 try:
2682 for cell in get_cells():
2682 for cell in get_cells():
2683 # self.run_cell currently captures all exceptions
2683 # self.run_cell currently captures all exceptions
2684 # raised in user code. It would be nice if there were
2684 # raised in user code. It would be nice if there were
2685 # versions of run_cell that did raise, so
2685 # versions of run_cell that did raise, so
2686 # we could catch the errors.
2686 # we could catch the errors.
2687 self.run_cell(cell, silent=True, shell_futures=shell_futures)
2687 self.run_cell(cell, silent=True, shell_futures=shell_futures)
2688 except:
2688 except:
2689 self.showtraceback()
2689 self.showtraceback()
2690 warn('Unknown failure executing file: <%s>' % fname)
2690 warn('Unknown failure executing file: <%s>' % fname)
2691
2691
2692 def safe_run_module(self, mod_name, where):
2692 def safe_run_module(self, mod_name, where):
2693 """A safe version of runpy.run_module().
2693 """A safe version of runpy.run_module().
2694
2694
2695 This version will never throw an exception, but instead print
2695 This version will never throw an exception, but instead print
2696 helpful error messages to the screen.
2696 helpful error messages to the screen.
2697
2697
2698 `SystemExit` exceptions with status code 0 or None are ignored.
2698 `SystemExit` exceptions with status code 0 or None are ignored.
2699
2699
2700 Parameters
2700 Parameters
2701 ----------
2701 ----------
2702 mod_name : string
2702 mod_name : string
2703 The name of the module to be executed.
2703 The name of the module to be executed.
2704 where : dict
2704 where : dict
2705 The globals namespace.
2705 The globals namespace.
2706 """
2706 """
2707 try:
2707 try:
2708 try:
2708 try:
2709 where.update(
2709 where.update(
2710 runpy.run_module(str(mod_name), run_name="__main__",
2710 runpy.run_module(str(mod_name), run_name="__main__",
2711 alter_sys=True)
2711 alter_sys=True)
2712 )
2712 )
2713 except SystemExit as status:
2713 except SystemExit as status:
2714 if status.code:
2714 if status.code:
2715 raise
2715 raise
2716 except:
2716 except:
2717 self.showtraceback()
2717 self.showtraceback()
2718 warn('Unknown failure executing module: <%s>' % mod_name)
2718 warn('Unknown failure executing module: <%s>' % mod_name)
2719
2719
2720 def _run_cached_cell_magic(self, magic_name, line):
2720 def _run_cached_cell_magic(self, magic_name, line):
2721 """Special method to call a cell magic with the data stored in self.
2721 """Special method to call a cell magic with the data stored in self.
2722 """
2722 """
2723 cell = self._current_cell_magic_body
2723 cell = self._current_cell_magic_body
2724 self._current_cell_magic_body = None
2724 self._current_cell_magic_body = None
2725 return self.run_cell_magic(magic_name, line, cell)
2725 return self.run_cell_magic(magic_name, line, cell)
2726
2726
2727 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2727 def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True):
2728 """Run a complete IPython cell.
2728 """Run a complete IPython cell.
2729
2729
2730 Parameters
2730 Parameters
2731 ----------
2731 ----------
2732 raw_cell : str
2732 raw_cell : str
2733 The code (including IPython code such as %magic functions) to run.
2733 The code (including IPython code such as %magic functions) to run.
2734 store_history : bool
2734 store_history : bool
2735 If True, the raw and translated cell will be stored in IPython's
2735 If True, the raw and translated cell will be stored in IPython's
2736 history. For user code calling back into IPython's machinery, this
2736 history. For user code calling back into IPython's machinery, this
2737 should be set to False.
2737 should be set to False.
2738 silent : bool
2738 silent : bool
2739 If True, avoid side-effects, such as implicit displayhooks and
2739 If True, avoid side-effects, such as implicit displayhooks and
2740 and logging. silent=True forces store_history=False.
2740 and logging. silent=True forces store_history=False.
2741 shell_futures : bool
2741 shell_futures : bool
2742 If True, the code will share future statements with the interactive
2742 If True, the code will share future statements with the interactive
2743 shell. It will both be affected by previous __future__ imports, and
2743 shell. It will both be affected by previous __future__ imports, and
2744 any __future__ imports in the code will affect the shell. If False,
2744 any __future__ imports in the code will affect the shell. If False,
2745 __future__ imports are not shared in either direction.
2745 __future__ imports are not shared in either direction.
2746 """
2746 """
2747 if (not raw_cell) or raw_cell.isspace():
2747 if (not raw_cell) or raw_cell.isspace():
2748 return
2748 return
2749
2749
2750 if silent:
2750 if silent:
2751 store_history = False
2751 store_history = False
2752
2752
2753 self.events.trigger('pre_execute')
2753 self.events.trigger('pre_execute')
2754 if not silent:
2754 if not silent:
2755 self.events.trigger('pre_run_cell')
2755 self.events.trigger('pre_run_cell')
2756
2756
2757 # If any of our input transformation (input_transformer_manager or
2757 # If any of our input transformation (input_transformer_manager or
2758 # prefilter_manager) raises an exception, we store it in this variable
2758 # prefilter_manager) raises an exception, we store it in this variable
2759 # so that we can display the error after logging the input and storing
2759 # so that we can display the error after logging the input and storing
2760 # it in the history.
2760 # it in the history.
2761 preprocessing_exc_tuple = None
2761 preprocessing_exc_tuple = None
2762 try:
2762 try:
2763 # Static input transformations
2763 # Static input transformations
2764 cell = self.input_transformer_manager.transform_cell(raw_cell)
2764 cell = self.input_transformer_manager.transform_cell(raw_cell)
2765 except SyntaxError:
2765 except SyntaxError:
2766 preprocessing_exc_tuple = sys.exc_info()
2766 preprocessing_exc_tuple = sys.exc_info()
2767 cell = raw_cell # cell has to exist so it can be stored/logged
2767 cell = raw_cell # cell has to exist so it can be stored/logged
2768 else:
2768 else:
2769 if len(cell.splitlines()) == 1:
2769 if len(cell.splitlines()) == 1:
2770 # Dynamic transformations - only applied for single line commands
2770 # Dynamic transformations - only applied for single line commands
2771 with self.builtin_trap:
2771 with self.builtin_trap:
2772 try:
2772 try:
2773 # use prefilter_lines to handle trailing newlines
2773 # use prefilter_lines to handle trailing newlines
2774 # restore trailing newline for ast.parse
2774 # restore trailing newline for ast.parse
2775 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2775 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2776 except Exception:
2776 except Exception:
2777 # don't allow prefilter errors to crash IPython
2777 # don't allow prefilter errors to crash IPython
2778 preprocessing_exc_tuple = sys.exc_info()
2778 preprocessing_exc_tuple = sys.exc_info()
2779
2779
2780 # Store raw and processed history
2780 # Store raw and processed history
2781 if store_history:
2781 if store_history:
2782 self.history_manager.store_inputs(self.execution_count,
2782 self.history_manager.store_inputs(self.execution_count,
2783 cell, raw_cell)
2783 cell, raw_cell)
2784 if not silent:
2784 if not silent:
2785 self.logger.log(cell, raw_cell)
2785 self.logger.log(cell, raw_cell)
2786
2786
2787 # Display the exception if input processing failed.
2787 # Display the exception if input processing failed.
2788 if preprocessing_exc_tuple is not None:
2788 if preprocessing_exc_tuple is not None:
2789 self.showtraceback(preprocessing_exc_tuple)
2789 self.showtraceback(preprocessing_exc_tuple)
2790 if store_history:
2790 if store_history:
2791 self.execution_count += 1
2791 self.execution_count += 1
2792 return
2792 return
2793
2793
2794 # Our own compiler remembers the __future__ environment. If we want to
2794 # Our own compiler remembers the __future__ environment. If we want to
2795 # run code with a separate __future__ environment, use the default
2795 # run code with a separate __future__ environment, use the default
2796 # compiler
2796 # compiler
2797 compiler = self.compile if shell_futures else CachingCompiler()
2797 compiler = self.compile if shell_futures else CachingCompiler()
2798
2798
2799 with self.builtin_trap:
2799 with self.builtin_trap:
2800 cell_name = self.compile.cache(cell, self.execution_count)
2800 cell_name = self.compile.cache(cell, self.execution_count)
2801
2801
2802 with self.display_trap:
2802 with self.display_trap:
2803 # Compile to bytecode
2803 # Compile to bytecode
2804 try:
2804 try:
2805 code_ast = compiler.ast_parse(cell, filename=cell_name)
2805 code_ast = compiler.ast_parse(cell, filename=cell_name)
2806 except IndentationError:
2806 except IndentationError:
2807 self.showindentationerror()
2807 self.showindentationerror()
2808 if store_history:
2808 if store_history:
2809 self.execution_count += 1
2809 self.execution_count += 1
2810 return None
2810 return None
2811 except (OverflowError, SyntaxError, ValueError, TypeError,
2811 except (OverflowError, SyntaxError, ValueError, TypeError,
2812 MemoryError):
2812 MemoryError):
2813 self.showsyntaxerror()
2813 self.showsyntaxerror()
2814 if store_history:
2814 if store_history:
2815 self.execution_count += 1
2815 self.execution_count += 1
2816 return None
2816 return None
2817
2817
2818 # Apply AST transformations
2818 # Apply AST transformations
2819 try:
2819 try:
2820 code_ast = self.transform_ast(code_ast)
2820 code_ast = self.transform_ast(code_ast)
2821 except InputRejected:
2821 except InputRejected:
2822 self.showtraceback()
2822 self.showtraceback()
2823 if store_history:
2823 if store_history:
2824 self.execution_count += 1
2824 self.execution_count += 1
2825 return None
2825 return None
2826
2826
2827 # Execute the user code
2827 # Execute the user code
2828 interactivity = "none" if silent else self.ast_node_interactivity
2828 interactivity = "none" if silent else self.ast_node_interactivity
2829 self.run_ast_nodes(code_ast.body, cell_name,
2829 self.run_ast_nodes(code_ast.body, cell_name,
2830 interactivity=interactivity, compiler=compiler)
2830 interactivity=interactivity, compiler=compiler)
2831
2831
2832 self.events.trigger('post_execute')
2832 self.events.trigger('post_execute')
2833 if not silent:
2833 if not silent:
2834 self.events.trigger('post_run_cell')
2834 self.events.trigger('post_run_cell')
2835
2835
2836 if store_history:
2836 if store_history:
2837 # Write output to the database. Does nothing unless
2837 # Write output to the database. Does nothing unless
2838 # history output logging is enabled.
2838 # history output logging is enabled.
2839 self.history_manager.store_output(self.execution_count)
2839 self.history_manager.store_output(self.execution_count)
2840 # Each cell is a *single* input, regardless of how many lines it has
2840 # Each cell is a *single* input, regardless of how many lines it has
2841 self.execution_count += 1
2841 self.execution_count += 1
2842
2842
2843 def transform_ast(self, node):
2843 def transform_ast(self, node):
2844 """Apply the AST transformations from self.ast_transformers
2844 """Apply the AST transformations from self.ast_transformers
2845
2845
2846 Parameters
2846 Parameters
2847 ----------
2847 ----------
2848 node : ast.Node
2848 node : ast.Node
2849 The root node to be transformed. Typically called with the ast.Module
2849 The root node to be transformed. Typically called with the ast.Module
2850 produced by parsing user input.
2850 produced by parsing user input.
2851
2851
2852 Returns
2852 Returns
2853 -------
2853 -------
2854 An ast.Node corresponding to the node it was called with. Note that it
2854 An ast.Node corresponding to the node it was called with. Note that it
2855 may also modify the passed object, so don't rely on references to the
2855 may also modify the passed object, so don't rely on references to the
2856 original AST.
2856 original AST.
2857 """
2857 """
2858 for transformer in self.ast_transformers:
2858 for transformer in self.ast_transformers:
2859 try:
2859 try:
2860 node = transformer.visit(node)
2860 node = transformer.visit(node)
2861 except InputRejected:
2861 except InputRejected:
2862 # User-supplied AST transformers can reject an input by raising
2862 # User-supplied AST transformers can reject an input by raising
2863 # an InputRejected. Short-circuit in this case so that we
2863 # an InputRejected. Short-circuit in this case so that we
2864 # don't unregister the transform.
2864 # don't unregister the transform.
2865 raise
2865 raise
2866 except Exception:
2866 except Exception:
2867 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
2867 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
2868 self.ast_transformers.remove(transformer)
2868 self.ast_transformers.remove(transformer)
2869
2869
2870 if self.ast_transformers:
2870 if self.ast_transformers:
2871 ast.fix_missing_locations(node)
2871 ast.fix_missing_locations(node)
2872 return node
2872 return node
2873
2873
2874
2874
2875 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr',
2875 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr',
2876 compiler=compile):
2876 compiler=compile):
2877 """Run a sequence of AST nodes. The execution mode depends on the
2877 """Run a sequence of AST nodes. The execution mode depends on the
2878 interactivity parameter.
2878 interactivity parameter.
2879
2879
2880 Parameters
2880 Parameters
2881 ----------
2881 ----------
2882 nodelist : list
2882 nodelist : list
2883 A sequence of AST nodes to run.
2883 A sequence of AST nodes to run.
2884 cell_name : str
2884 cell_name : str
2885 Will be passed to the compiler as the filename of the cell. Typically
2885 Will be passed to the compiler as the filename of the cell. Typically
2886 the value returned by ip.compile.cache(cell).
2886 the value returned by ip.compile.cache(cell).
2887 interactivity : str
2887 interactivity : str
2888 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2888 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2889 run interactively (displaying output from expressions). 'last_expr'
2889 run interactively (displaying output from expressions). 'last_expr'
2890 will run the last node interactively only if it is an expression (i.e.
2890 will run the last node interactively only if it is an expression (i.e.
2891 expressions in loops or other blocks are not displayed. Other values
2891 expressions in loops or other blocks are not displayed. Other values
2892 for this parameter will raise a ValueError.
2892 for this parameter will raise a ValueError.
2893 compiler : callable
2893 compiler : callable
2894 A function with the same interface as the built-in compile(), to turn
2894 A function with the same interface as the built-in compile(), to turn
2895 the AST nodes into code objects. Default is the built-in compile().
2895 the AST nodes into code objects. Default is the built-in compile().
2896 """
2896 """
2897 if not nodelist:
2897 if not nodelist:
2898 return
2898 return
2899
2899
2900 if interactivity == 'last_expr':
2900 if interactivity == 'last_expr':
2901 if isinstance(nodelist[-1], ast.Expr):
2901 if isinstance(nodelist[-1], ast.Expr):
2902 interactivity = "last"
2902 interactivity = "last"
2903 else:
2903 else:
2904 interactivity = "none"
2904 interactivity = "none"
2905
2905
2906 if interactivity == 'none':
2906 if interactivity == 'none':
2907 to_run_exec, to_run_interactive = nodelist, []
2907 to_run_exec, to_run_interactive = nodelist, []
2908 elif interactivity == 'last':
2908 elif interactivity == 'last':
2909 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2909 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2910 elif interactivity == 'all':
2910 elif interactivity == 'all':
2911 to_run_exec, to_run_interactive = [], nodelist
2911 to_run_exec, to_run_interactive = [], nodelist
2912 else:
2912 else:
2913 raise ValueError("Interactivity was %r" % interactivity)
2913 raise ValueError("Interactivity was %r" % interactivity)
2914
2914
2915 exec_count = self.execution_count
2915 exec_count = self.execution_count
2916
2916
2917 try:
2917 try:
2918 for i, node in enumerate(to_run_exec):
2918 for i, node in enumerate(to_run_exec):
2919 mod = ast.Module([node])
2919 mod = ast.Module([node])
2920 code = compiler(mod, cell_name, "exec")
2920 code = compiler(mod, cell_name, "exec")
2921 if self.run_code(code):
2921 if self.run_code(code):
2922 return True
2922 return True
2923
2923
2924 for i, node in enumerate(to_run_interactive):
2924 for i, node in enumerate(to_run_interactive):
2925 mod = ast.Interactive([node])
2925 mod = ast.Interactive([node])
2926 code = compiler(mod, cell_name, "single")
2926 code = compiler(mod, cell_name, "single")
2927 if self.run_code(code):
2927 if self.run_code(code):
2928 return True
2928 return True
2929
2929
2930 # Flush softspace
2930 # Flush softspace
2931 if softspace(sys.stdout, 0):
2931 if softspace(sys.stdout, 0):
2932 print()
2932 print()
2933
2933
2934 except:
2934 except:
2935 # It's possible to have exceptions raised here, typically by
2935 # It's possible to have exceptions raised here, typically by
2936 # compilation of odd code (such as a naked 'return' outside a
2936 # compilation of odd code (such as a naked 'return' outside a
2937 # function) that did parse but isn't valid. Typically the exception
2937 # function) that did parse but isn't valid. Typically the exception
2938 # is a SyntaxError, but it's safest just to catch anything and show
2938 # is a SyntaxError, but it's safest just to catch anything and show
2939 # the user a traceback.
2939 # the user a traceback.
2940
2940
2941 # We do only one try/except outside the loop to minimize the impact
2941 # We do only one try/except outside the loop to minimize the impact
2942 # on runtime, and also because if any node in the node list is
2942 # on runtime, and also because if any node in the node list is
2943 # broken, we should stop execution completely.
2943 # broken, we should stop execution completely.
2944 self.showtraceback()
2944 self.showtraceback()
2945
2945
2946 return False
2946 return False
2947
2947
2948 def run_code(self, code_obj):
2948 def run_code(self, code_obj):
2949 """Execute a code object.
2949 """Execute a code object.
2950
2950
2951 When an exception occurs, self.showtraceback() is called to display a
2951 When an exception occurs, self.showtraceback() is called to display a
2952 traceback.
2952 traceback.
2953
2953
2954 Parameters
2954 Parameters
2955 ----------
2955 ----------
2956 code_obj : code object
2956 code_obj : code object
2957 A compiled code object, to be executed
2957 A compiled code object, to be executed
2958
2958
2959 Returns
2959 Returns
2960 -------
2960 -------
2961 False : successful execution.
2961 False : successful execution.
2962 True : an error occurred.
2962 True : an error occurred.
2963 """
2963 """
2964 # Set our own excepthook in case the user code tries to call it
2964 # Set our own excepthook in case the user code tries to call it
2965 # directly, so that the IPython crash handler doesn't get triggered
2965 # directly, so that the IPython crash handler doesn't get triggered
2966 old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
2966 old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
2967
2967
2968 # we save the original sys.excepthook in the instance, in case config
2968 # we save the original sys.excepthook in the instance, in case config
2969 # code (such as magics) needs access to it.
2969 # code (such as magics) needs access to it.
2970 self.sys_excepthook = old_excepthook
2970 self.sys_excepthook = old_excepthook
2971 outflag = 1 # happens in more places, so it's easier as default
2971 outflag = 1 # happens in more places, so it's easier as default
2972 try:
2972 try:
2973 try:
2973 try:
2974 self.hooks.pre_run_code_hook()
2974 self.hooks.pre_run_code_hook()
2975 #rprint('Running code', repr(code_obj)) # dbg
2975 #rprint('Running code', repr(code_obj)) # dbg
2976 exec(code_obj, self.user_global_ns, self.user_ns)
2976 exec(code_obj, self.user_global_ns, self.user_ns)
2977 finally:
2977 finally:
2978 # Reset our crash handler in place
2978 # Reset our crash handler in place
2979 sys.excepthook = old_excepthook
2979 sys.excepthook = old_excepthook
2980 except SystemExit:
2980 except SystemExit:
2981 self.showtraceback(exception_only=True)
2981 self.showtraceback(exception_only=True)
2982 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2982 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2983 except self.custom_exceptions:
2983 except self.custom_exceptions:
2984 etype, value, tb = sys.exc_info()
2984 etype, value, tb = sys.exc_info()
2985 self.CustomTB(etype, value, tb)
2985 self.CustomTB(etype, value, tb)
2986 except:
2986 except:
2987 self.showtraceback()
2987 self.showtraceback()
2988 else:
2988 else:
2989 outflag = 0
2989 outflag = 0
2990 return outflag
2990 return outflag
2991
2991
2992 # For backwards compatibility
2992 # For backwards compatibility
2993 runcode = run_code
2993 runcode = run_code
2994
2994
2995 #-------------------------------------------------------------------------
2995 #-------------------------------------------------------------------------
2996 # Things related to GUI support and pylab
2996 # Things related to GUI support and pylab
2997 #-------------------------------------------------------------------------
2997 #-------------------------------------------------------------------------
2998
2998
2999 def enable_gui(self, gui=None):
2999 def enable_gui(self, gui=None):
3000 raise NotImplementedError('Implement enable_gui in a subclass')
3000 raise NotImplementedError('Implement enable_gui in a subclass')
3001
3001
3002 def enable_matplotlib(self, gui=None):
3002 def enable_matplotlib(self, gui=None):
3003 """Enable interactive matplotlib and inline figure support.
3003 """Enable interactive matplotlib and inline figure support.
3004
3004
3005 This takes the following steps:
3005 This takes the following steps:
3006
3006
3007 1. select the appropriate eventloop and matplotlib backend
3007 1. select the appropriate eventloop and matplotlib backend
3008 2. set up matplotlib for interactive use with that backend
3008 2. set up matplotlib for interactive use with that backend
3009 3. configure formatters for inline figure display
3009 3. configure formatters for inline figure display
3010 4. enable the selected gui eventloop
3010 4. enable the selected gui eventloop
3011
3011
3012 Parameters
3012 Parameters
3013 ----------
3013 ----------
3014 gui : optional, string
3014 gui : optional, string
3015 If given, dictates the choice of matplotlib GUI backend to use
3015 If given, dictates the choice of matplotlib GUI backend to use
3016 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3016 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3017 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3017 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3018 matplotlib (as dictated by the matplotlib build-time options plus the
3018 matplotlib (as dictated by the matplotlib build-time options plus the
3019 user's matplotlibrc configuration file). Note that not all backends
3019 user's matplotlibrc configuration file). Note that not all backends
3020 make sense in all contexts, for example a terminal ipython can't
3020 make sense in all contexts, for example a terminal ipython can't
3021 display figures inline.
3021 display figures inline.
3022 """
3022 """
3023 from IPython.core import pylabtools as pt
3023 from IPython.core import pylabtools as pt
3024 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
3024 gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
3025
3025
3026 if gui != 'inline':
3026 if gui != 'inline':
3027 # If we have our first gui selection, store it
3027 # If we have our first gui selection, store it
3028 if self.pylab_gui_select is None:
3028 if self.pylab_gui_select is None:
3029 self.pylab_gui_select = gui
3029 self.pylab_gui_select = gui
3030 # Otherwise if they are different
3030 # Otherwise if they are different
3031 elif gui != self.pylab_gui_select:
3031 elif gui != self.pylab_gui_select:
3032 print ('Warning: Cannot change to a different GUI toolkit: %s.'
3032 print ('Warning: Cannot change to a different GUI toolkit: %s.'
3033 ' Using %s instead.' % (gui, self.pylab_gui_select))
3033 ' Using %s instead.' % (gui, self.pylab_gui_select))
3034 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
3034 gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
3035
3035
3036 pt.activate_matplotlib(backend)
3036 pt.activate_matplotlib(backend)
3037 pt.configure_inline_support(self, backend)
3037 pt.configure_inline_support(self, backend)
3038
3038
3039 # Now we must activate the gui pylab wants to use, and fix %run to take
3039 # Now we must activate the gui pylab wants to use, and fix %run to take
3040 # plot updates into account
3040 # plot updates into account
3041 self.enable_gui(gui)
3041 self.enable_gui(gui)
3042 self.magics_manager.registry['ExecutionMagics'].default_runner = \
3042 self.magics_manager.registry['ExecutionMagics'].default_runner = \
3043 pt.mpl_runner(self.safe_execfile)
3043 pt.mpl_runner(self.safe_execfile)
3044
3044
3045 return gui, backend
3045 return gui, backend
3046
3046
3047 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
3047 def enable_pylab(self, gui=None, import_all=True, welcome_message=False):
3048 """Activate pylab support at runtime.
3048 """Activate pylab support at runtime.
3049
3049
3050 This turns on support for matplotlib, preloads into the interactive
3050 This turns on support for matplotlib, preloads into the interactive
3051 namespace all of numpy and pylab, and configures IPython to correctly
3051 namespace all of numpy and pylab, and configures IPython to correctly
3052 interact with the GUI event loop. The GUI backend to be used can be
3052 interact with the GUI event loop. The GUI backend to be used can be
3053 optionally selected with the optional ``gui`` argument.
3053 optionally selected with the optional ``gui`` argument.
3054
3054
3055 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
3055 This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
3056
3056
3057 Parameters
3057 Parameters
3058 ----------
3058 ----------
3059 gui : optional, string
3059 gui : optional, string
3060 If given, dictates the choice of matplotlib GUI backend to use
3060 If given, dictates the choice of matplotlib GUI backend to use
3061 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3061 (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
3062 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3062 'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
3063 matplotlib (as dictated by the matplotlib build-time options plus the
3063 matplotlib (as dictated by the matplotlib build-time options plus the
3064 user's matplotlibrc configuration file). Note that not all backends
3064 user's matplotlibrc configuration file). Note that not all backends
3065 make sense in all contexts, for example a terminal ipython can't
3065 make sense in all contexts, for example a terminal ipython can't
3066 display figures inline.
3066 display figures inline.
3067 import_all : optional, bool, default: True
3067 import_all : optional, bool, default: True
3068 Whether to do `from numpy import *` and `from pylab import *`
3068 Whether to do `from numpy import *` and `from pylab import *`
3069 in addition to module imports.
3069 in addition to module imports.
3070 welcome_message : deprecated
3070 welcome_message : deprecated
3071 This argument is ignored, no welcome message will be displayed.
3071 This argument is ignored, no welcome message will be displayed.
3072 """
3072 """
3073 from IPython.core.pylabtools import import_pylab
3073 from IPython.core.pylabtools import import_pylab
3074
3074
3075 gui, backend = self.enable_matplotlib(gui)
3075 gui, backend = self.enable_matplotlib(gui)
3076
3076
3077 # We want to prevent the loading of pylab to pollute the user's
3077 # We want to prevent the loading of pylab to pollute the user's
3078 # namespace as shown by the %who* magics, so we execute the activation
3078 # namespace as shown by the %who* magics, so we execute the activation
3079 # code in an empty namespace, and we update *both* user_ns and
3079 # code in an empty namespace, and we update *both* user_ns and
3080 # user_ns_hidden with this information.
3080 # user_ns_hidden with this information.
3081 ns = {}
3081 ns = {}
3082 import_pylab(ns, import_all)
3082 import_pylab(ns, import_all)
3083 # warn about clobbered names
3083 # warn about clobbered names
3084 ignored = set(["__builtins__"])
3084 ignored = set(["__builtins__"])
3085 both = set(ns).intersection(self.user_ns).difference(ignored)
3085 both = set(ns).intersection(self.user_ns).difference(ignored)
3086 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
3086 clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
3087 self.user_ns.update(ns)
3087 self.user_ns.update(ns)
3088 self.user_ns_hidden.update(ns)
3088 self.user_ns_hidden.update(ns)
3089 return gui, backend, clobbered
3089 return gui, backend, clobbered
3090
3090
3091 #-------------------------------------------------------------------------
3091 #-------------------------------------------------------------------------
3092 # Utilities
3092 # Utilities
3093 #-------------------------------------------------------------------------
3093 #-------------------------------------------------------------------------
3094
3094
3095 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
3095 def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
3096 """Expand python variables in a string.
3096 """Expand python variables in a string.
3097
3097
3098 The depth argument indicates how many frames above the caller should
3098 The depth argument indicates how many frames above the caller should
3099 be walked to look for the local namespace where to expand variables.
3099 be walked to look for the local namespace where to expand variables.
3100
3100
3101 The global namespace for expansion is always the user's interactive
3101 The global namespace for expansion is always the user's interactive
3102 namespace.
3102 namespace.
3103 """
3103 """
3104 ns = self.user_ns.copy()
3104 ns = self.user_ns.copy()
3105 ns.update(sys._getframe(depth+1).f_locals)
3105 ns.update(sys._getframe(depth+1).f_locals)
3106 try:
3106 try:
3107 # We have to use .vformat() here, because 'self' is a valid and common
3107 # We have to use .vformat() here, because 'self' is a valid and common
3108 # name, and expanding **ns for .format() would make it collide with
3108 # name, and expanding **ns for .format() would make it collide with
3109 # the 'self' argument of the method.
3109 # the 'self' argument of the method.
3110 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
3110 cmd = formatter.vformat(cmd, args=[], kwargs=ns)
3111 except Exception:
3111 except Exception:
3112 # if formatter couldn't format, just let it go untransformed
3112 # if formatter couldn't format, just let it go untransformed
3113 pass
3113 pass
3114 return cmd
3114 return cmd
3115
3115
3116 def mktempfile(self, data=None, prefix='ipython_edit_'):
3116 def mktempfile(self, data=None, prefix='ipython_edit_'):
3117 """Make a new tempfile and return its filename.
3117 """Make a new tempfile and return its filename.
3118
3118
3119 This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
3119 This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
3120 but it registers the created filename internally so ipython cleans it up
3120 but it registers the created filename internally so ipython cleans it up
3121 at exit time.
3121 at exit time.
3122
3122
3123 Optional inputs:
3123 Optional inputs:
3124
3124
3125 - data(None): if data is given, it gets written out to the temp file
3125 - data(None): if data is given, it gets written out to the temp file
3126 immediately, and the file is closed again."""
3126 immediately, and the file is closed again."""
3127
3127
3128 dirname = tempfile.mkdtemp(prefix=prefix)
3128 dirname = tempfile.mkdtemp(prefix=prefix)
3129 self.tempdirs.append(dirname)
3129 self.tempdirs.append(dirname)
3130
3130
3131 handle, filename = tempfile.mkstemp('.py', prefix, dir=dirname)
3131 handle, filename = tempfile.mkstemp('.py', prefix, dir=dirname)
3132 os.close(handle) # On Windows, there can only be one open handle on a file
3132 os.close(handle) # On Windows, there can only be one open handle on a file
3133 self.tempfiles.append(filename)
3133 self.tempfiles.append(filename)
3134
3134
3135 if data:
3135 if data:
3136 tmp_file = open(filename,'w')
3136 tmp_file = open(filename,'w')
3137 tmp_file.write(data)
3137 tmp_file.write(data)
3138 tmp_file.close()
3138 tmp_file.close()
3139 return filename
3139 return filename
3140
3140
3141 # TODO: This should be removed when Term is refactored.
3141 # TODO: This should be removed when Term is refactored.
3142 def write(self,data):
3142 def write(self,data):
3143 """Write a string to the default output"""
3143 """Write a string to the default output"""
3144 io.stdout.write(data)
3144 io.stdout.write(data)
3145
3145
3146 # TODO: This should be removed when Term is refactored.
3146 # TODO: This should be removed when Term is refactored.
3147 def write_err(self,data):
3147 def write_err(self,data):
3148 """Write a string to the default error output"""
3148 """Write a string to the default error output"""
3149 io.stderr.write(data)
3149 io.stderr.write(data)
3150
3150
3151 def ask_yes_no(self, prompt, default=None):
3151 def ask_yes_no(self, prompt, default=None):
3152 if self.quiet:
3152 if self.quiet:
3153 return True
3153 return True
3154 return ask_yes_no(prompt,default)
3154 return ask_yes_no(prompt,default)
3155
3155
3156 def show_usage(self):
3156 def show_usage(self):
3157 """Show a usage message"""
3157 """Show a usage message"""
3158 page.page(IPython.core.usage.interactive_usage)
3158 page.page(IPython.core.usage.interactive_usage)
3159
3159
3160 def extract_input_lines(self, range_str, raw=False):
3160 def extract_input_lines(self, range_str, raw=False):
3161 """Return as a string a set of input history slices.
3161 """Return as a string a set of input history slices.
3162
3162
3163 Parameters
3163 Parameters
3164 ----------
3164 ----------
3165 range_str : string
3165 range_str : string
3166 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3166 The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
3167 since this function is for use by magic functions which get their
3167 since this function is for use by magic functions which get their
3168 arguments as strings. The number before the / is the session
3168 arguments as strings. The number before the / is the session
3169 number: ~n goes n back from the current session.
3169 number: ~n goes n back from the current session.
3170
3170
3171 raw : bool, optional
3171 raw : bool, optional
3172 By default, the processed input is used. If this is true, the raw
3172 By default, the processed input is used. If this is true, the raw
3173 input history is used instead.
3173 input history is used instead.
3174
3174
3175 Notes
3175 Notes
3176 -----
3176 -----
3177
3177
3178 Slices can be described with two notations:
3178 Slices can be described with two notations:
3179
3179
3180 * ``N:M`` -> standard python form, means including items N...(M-1).
3180 * ``N:M`` -> standard python form, means including items N...(M-1).
3181 * ``N-M`` -> include items N..M (closed endpoint).
3181 * ``N-M`` -> include items N..M (closed endpoint).
3182 """
3182 """
3183 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3183 lines = self.history_manager.get_range_by_str(range_str, raw=raw)
3184 return "\n".join(x for _, _, x in lines)
3184 return "\n".join(x for _, _, x in lines)
3185
3185
3186 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
3186 def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
3187 """Get a code string from history, file, url, or a string or macro.
3187 """Get a code string from history, file, url, or a string or macro.
3188
3188
3189 This is mainly used by magic functions.
3189 This is mainly used by magic functions.
3190
3190
3191 Parameters
3191 Parameters
3192 ----------
3192 ----------
3193
3193
3194 target : str
3194 target : str
3195
3195
3196 A string specifying code to retrieve. This will be tried respectively
3196 A string specifying code to retrieve. This will be tried respectively
3197 as: ranges of input history (see %history for syntax), url,
3197 as: ranges of input history (see %history for syntax), url,
3198 correspnding .py file, filename, or an expression evaluating to a
3198 correspnding .py file, filename, or an expression evaluating to a
3199 string or Macro in the user namespace.
3199 string or Macro in the user namespace.
3200
3200
3201 raw : bool
3201 raw : bool
3202 If true (default), retrieve raw history. Has no effect on the other
3202 If true (default), retrieve raw history. Has no effect on the other
3203 retrieval mechanisms.
3203 retrieval mechanisms.
3204
3204
3205 py_only : bool (default False)
3205 py_only : bool (default False)
3206 Only try to fetch python code, do not try alternative methods to decode file
3206 Only try to fetch python code, do not try alternative methods to decode file
3207 if unicode fails.
3207 if unicode fails.
3208
3208
3209 Returns
3209 Returns
3210 -------
3210 -------
3211 A string of code.
3211 A string of code.
3212
3212
3213 ValueError is raised if nothing is found, and TypeError if it evaluates
3213 ValueError is raised if nothing is found, and TypeError if it evaluates
3214 to an object of another type. In each case, .args[0] is a printable
3214 to an object of another type. In each case, .args[0] is a printable
3215 message.
3215 message.
3216 """
3216 """
3217 code = self.extract_input_lines(target, raw=raw) # Grab history
3217 code = self.extract_input_lines(target, raw=raw) # Grab history
3218 if code:
3218 if code:
3219 return code
3219 return code
3220 utarget = unquote_filename(target)
3220 utarget = unquote_filename(target)
3221 try:
3221 try:
3222 if utarget.startswith(('http://', 'https://')):
3222 if utarget.startswith(('http://', 'https://')):
3223 return openpy.read_py_url(utarget, skip_encoding_cookie=skip_encoding_cookie)
3223 return openpy.read_py_url(utarget, skip_encoding_cookie=skip_encoding_cookie)
3224 except UnicodeDecodeError:
3224 except UnicodeDecodeError:
3225 if not py_only :
3225 if not py_only :
3226 # Deferred import
3226 # Deferred import
3227 try:
3227 try:
3228 from urllib.request import urlopen # Py3
3228 from urllib.request import urlopen # Py3
3229 except ImportError:
3229 except ImportError:
3230 from urllib import urlopen
3230 from urllib import urlopen
3231 response = urlopen(target)
3231 response = urlopen(target)
3232 return response.read().decode('latin1')
3232 return response.read().decode('latin1')
3233 raise ValueError(("'%s' seem to be unreadable.") % utarget)
3233 raise ValueError(("'%s' seem to be unreadable.") % utarget)
3234
3234
3235 potential_target = [target]
3235 potential_target = [target]
3236 try :
3236 try :
3237 potential_target.insert(0,get_py_filename(target))
3237 potential_target.insert(0,get_py_filename(target))
3238 except IOError:
3238 except IOError:
3239 pass
3239 pass
3240
3240
3241 for tgt in potential_target :
3241 for tgt in potential_target :
3242 if os.path.isfile(tgt): # Read file
3242 if os.path.isfile(tgt): # Read file
3243 try :
3243 try :
3244 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3244 return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
3245 except UnicodeDecodeError :
3245 except UnicodeDecodeError :
3246 if not py_only :
3246 if not py_only :
3247 with io_open(tgt,'r', encoding='latin1') as f :
3247 with io_open(tgt,'r', encoding='latin1') as f :
3248 return f.read()
3248 return f.read()
3249 raise ValueError(("'%s' seem to be unreadable.") % target)
3249 raise ValueError(("'%s' seem to be unreadable.") % target)
3250 elif os.path.isdir(os.path.expanduser(tgt)):
3250 elif os.path.isdir(os.path.expanduser(tgt)):
3251 raise ValueError("'%s' is a directory, not a regular file." % target)
3251 raise ValueError("'%s' is a directory, not a regular file." % target)
3252
3252
3253 if search_ns:
3253 if search_ns:
3254 # Inspect namespace to load object source
3254 # Inspect namespace to load object source
3255 object_info = self.object_inspect(target, detail_level=1)
3255 object_info = self.object_inspect(target, detail_level=1)
3256 if object_info['found'] and object_info['source']:
3256 if object_info['found'] and object_info['source']:
3257 return object_info['source']
3257 return object_info['source']
3258
3258
3259 try: # User namespace
3259 try: # User namespace
3260 codeobj = eval(target, self.user_ns)
3260 codeobj = eval(target, self.user_ns)
3261 except Exception:
3261 except Exception:
3262 raise ValueError(("'%s' was not found in history, as a file, url, "
3262 raise ValueError(("'%s' was not found in history, as a file, url, "
3263 "nor in the user namespace.") % target)
3263 "nor in the user namespace.") % target)
3264
3264
3265 if isinstance(codeobj, string_types):
3265 if isinstance(codeobj, string_types):
3266 return codeobj
3266 return codeobj
3267 elif isinstance(codeobj, Macro):
3267 elif isinstance(codeobj, Macro):
3268 return codeobj.value
3268 return codeobj.value
3269
3269
3270 raise TypeError("%s is neither a string nor a macro." % target,
3270 raise TypeError("%s is neither a string nor a macro." % target,
3271 codeobj)
3271 codeobj)
3272
3272
3273 #-------------------------------------------------------------------------
3273 #-------------------------------------------------------------------------
3274 # Things related to IPython exiting
3274 # Things related to IPython exiting
3275 #-------------------------------------------------------------------------
3275 #-------------------------------------------------------------------------
3276 def atexit_operations(self):
3276 def atexit_operations(self):
3277 """This will be executed at the time of exit.
3277 """This will be executed at the time of exit.
3278
3278
3279 Cleanup operations and saving of persistent data that is done
3279 Cleanup operations and saving of persistent data that is done
3280 unconditionally by IPython should be performed here.
3280 unconditionally by IPython should be performed here.
3281
3281
3282 For things that may depend on startup flags or platform specifics (such
3282 For things that may depend on startup flags or platform specifics (such
3283 as having readline or not), register a separate atexit function in the
3283 as having readline or not), register a separate atexit function in the
3284 code that has the appropriate information, rather than trying to
3284 code that has the appropriate information, rather than trying to
3285 clutter
3285 clutter
3286 """
3286 """
3287 # Close the history session (this stores the end time and line count)
3287 # Close the history session (this stores the end time and line count)
3288 # this must be *before* the tempfile cleanup, in case of temporary
3288 # this must be *before* the tempfile cleanup, in case of temporary
3289 # history db
3289 # history db
3290 self.history_manager.end_session()
3290 self.history_manager.end_session()
3291
3291
3292 # Cleanup all tempfiles and folders left around
3292 # Cleanup all tempfiles and folders left around
3293 for tfile in self.tempfiles:
3293 for tfile in self.tempfiles:
3294 try:
3294 try:
3295 os.unlink(tfile)
3295 os.unlink(tfile)
3296 except OSError:
3296 except OSError:
3297 pass
3297 pass
3298
3298
3299 for tdir in self.tempdirs:
3299 for tdir in self.tempdirs:
3300 try:
3300 try:
3301 os.rmdir(tdir)
3301 os.rmdir(tdir)
3302 except OSError:
3302 except OSError:
3303 pass
3303 pass
3304
3304
3305 # Clear all user namespaces to release all references cleanly.
3305 # Clear all user namespaces to release all references cleanly.
3306 self.reset(new_session=False)
3306 self.reset(new_session=False)
3307
3307
3308 # Run user hooks
3308 # Run user hooks
3309 self.hooks.shutdown_hook()
3309 self.hooks.shutdown_hook()
3310
3310
3311 def cleanup(self):
3311 def cleanup(self):
3312 self.restore_sys_module_state()
3312 self.restore_sys_module_state()
3313
3313
3314
3314
3315 class InteractiveShellABC(with_metaclass(abc.ABCMeta, object)):
3315 class InteractiveShellABC(with_metaclass(abc.ABCMeta, object)):
3316 """An abstract base class for InteractiveShell."""
3316 """An abstract base class for InteractiveShell."""
3317
3317
3318 InteractiveShellABC.register(InteractiveShell)
3318 InteractiveShellABC.register(InteractiveShell)
@@ -1,572 +1,578 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2 """terminal client to the IPython kernel"""
2 """terminal client to the IPython kernel"""
3
3
4 # Copyright (c) IPython Development Team.
4 # Copyright (c) IPython Development Team.
5 # Distributed under the terms of the Modified BSD License.
5 # Distributed under the terms of the Modified BSD License.
6
6
7 from __future__ import print_function
7 from __future__ import print_function
8
8
9 import base64
9 import base64
10 import bdb
10 import bdb
11 import signal
11 import signal
12 import os
12 import os
13 import sys
13 import sys
14 import time
14 import time
15 import subprocess
15 import subprocess
16 from getpass import getpass
16 from getpass import getpass
17 from io import BytesIO
17 from io import BytesIO
18
18
19 try:
19 try:
20 from queue import Empty # Py 3
20 from queue import Empty # Py 3
21 except ImportError:
21 except ImportError:
22 from Queue import Empty # Py 2
22 from Queue import Empty # Py 2
23
23
24 from IPython.core import page
24 from IPython.core import page
25 from IPython.core import release
25 from IPython.core import release
26 from IPython.terminal.console.zmqhistory import ZMQHistoryManager
26 from IPython.utils.warn import warn, error
27 from IPython.utils.warn import warn, error
27 from IPython.utils import io
28 from IPython.utils import io
28 from IPython.utils.py3compat import string_types, input
29 from IPython.utils.py3compat import string_types, input
29 from IPython.utils.traitlets import List, Enum, Any, Instance, Unicode, Float, Bool
30 from IPython.utils.traitlets import List, Enum, Any, Instance, Unicode, Float, Bool
30 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
31 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
31
32
32 from IPython.terminal.interactiveshell import TerminalInteractiveShell
33 from IPython.terminal.interactiveshell import TerminalInteractiveShell
33 from IPython.terminal.console.completer import ZMQCompleter
34 from IPython.terminal.console.completer import ZMQCompleter
34
35
35
36 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
36 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
37 """A subclass of TerminalInteractiveShell that uses the 0MQ kernel"""
37 """A subclass of TerminalInteractiveShell that uses the 0MQ kernel"""
38 _executing = False
38 _executing = False
39 _execution_state = Unicode('')
39 _execution_state = Unicode('')
40 _pending_clearoutput = False
40 _pending_clearoutput = False
41 kernel_banner = Unicode('')
41 kernel_banner = Unicode('')
42 kernel_timeout = Float(60, config=True,
42 kernel_timeout = Float(60, config=True,
43 help="""Timeout for giving up on a kernel (in seconds).
43 help="""Timeout for giving up on a kernel (in seconds).
44
44
45 On first connect and restart, the console tests whether the
45 On first connect and restart, the console tests whether the
46 kernel is running and responsive by sending kernel_info_requests.
46 kernel is running and responsive by sending kernel_info_requests.
47 This sets the timeout in seconds for how long the kernel can take
47 This sets the timeout in seconds for how long the kernel can take
48 before being presumed dead.
48 before being presumed dead.
49 """
49 """
50 )
50 )
51
51
52 image_handler = Enum(('PIL', 'stream', 'tempfile', 'callable'),
52 image_handler = Enum(('PIL', 'stream', 'tempfile', 'callable'),
53 config=True, help=
53 config=True, help=
54 """
54 """
55 Handler for image type output. This is useful, for example,
55 Handler for image type output. This is useful, for example,
56 when connecting to the kernel in which pylab inline backend is
56 when connecting to the kernel in which pylab inline backend is
57 activated. There are four handlers defined. 'PIL': Use
57 activated. There are four handlers defined. 'PIL': Use
58 Python Imaging Library to popup image; 'stream': Use an
58 Python Imaging Library to popup image; 'stream': Use an
59 external program to show the image. Image will be fed into
59 external program to show the image. Image will be fed into
60 the STDIN of the program. You will need to configure
60 the STDIN of the program. You will need to configure
61 `stream_image_handler`; 'tempfile': Use an external program to
61 `stream_image_handler`; 'tempfile': Use an external program to
62 show the image. Image will be saved in a temporally file and
62 show the image. Image will be saved in a temporally file and
63 the program is called with the temporally file. You will need
63 the program is called with the temporally file. You will need
64 to configure `tempfile_image_handler`; 'callable': You can set
64 to configure `tempfile_image_handler`; 'callable': You can set
65 any Python callable which is called with the image data. You
65 any Python callable which is called with the image data. You
66 will need to configure `callable_image_handler`.
66 will need to configure `callable_image_handler`.
67 """
67 """
68 )
68 )
69
69
70 stream_image_handler = List(config=True, help=
70 stream_image_handler = List(config=True, help=
71 """
71 """
72 Command to invoke an image viewer program when you are using
72 Command to invoke an image viewer program when you are using
73 'stream' image handler. This option is a list of string where
73 'stream' image handler. This option is a list of string where
74 the first element is the command itself and reminders are the
74 the first element is the command itself and reminders are the
75 options for the command. Raw image data is given as STDIN to
75 options for the command. Raw image data is given as STDIN to
76 the program.
76 the program.
77 """
77 """
78 )
78 )
79
79
80 tempfile_image_handler = List(config=True, help=
80 tempfile_image_handler = List(config=True, help=
81 """
81 """
82 Command to invoke an image viewer program when you are using
82 Command to invoke an image viewer program when you are using
83 'tempfile' image handler. This option is a list of string
83 'tempfile' image handler. This option is a list of string
84 where the first element is the command itself and reminders
84 where the first element is the command itself and reminders
85 are the options for the command. You can use {file} and
85 are the options for the command. You can use {file} and
86 {format} in the string to represent the location of the
86 {format} in the string to represent the location of the
87 generated image file and image format.
87 generated image file and image format.
88 """
88 """
89 )
89 )
90
90
91 callable_image_handler = Any(config=True, help=
91 callable_image_handler = Any(config=True, help=
92 """
92 """
93 Callable object called via 'callable' image handler with one
93 Callable object called via 'callable' image handler with one
94 argument, `data`, which is `msg["content"]["data"]` where
94 argument, `data`, which is `msg["content"]["data"]` where
95 `msg` is the message from iopub channel. For exmaple, you can
95 `msg` is the message from iopub channel. For exmaple, you can
96 find base64 encoded PNG data as `data['image/png']`.
96 find base64 encoded PNG data as `data['image/png']`.
97 """
97 """
98 )
98 )
99
99
100 mime_preference = List(
100 mime_preference = List(
101 default_value=['image/png', 'image/jpeg', 'image/svg+xml'],
101 default_value=['image/png', 'image/jpeg', 'image/svg+xml'],
102 config=True, allow_none=False, help=
102 config=True, allow_none=False, help=
103 """
103 """
104 Preferred object representation MIME type in order. First
104 Preferred object representation MIME type in order. First
105 matched MIME type will be used.
105 matched MIME type will be used.
106 """
106 """
107 )
107 )
108
108
109 manager = Instance('IPython.kernel.KernelManager')
109 manager = Instance('IPython.kernel.KernelManager')
110 client = Instance('IPython.kernel.KernelClient')
110 client = Instance('IPython.kernel.KernelClient')
111 def _client_changed(self, name, old, new):
111 def _client_changed(self, name, old, new):
112 self.session_id = new.session.session
112 self.session_id = new.session.session
113 session_id = Unicode()
113 session_id = Unicode()
114
114
115 def init_completer(self):
115 def init_completer(self):
116 """Initialize the completion machinery.
116 """Initialize the completion machinery.
117
117
118 This creates completion machinery that can be used by client code,
118 This creates completion machinery that can be used by client code,
119 either interactively in-process (typically triggered by the readline
119 either interactively in-process (typically triggered by the readline
120 library), programmatically (such as in test suites) or out-of-process
120 library), programmatically (such as in test suites) or out-of-process
121 (typically over the network by remote frontends).
121 (typically over the network by remote frontends).
122 """
122 """
123 from IPython.core.completerlib import (module_completer,
123 from IPython.core.completerlib import (module_completer,
124 magic_run_completer, cd_completer)
124 magic_run_completer, cd_completer)
125
125
126 self.Completer = ZMQCompleter(self, self.client, config=self.config)
126 self.Completer = ZMQCompleter(self, self.client, config=self.config)
127
127
128
128
129 self.set_hook('complete_command', module_completer, str_key = 'import')
129 self.set_hook('complete_command', module_completer, str_key = 'import')
130 self.set_hook('complete_command', module_completer, str_key = 'from')
130 self.set_hook('complete_command', module_completer, str_key = 'from')
131 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
131 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
132 self.set_hook('complete_command', cd_completer, str_key = '%cd')
132 self.set_hook('complete_command', cd_completer, str_key = '%cd')
133
133
134 # Only configure readline if we truly are using readline. IPython can
134 # Only configure readline if we truly are using readline. IPython can
135 # do tab-completion over the network, in GUIs, etc, where readline
135 # do tab-completion over the network, in GUIs, etc, where readline
136 # itself may be absent
136 # itself may be absent
137 if self.has_readline:
137 if self.has_readline:
138 self.set_readline_completer()
138 self.set_readline_completer()
139
139
140 def run_cell(self, cell, store_history=True):
140 def run_cell(self, cell, store_history=True):
141 """Run a complete IPython cell.
141 """Run a complete IPython cell.
142
142
143 Parameters
143 Parameters
144 ----------
144 ----------
145 cell : str
145 cell : str
146 The code (including IPython code such as %magic functions) to run.
146 The code (including IPython code such as %magic functions) to run.
147 store_history : bool
147 store_history : bool
148 If True, the raw and translated cell will be stored in IPython's
148 If True, the raw and translated cell will be stored in IPython's
149 history. For user code calling back into IPython's machinery, this
149 history. For user code calling back into IPython's machinery, this
150 should be set to False.
150 should be set to False.
151 """
151 """
152 if (not cell) or cell.isspace():
152 if (not cell) or cell.isspace():
153 # pressing enter flushes any pending display
153 # pressing enter flushes any pending display
154 self.handle_iopub()
154 self.handle_iopub()
155 return
155 return
156
156
157 # flush stale replies, which could have been ignored, due to missed heartbeats
157 # flush stale replies, which could have been ignored, due to missed heartbeats
158 while self.client.shell_channel.msg_ready():
158 while self.client.shell_channel.msg_ready():
159 self.client.shell_channel.get_msg()
159 self.client.shell_channel.get_msg()
160 # shell_channel.execute takes 'hidden', which is the inverse of store_hist
160 # shell_channel.execute takes 'hidden', which is the inverse of store_hist
161 msg_id = self.client.shell_channel.execute(cell, not store_history)
161 msg_id = self.client.shell_channel.execute(cell, not store_history)
162
162
163 # first thing is wait for any side effects (output, stdin, etc.)
163 # first thing is wait for any side effects (output, stdin, etc.)
164 self._executing = True
164 self._executing = True
165 self._execution_state = "busy"
165 self._execution_state = "busy"
166 while self._execution_state != 'idle' and self.client.is_alive():
166 while self._execution_state != 'idle' and self.client.is_alive():
167 try:
167 try:
168 self.handle_input_request(msg_id, timeout=0.05)
168 self.handle_input_request(msg_id, timeout=0.05)
169 except Empty:
169 except Empty:
170 # display intermediate print statements, etc.
170 # display intermediate print statements, etc.
171 self.handle_iopub(msg_id)
171 self.handle_iopub(msg_id)
172
172
173 # after all of that is done, wait for the execute reply
173 # after all of that is done, wait for the execute reply
174 while self.client.is_alive():
174 while self.client.is_alive():
175 try:
175 try:
176 self.handle_execute_reply(msg_id, timeout=0.05)
176 self.handle_execute_reply(msg_id, timeout=0.05)
177 except Empty:
177 except Empty:
178 pass
178 pass
179 else:
179 else:
180 break
180 break
181 self._executing = False
181 self._executing = False
182
182
183 #-----------------
183 #-----------------
184 # message handlers
184 # message handlers
185 #-----------------
185 #-----------------
186
186
187 def handle_execute_reply(self, msg_id, timeout=None):
187 def handle_execute_reply(self, msg_id, timeout=None):
188 msg = self.client.shell_channel.get_msg(block=False, timeout=timeout)
188 msg = self.client.shell_channel.get_msg(block=False, timeout=timeout)
189 if msg["parent_header"].get("msg_id", None) == msg_id:
189 if msg["parent_header"].get("msg_id", None) == msg_id:
190
190
191 self.handle_iopub(msg_id)
191 self.handle_iopub(msg_id)
192
192
193 content = msg["content"]
193 content = msg["content"]
194 status = content['status']
194 status = content['status']
195
195
196 if status == 'aborted':
196 if status == 'aborted':
197 self.write('Aborted\n')
197 self.write('Aborted\n')
198 return
198 return
199 elif status == 'ok':
199 elif status == 'ok':
200 # handle payloads
200 # handle payloads
201 for item in content["payload"]:
201 for item in content["payload"]:
202 source = item['source']
202 source = item['source']
203 if source == 'page':
203 if source == 'page':
204 page.page(item['data']['text/plain'])
204 page.page(item['data']['text/plain'])
205 elif source == 'set_next_input':
205 elif source == 'set_next_input':
206 self.set_next_input(item['text'])
206 self.set_next_input(item['text'])
207 elif source == 'ask_exit':
207 elif source == 'ask_exit':
208 self.ask_exit()
208 self.ask_exit()
209
209
210 elif status == 'error':
210 elif status == 'error':
211 for frame in content["traceback"]:
211 for frame in content["traceback"]:
212 print(frame, file=io.stderr)
212 print(frame, file=io.stderr)
213
213
214 self.execution_count = int(content["execution_count"] + 1)
214 self.execution_count = int(content["execution_count"] + 1)
215
215
216 include_other_output = Bool(False, config=True,
216 include_other_output = Bool(False, config=True,
217 help="""Whether to include output from clients
217 help="""Whether to include output from clients
218 other than this one sharing the same kernel.
218 other than this one sharing the same kernel.
219
219
220 Outputs are not displayed until enter is pressed.
220 Outputs are not displayed until enter is pressed.
221 """
221 """
222 )
222 )
223 other_output_prefix = Unicode("[remote] ", config=True,
223 other_output_prefix = Unicode("[remote] ", config=True,
224 help="""Prefix to add to outputs coming from clients other than this one.
224 help="""Prefix to add to outputs coming from clients other than this one.
225
225
226 Only relevant if include_other_output is True.
226 Only relevant if include_other_output is True.
227 """
227 """
228 )
228 )
229
229
230 def from_here(self, msg):
230 def from_here(self, msg):
231 """Return whether a message is from this session"""
231 """Return whether a message is from this session"""
232 return msg['parent_header'].get("session", self.session_id) == self.session_id
232 return msg['parent_header'].get("session", self.session_id) == self.session_id
233
233
234 def include_output(self, msg):
234 def include_output(self, msg):
235 """Return whether we should include a given output message"""
235 """Return whether we should include a given output message"""
236 from_here = self.from_here(msg)
236 from_here = self.from_here(msg)
237 if msg['msg_type'] == 'execute_input':
237 if msg['msg_type'] == 'execute_input':
238 # only echo inputs not from here
238 # only echo inputs not from here
239 return self.include_other_output and not from_here
239 return self.include_other_output and not from_here
240
240
241 if self.include_other_output:
241 if self.include_other_output:
242 return True
242 return True
243 else:
243 else:
244 return from_here
244 return from_here
245
245
246 def handle_iopub(self, msg_id=''):
246 def handle_iopub(self, msg_id=''):
247 """Process messages on the IOPub channel
247 """Process messages on the IOPub channel
248
248
249 This method consumes and processes messages on the IOPub channel,
249 This method consumes and processes messages on the IOPub channel,
250 such as stdout, stderr, execute_result and status.
250 such as stdout, stderr, execute_result and status.
251
251
252 It only displays output that is caused by this session.
252 It only displays output that is caused by this session.
253 """
253 """
254 while self.client.iopub_channel.msg_ready():
254 while self.client.iopub_channel.msg_ready():
255 sub_msg = self.client.iopub_channel.get_msg()
255 sub_msg = self.client.iopub_channel.get_msg()
256 msg_type = sub_msg['header']['msg_type']
256 msg_type = sub_msg['header']['msg_type']
257 parent = sub_msg["parent_header"]
257 parent = sub_msg["parent_header"]
258
258
259 if self.include_output(sub_msg):
259 if self.include_output(sub_msg):
260 if msg_type == 'status':
260 if msg_type == 'status':
261 self._execution_state = sub_msg["content"]["execution_state"]
261 self._execution_state = sub_msg["content"]["execution_state"]
262 elif msg_type == 'stream':
262 elif msg_type == 'stream':
263 if sub_msg["content"]["name"] == "stdout":
263 if sub_msg["content"]["name"] == "stdout":
264 if self._pending_clearoutput:
264 if self._pending_clearoutput:
265 print("\r", file=io.stdout, end="")
265 print("\r", file=io.stdout, end="")
266 self._pending_clearoutput = False
266 self._pending_clearoutput = False
267 print(sub_msg["content"]["text"], file=io.stdout, end="")
267 print(sub_msg["content"]["text"], file=io.stdout, end="")
268 io.stdout.flush()
268 io.stdout.flush()
269 elif sub_msg["content"]["name"] == "stderr":
269 elif sub_msg["content"]["name"] == "stderr":
270 if self._pending_clearoutput:
270 if self._pending_clearoutput:
271 print("\r", file=io.stderr, end="")
271 print("\r", file=io.stderr, end="")
272 self._pending_clearoutput = False
272 self._pending_clearoutput = False
273 print(sub_msg["content"]["text"], file=io.stderr, end="")
273 print(sub_msg["content"]["text"], file=io.stderr, end="")
274 io.stderr.flush()
274 io.stderr.flush()
275
275
276 elif msg_type == 'execute_result':
276 elif msg_type == 'execute_result':
277 if self._pending_clearoutput:
277 if self._pending_clearoutput:
278 print("\r", file=io.stdout, end="")
278 print("\r", file=io.stdout, end="")
279 self._pending_clearoutput = False
279 self._pending_clearoutput = False
280 self.execution_count = int(sub_msg["content"]["execution_count"])
280 self.execution_count = int(sub_msg["content"]["execution_count"])
281 if not self.from_here(sub_msg):
281 if not self.from_here(sub_msg):
282 sys.stdout.write(self.other_output_prefix)
282 sys.stdout.write(self.other_output_prefix)
283 format_dict = sub_msg["content"]["data"]
283 format_dict = sub_msg["content"]["data"]
284 self.handle_rich_data(format_dict)
284 self.handle_rich_data(format_dict)
285
285
286 # taken from DisplayHook.__call__:
286 # taken from DisplayHook.__call__:
287 hook = self.displayhook
287 hook = self.displayhook
288 hook.start_displayhook()
288 hook.start_displayhook()
289 hook.write_output_prompt()
289 hook.write_output_prompt()
290 hook.write_format_data(format_dict)
290 hook.write_format_data(format_dict)
291 hook.log_output(format_dict)
291 hook.log_output(format_dict)
292 hook.finish_displayhook()
292 hook.finish_displayhook()
293
293
294 elif msg_type == 'display_data':
294 elif msg_type == 'display_data':
295 data = sub_msg["content"]["data"]
295 data = sub_msg["content"]["data"]
296 handled = self.handle_rich_data(data)
296 handled = self.handle_rich_data(data)
297 if not handled:
297 if not handled:
298 if not self.from_here(sub_msg):
298 if not self.from_here(sub_msg):
299 sys.stdout.write(self.other_output_prefix)
299 sys.stdout.write(self.other_output_prefix)
300 # if it was an image, we handled it by now
300 # if it was an image, we handled it by now
301 if 'text/plain' in data:
301 if 'text/plain' in data:
302 print(data['text/plain'])
302 print(data['text/plain'])
303
303
304 elif msg_type == 'execute_input':
304 elif msg_type == 'execute_input':
305 content = sub_msg['content']
305 content = sub_msg['content']
306 self.execution_count = content['execution_count']
306 self.execution_count = content['execution_count']
307 if not self.from_here(sub_msg):
307 if not self.from_here(sub_msg):
308 sys.stdout.write(self.other_output_prefix)
308 sys.stdout.write(self.other_output_prefix)
309 sys.stdout.write(self.prompt_manager.render('in'))
309 sys.stdout.write(self.prompt_manager.render('in'))
310 sys.stdout.write(content['code'])
310 sys.stdout.write(content['code'])
311
311
312 elif msg_type == 'clear_output':
312 elif msg_type == 'clear_output':
313 if sub_msg["content"]["wait"]:
313 if sub_msg["content"]["wait"]:
314 self._pending_clearoutput = True
314 self._pending_clearoutput = True
315 else:
315 else:
316 print("\r", file=io.stdout, end="")
316 print("\r", file=io.stdout, end="")
317
317
318 _imagemime = {
318 _imagemime = {
319 'image/png': 'png',
319 'image/png': 'png',
320 'image/jpeg': 'jpeg',
320 'image/jpeg': 'jpeg',
321 'image/svg+xml': 'svg',
321 'image/svg+xml': 'svg',
322 }
322 }
323
323
324 def handle_rich_data(self, data):
324 def handle_rich_data(self, data):
325 for mime in self.mime_preference:
325 for mime in self.mime_preference:
326 if mime in data and mime in self._imagemime:
326 if mime in data and mime in self._imagemime:
327 self.handle_image(data, mime)
327 self.handle_image(data, mime)
328 return True
328 return True
329
329
330 def handle_image(self, data, mime):
330 def handle_image(self, data, mime):
331 handler = getattr(
331 handler = getattr(
332 self, 'handle_image_{0}'.format(self.image_handler), None)
332 self, 'handle_image_{0}'.format(self.image_handler), None)
333 if handler:
333 if handler:
334 handler(data, mime)
334 handler(data, mime)
335
335
336 def handle_image_PIL(self, data, mime):
336 def handle_image_PIL(self, data, mime):
337 if mime not in ('image/png', 'image/jpeg'):
337 if mime not in ('image/png', 'image/jpeg'):
338 return
338 return
339 import PIL.Image
339 import PIL.Image
340 raw = base64.decodestring(data[mime].encode('ascii'))
340 raw = base64.decodestring(data[mime].encode('ascii'))
341 img = PIL.Image.open(BytesIO(raw))
341 img = PIL.Image.open(BytesIO(raw))
342 img.show()
342 img.show()
343
343
344 def handle_image_stream(self, data, mime):
344 def handle_image_stream(self, data, mime):
345 raw = base64.decodestring(data[mime].encode('ascii'))
345 raw = base64.decodestring(data[mime].encode('ascii'))
346 imageformat = self._imagemime[mime]
346 imageformat = self._imagemime[mime]
347 fmt = dict(format=imageformat)
347 fmt = dict(format=imageformat)
348 args = [s.format(**fmt) for s in self.stream_image_handler]
348 args = [s.format(**fmt) for s in self.stream_image_handler]
349 with open(os.devnull, 'w') as devnull:
349 with open(os.devnull, 'w') as devnull:
350 proc = subprocess.Popen(
350 proc = subprocess.Popen(
351 args, stdin=subprocess.PIPE,
351 args, stdin=subprocess.PIPE,
352 stdout=devnull, stderr=devnull)
352 stdout=devnull, stderr=devnull)
353 proc.communicate(raw)
353 proc.communicate(raw)
354
354
355 def handle_image_tempfile(self, data, mime):
355 def handle_image_tempfile(self, data, mime):
356 raw = base64.decodestring(data[mime].encode('ascii'))
356 raw = base64.decodestring(data[mime].encode('ascii'))
357 imageformat = self._imagemime[mime]
357 imageformat = self._imagemime[mime]
358 filename = 'tmp.{0}'.format(imageformat)
358 filename = 'tmp.{0}'.format(imageformat)
359 with NamedFileInTemporaryDirectory(filename) as f, \
359 with NamedFileInTemporaryDirectory(filename) as f, \
360 open(os.devnull, 'w') as devnull:
360 open(os.devnull, 'w') as devnull:
361 f.write(raw)
361 f.write(raw)
362 f.flush()
362 f.flush()
363 fmt = dict(file=f.name, format=imageformat)
363 fmt = dict(file=f.name, format=imageformat)
364 args = [s.format(**fmt) for s in self.tempfile_image_handler]
364 args = [s.format(**fmt) for s in self.tempfile_image_handler]
365 subprocess.call(args, stdout=devnull, stderr=devnull)
365 subprocess.call(args, stdout=devnull, stderr=devnull)
366
366
367 def handle_image_callable(self, data, mime):
367 def handle_image_callable(self, data, mime):
368 self.callable_image_handler(data)
368 self.callable_image_handler(data)
369
369
370 def handle_input_request(self, msg_id, timeout=0.1):
370 def handle_input_request(self, msg_id, timeout=0.1):
371 """ Method to capture raw_input
371 """ Method to capture raw_input
372 """
372 """
373 req = self.client.stdin_channel.get_msg(timeout=timeout)
373 req = self.client.stdin_channel.get_msg(timeout=timeout)
374 # in case any iopub came while we were waiting:
374 # in case any iopub came while we were waiting:
375 self.handle_iopub(msg_id)
375 self.handle_iopub(msg_id)
376 if msg_id == req["parent_header"].get("msg_id"):
376 if msg_id == req["parent_header"].get("msg_id"):
377 # wrap SIGINT handler
377 # wrap SIGINT handler
378 real_handler = signal.getsignal(signal.SIGINT)
378 real_handler = signal.getsignal(signal.SIGINT)
379 def double_int(sig,frame):
379 def double_int(sig,frame):
380 # call real handler (forwards sigint to kernel),
380 # call real handler (forwards sigint to kernel),
381 # then raise local interrupt, stopping local raw_input
381 # then raise local interrupt, stopping local raw_input
382 real_handler(sig,frame)
382 real_handler(sig,frame)
383 raise KeyboardInterrupt
383 raise KeyboardInterrupt
384 signal.signal(signal.SIGINT, double_int)
384 signal.signal(signal.SIGINT, double_int)
385 content = req['content']
385 content = req['content']
386 read = getpass if content.get('password', False) else input
386 read = getpass if content.get('password', False) else input
387 try:
387 try:
388 raw_data = read(content["prompt"])
388 raw_data = read(content["prompt"])
389 except EOFError:
389 except EOFError:
390 # turn EOFError into EOF character
390 # turn EOFError into EOF character
391 raw_data = '\x04'
391 raw_data = '\x04'
392 except KeyboardInterrupt:
392 except KeyboardInterrupt:
393 sys.stdout.write('\n')
393 sys.stdout.write('\n')
394 return
394 return
395 finally:
395 finally:
396 # restore SIGINT handler
396 # restore SIGINT handler
397 signal.signal(signal.SIGINT, real_handler)
397 signal.signal(signal.SIGINT, real_handler)
398
398
399 # only send stdin reply if there *was not* another request
399 # only send stdin reply if there *was not* another request
400 # or execution finished while we were reading.
400 # or execution finished while we were reading.
401 if not (self.client.stdin_channel.msg_ready() or self.client.shell_channel.msg_ready()):
401 if not (self.client.stdin_channel.msg_ready() or self.client.shell_channel.msg_ready()):
402 self.client.stdin_channel.input(raw_data)
402 self.client.stdin_channel.input(raw_data)
403
403
404 def mainloop(self, display_banner=False):
404 def mainloop(self, display_banner=False):
405 while True:
405 while True:
406 try:
406 try:
407 self.interact(display_banner=display_banner)
407 self.interact(display_banner=display_banner)
408 #self.interact_with_readline()
408 #self.interact_with_readline()
409 # XXX for testing of a readline-decoupled repl loop, call
409 # XXX for testing of a readline-decoupled repl loop, call
410 # interact_with_readline above
410 # interact_with_readline above
411 break
411 break
412 except KeyboardInterrupt:
412 except KeyboardInterrupt:
413 # this should not be necessary, but KeyboardInterrupt
413 # this should not be necessary, but KeyboardInterrupt
414 # handling seems rather unpredictable...
414 # handling seems rather unpredictable...
415 self.write("\nKeyboardInterrupt in interact()\n")
415 self.write("\nKeyboardInterrupt in interact()\n")
416
416
417 self.client.shell_channel.shutdown()
417 self.client.shell_channel.shutdown()
418
418
419 def _banner1_default(self):
419 def _banner1_default(self):
420 return "IPython Console {version}\n".format(version=release.version)
420 return "IPython Console {version}\n".format(version=release.version)
421
421
422 def compute_banner(self):
422 def compute_banner(self):
423 super(ZMQTerminalInteractiveShell, self).compute_banner()
423 super(ZMQTerminalInteractiveShell, self).compute_banner()
424 if self.client and not self.kernel_banner:
424 if self.client and not self.kernel_banner:
425 msg_id = self.client.kernel_info()
425 msg_id = self.client.kernel_info()
426 while True:
426 while True:
427 try:
427 try:
428 reply = self.client.get_shell_msg(timeout=1)
428 reply = self.client.get_shell_msg(timeout=1)
429 except Empty:
429 except Empty:
430 break
430 break
431 else:
431 else:
432 if reply['parent_header'].get('msg_id') == msg_id:
432 if reply['parent_header'].get('msg_id') == msg_id:
433 self.kernel_banner = reply['content'].get('banner', '')
433 self.kernel_banner = reply['content'].get('banner', '')
434 break
434 break
435 self.banner += self.kernel_banner
435 self.banner += self.kernel_banner
436
436
437 def wait_for_kernel(self, timeout=None):
437 def wait_for_kernel(self, timeout=None):
438 """method to wait for a kernel to be ready"""
438 """method to wait for a kernel to be ready"""
439 tic = time.time()
439 tic = time.time()
440 self.client.hb_channel.unpause()
440 self.client.hb_channel.unpause()
441 while True:
441 while True:
442 msg_id = self.client.kernel_info()
442 msg_id = self.client.kernel_info()
443 reply = None
443 reply = None
444 while True:
444 while True:
445 try:
445 try:
446 reply = self.client.get_shell_msg(timeout=1)
446 reply = self.client.get_shell_msg(timeout=1)
447 except Empty:
447 except Empty:
448 break
448 break
449 else:
449 else:
450 if reply['parent_header'].get('msg_id') == msg_id:
450 if reply['parent_header'].get('msg_id') == msg_id:
451 return True
451 return True
452 if timeout is not None \
452 if timeout is not None \
453 and (time.time() - tic) > timeout \
453 and (time.time() - tic) > timeout \
454 and not self.client.hb_channel.is_beating():
454 and not self.client.hb_channel.is_beating():
455 # heart failed
455 # heart failed
456 return False
456 return False
457 return True
457 return True
458
458
459 def interact(self, display_banner=None):
459 def interact(self, display_banner=None):
460 """Closely emulate the interactive Python console."""
460 """Closely emulate the interactive Python console."""
461
461
462 # batch run -> do not interact
462 # batch run -> do not interact
463 if self.exit_now:
463 if self.exit_now:
464 return
464 return
465
465
466 if display_banner is None:
466 if display_banner is None:
467 display_banner = self.display_banner
467 display_banner = self.display_banner
468
468
469 if isinstance(display_banner, string_types):
469 if isinstance(display_banner, string_types):
470 self.show_banner(display_banner)
470 self.show_banner(display_banner)
471 elif display_banner:
471 elif display_banner:
472 self.show_banner()
472 self.show_banner()
473
473
474 more = False
474 more = False
475
475
476 # run a non-empty no-op, so that we don't get a prompt until
476 # run a non-empty no-op, so that we don't get a prompt until
477 # we know the kernel is ready. This keeps the connection
477 # we know the kernel is ready. This keeps the connection
478 # message above the first prompt.
478 # message above the first prompt.
479 if not self.wait_for_kernel(self.kernel_timeout):
479 if not self.wait_for_kernel(self.kernel_timeout):
480 error("Kernel did not respond\n")
480 error("Kernel did not respond\n")
481 return
481 return
482
482
483 if self.has_readline:
483 if self.has_readline:
484 self.readline_startup_hook(self.pre_readline)
484 self.readline_startup_hook(self.pre_readline)
485 hlen_b4_cell = self.readline.get_current_history_length()
485 hlen_b4_cell = self.readline.get_current_history_length()
486 else:
486 else:
487 hlen_b4_cell = 0
487 hlen_b4_cell = 0
488 # exit_now is set by a call to %Exit or %Quit, through the
488 # exit_now is set by a call to %Exit or %Quit, through the
489 # ask_exit callback.
489 # ask_exit callback.
490
490
491 while not self.exit_now:
491 while not self.exit_now:
492 if not self.client.is_alive():
492 if not self.client.is_alive():
493 # kernel died, prompt for action or exit
493 # kernel died, prompt for action or exit
494
494
495 action = "restart" if self.manager else "wait for restart"
495 action = "restart" if self.manager else "wait for restart"
496 ans = self.ask_yes_no("kernel died, %s ([y]/n)?" % action, default='y')
496 ans = self.ask_yes_no("kernel died, %s ([y]/n)?" % action, default='y')
497 if ans:
497 if ans:
498 if self.manager:
498 if self.manager:
499 self.manager.restart_kernel(True)
499 self.manager.restart_kernel(True)
500 self.wait_for_kernel(self.kernel_timeout)
500 self.wait_for_kernel(self.kernel_timeout)
501 else:
501 else:
502 self.exit_now = True
502 self.exit_now = True
503 continue
503 continue
504 try:
504 try:
505 # protect prompt block from KeyboardInterrupt
505 # protect prompt block from KeyboardInterrupt
506 # when sitting on ctrl-C
506 # when sitting on ctrl-C
507 self.hooks.pre_prompt_hook()
507 self.hooks.pre_prompt_hook()
508 if more:
508 if more:
509 try:
509 try:
510 prompt = self.prompt_manager.render('in2')
510 prompt = self.prompt_manager.render('in2')
511 except Exception:
511 except Exception:
512 self.showtraceback()
512 self.showtraceback()
513 if self.autoindent:
513 if self.autoindent:
514 self.rl_do_indent = True
514 self.rl_do_indent = True
515
515
516 else:
516 else:
517 try:
517 try:
518 prompt = self.separate_in + self.prompt_manager.render('in')
518 prompt = self.separate_in + self.prompt_manager.render('in')
519 except Exception:
519 except Exception:
520 self.showtraceback()
520 self.showtraceback()
521
521
522 line = self.raw_input(prompt)
522 line = self.raw_input(prompt)
523 if self.exit_now:
523 if self.exit_now:
524 # quick exit on sys.std[in|out] close
524 # quick exit on sys.std[in|out] close
525 break
525 break
526 if self.autoindent:
526 if self.autoindent:
527 self.rl_do_indent = False
527 self.rl_do_indent = False
528
528
529 except KeyboardInterrupt:
529 except KeyboardInterrupt:
530 #double-guard against keyboardinterrupts during kbdint handling
530 #double-guard against keyboardinterrupts during kbdint handling
531 try:
531 try:
532 self.write('\nKeyboardInterrupt\n')
532 self.write('\nKeyboardInterrupt\n')
533 source_raw = self.input_splitter.raw_reset()
533 source_raw = self.input_splitter.raw_reset()
534 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
534 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
535 more = False
535 more = False
536 except KeyboardInterrupt:
536 except KeyboardInterrupt:
537 pass
537 pass
538 except EOFError:
538 except EOFError:
539 if self.autoindent:
539 if self.autoindent:
540 self.rl_do_indent = False
540 self.rl_do_indent = False
541 if self.has_readline:
541 if self.has_readline:
542 self.readline_startup_hook(None)
542 self.readline_startup_hook(None)
543 self.write('\n')
543 self.write('\n')
544 self.exit()
544 self.exit()
545 except bdb.BdbQuit:
545 except bdb.BdbQuit:
546 warn('The Python debugger has exited with a BdbQuit exception.\n'
546 warn('The Python debugger has exited with a BdbQuit exception.\n'
547 'Because of how pdb handles the stack, it is impossible\n'
547 'Because of how pdb handles the stack, it is impossible\n'
548 'for IPython to properly format this particular exception.\n'
548 'for IPython to properly format this particular exception.\n'
549 'IPython will resume normal operation.')
549 'IPython will resume normal operation.')
550 except:
550 except:
551 # exceptions here are VERY RARE, but they can be triggered
551 # exceptions here are VERY RARE, but they can be triggered
552 # asynchronously by signal handlers, for example.
552 # asynchronously by signal handlers, for example.
553 self.showtraceback()
553 self.showtraceback()
554 else:
554 else:
555 try:
555 try:
556 self.input_splitter.push(line)
556 self.input_splitter.push(line)
557 more = self.input_splitter.push_accepts_more()
557 more = self.input_splitter.push_accepts_more()
558 except SyntaxError:
558 except SyntaxError:
559 # Run the code directly - run_cell takes care of displaying
559 # Run the code directly - run_cell takes care of displaying
560 # the exception.
560 # the exception.
561 more = False
561 more = False
562 if (self.SyntaxTB.last_syntax_error and
562 if (self.SyntaxTB.last_syntax_error and
563 self.autoedit_syntax):
563 self.autoedit_syntax):
564 self.edit_syntax_error()
564 self.edit_syntax_error()
565 if not more:
565 if not more:
566 source_raw = self.input_splitter.raw_reset()
566 source_raw = self.input_splitter.raw_reset()
567 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
567 hlen_b4_cell = self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
568 self.run_cell(source_raw)
568 self.run_cell(source_raw)
569
569
570
570
571 # Turn off the exit flag, so the mainloop can be restarted if desired
571 # Turn off the exit flag, so the mainloop can be restarted if desired
572 self.exit_now = False
572 self.exit_now = False
573
574 def init_history(self):
575 """Sets up the command history. """
576 self.history_manager = ZMQHistoryManager(client=self.client)
577 self.configurables.append(self.history_manager)
578
General Comments 0
You need to be logged in to leave comments. Login now