##// END OF EJS Templates
Fix regression in embed() from pull-request #2096....
Bradley M. Froehle -
Show More
@@ -1,298 +1,300 b''
1 1 # encoding: utf-8
2 2 """
3 3 An embedded IPython shell.
4 4
5 5 Authors:
6 6
7 7 * Brian Granger
8 8 * Fernando Perez
9 9
10 10 Notes
11 11 -----
12 12 """
13 13
14 14 #-----------------------------------------------------------------------------
15 15 # Copyright (C) 2008-2011 The IPython Development Team
16 16 #
17 17 # Distributed under the terms of the BSD License. The full license is in
18 18 # the file COPYING, distributed as part of this software.
19 19 #-----------------------------------------------------------------------------
20 20
21 21 #-----------------------------------------------------------------------------
22 22 # Imports
23 23 #-----------------------------------------------------------------------------
24 24
25 25 from __future__ import with_statement
26 26
27 27 import sys
28 28 import warnings
29 29
30 30 # We need to use nested to support python 2.6, once we move to >=2.7, we can
31 31 # use the with keyword's new builtin support for nested managers
32 32 try:
33 33 from contextlib import nested
34 34 except:
35 35 from IPython.utils.nested_context import nested
36 36
37 37 from IPython.core import ultratb, compilerop
38 38 from IPython.core.magic import Magics, magics_class, line_magic
39 39 from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
40 40 from IPython.frontend.terminal.ipapp import load_default_config
41 41
42 42 from IPython.utils.traitlets import Bool, CBool, Unicode
43 43 from IPython.utils.io import ask_yes_no
44 44
45 45
46 46 #-----------------------------------------------------------------------------
47 47 # Classes and functions
48 48 #-----------------------------------------------------------------------------
49 49
50 50 # This is an additional magic that is exposed in embedded shells.
51 51 @magics_class
52 52 class EmbeddedMagics(Magics):
53 53
54 54 @line_magic
55 55 def kill_embedded(self, parameter_s=''):
56 56 """%kill_embedded : deactivate for good the current embedded IPython.
57 57
58 58 This function (after asking for confirmation) sets an internal flag so
59 59 that an embedded IPython will never activate again. This is useful to
60 60 permanently disable a shell that is being called inside a loop: once
61 61 you've figured out what you needed from it, you may then kill it and
62 62 the program will then continue to run without the interactive shell
63 63 interfering again.
64 64 """
65 65
66 66 kill = ask_yes_no("Are you sure you want to kill this embedded instance "
67 67 "(y/n)? [y/N] ",'n')
68 68 if kill:
69 69 self.shell.embedded_active = False
70 70 print ("This embedded IPython will not reactivate anymore "
71 71 "once you exit.")
72 72
73 73
74 74 class InteractiveShellEmbed(TerminalInteractiveShell):
75 75
76 76 dummy_mode = Bool(False)
77 77 exit_msg = Unicode('')
78 78 embedded = CBool(True)
79 79 embedded_active = CBool(True)
80 80 # Like the base class display_banner is not configurable, but here it
81 81 # is True by default.
82 82 display_banner = CBool(True)
83 83
84 84 def __init__(self, config=None, ipython_dir=None, user_ns=None,
85 85 user_module=None, custom_exceptions=((),None),
86 86 usage=None, banner1=None, banner2=None,
87 87 display_banner=None, exit_msg=u'', user_global_ns=None):
88 88
89 89 if user_global_ns is not None:
90 90 warnings.warn("user_global_ns has been replaced by user_module. The\
91 91 parameter will be ignored.", DeprecationWarning)
92 92
93 93 super(InteractiveShellEmbed,self).__init__(
94 94 config=config, ipython_dir=ipython_dir, user_ns=user_ns,
95 95 user_module=user_module, custom_exceptions=custom_exceptions,
96 96 usage=usage, banner1=banner1, banner2=banner2,
97 97 display_banner=display_banner
98 98 )
99 99
100 100 self.exit_msg = exit_msg
101 101
102 102 # don't use the ipython crash handler so that user exceptions aren't
103 103 # trapped
104 104 sys.excepthook = ultratb.FormattedTB(color_scheme=self.colors,
105 105 mode=self.xmode,
106 106 call_pdb=self.pdb)
107 107
108 108 def init_sys_modules(self):
109 109 pass
110 110
111 111 def init_magics(self):
112 112 super(InteractiveShellEmbed, self).init_magics()
113 113 self.register_magics(EmbeddedMagics)
114 114
115 115 def __call__(self, header='', local_ns=None, module=None, dummy=None,
116 116 stack_depth=1, global_ns=None, compile_flags=None):
117 117 """Activate the interactive interpreter.
118 118
119 119 __call__(self,header='',local_ns=None,module=None,dummy=None) -> Start
120 120 the interpreter shell with the given local and global namespaces, and
121 121 optionally print a header string at startup.
122 122
123 123 The shell can be globally activated/deactivated using the
124 124 dummy_mode attribute. This allows you to turn off a shell used
125 125 for debugging globally.
126 126
127 127 However, *each* time you call the shell you can override the current
128 128 state of dummy_mode with the optional keyword parameter 'dummy'. For
129 129 example, if you set dummy mode on with IPShell.dummy_mode = True, you
130 130 can still have a specific call work by making it as IPShell(dummy=False).
131 131 """
132 132
133 133 # If the user has turned it off, go away
134 134 if not self.embedded_active:
135 135 return
136 136
137 137 # Normal exits from interactive mode set this flag, so the shell can't
138 138 # re-enter (it checks this variable at the start of interactive mode).
139 139 self.exit_now = False
140 140
141 141 # Allow the dummy parameter to override the global __dummy_mode
142 142 if dummy or (dummy != 0 and self.dummy_mode):
143 143 return
144 144
145 145 if self.has_readline:
146 146 self.set_readline_completer()
147 147
148 148 # self.banner is auto computed
149 149 if header:
150 150 self.old_banner2 = self.banner2
151 151 self.banner2 = self.banner2 + '\n' + header + '\n'
152 152 else:
153 153 self.old_banner2 = ''
154 154
155 155 # Call the embedding code with a stack depth of 1 so it can skip over
156 156 # our call and get the original caller's namespaces.
157 157 self.mainloop(local_ns, module, stack_depth=stack_depth,
158 158 global_ns=global_ns, compile_flags=compile_flags)
159 159
160 160 self.banner2 = self.old_banner2
161 161
162 162 if self.exit_msg is not None:
163 163 print self.exit_msg
164 164
165 165 def mainloop(self, local_ns=None, module=None, stack_depth=0,
166 166 display_banner=None, global_ns=None, compile_flags=None):
167 167 """Embeds IPython into a running python program.
168 168
169 169 Input:
170 170
171 171 - header: An optional header message can be specified.
172 172
173 173 - local_ns, module: working local namespace (a dict) and module (a
174 174 module or similar object). If given as None, they are automatically
175 175 taken from the scope where the shell was called, so that
176 176 program variables become visible.
177 177
178 178 - stack_depth: specifies how many levels in the stack to go to
179 179 looking for namespaces (when local_ns or module is None). This
180 180 allows an intermediate caller to make sure that this function gets
181 181 the namespace from the intended level in the stack. By default (0)
182 182 it will get its locals and globals from the immediate caller.
183 183
184 184 - compile_flags: A bit field identifying the __future__ features
185 185 that are enabled, as passed to the builtin `compile` function. If
186 186 given as None, they are automatically taken from the scope where the
187 187 shell was called.
188 188
189 189 Warning: it's possible to use this in a program which is being run by
190 190 IPython itself (via %run), but some funny things will happen (a few
191 191 globals get overwritten). In the future this will be cleaned up, as
192 192 there is no fundamental reason why it can't work perfectly."""
193 193
194 194 if (global_ns is not None) and (module is None):
195 195 class DummyMod(object):
196 196 """A dummy module object for embedded IPython."""
197 197 pass
198 198 warnings.warn("global_ns is deprecated, use module instead.", DeprecationWarning)
199 199 module = DummyMod()
200 200 module.__dict__ = global_ns
201 201
202 202 # Get locals and globals from caller
203 if (local_ns is None or module is None) and self.default_user_namespaces:
203 if ((local_ns is None or module is None or compile_flags is None)
204 and self.default_user_namespaces):
204 205 call_frame = sys._getframe(stack_depth).f_back
205 206
206 207 if local_ns is None:
207 208 local_ns = call_frame.f_locals
208 209 if module is None:
209 210 global_ns = call_frame.f_globals
210 211 module = sys.modules[global_ns['__name__']]
211 212 if compile_flags is None:
212 213 compile_flags = (call_frame.f_code.co_flags &
213 214 compilerop.PyCF_MASK)
214 215
215 216 # Save original namespace and module so we can restore them after
216 217 # embedding; otherwise the shell doesn't shut down correctly.
217 218 orig_user_module = self.user_module
218 219 orig_user_ns = self.user_ns
219 220 orig_compile_flags = self.compile.flags
220 221
221 222 # Update namespaces and fire up interpreter
222 223
223 224 # The global one is easy, we can just throw it in
224 225 if module is not None:
225 226 self.user_module = module
226 227
227 228 # But the user/local one is tricky: ipython needs it to store internal
228 229 # data, but we also need the locals. We'll throw our hidden variables
229 230 # like _ih and get_ipython() into the local namespace, but delete them
230 231 # later.
231 232 if local_ns is not None:
232 233 self.user_ns = local_ns
233 234 self.init_user_ns()
234 235
235 236 # Compiler flags
236 self.compile.flags = compile_flags
237 if compile_flags is not None:
238 self.compile.flags = compile_flags
237 239
238 240 # Patch for global embedding to make sure that things don't overwrite
239 241 # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
240 242 # FIXME. Test this a bit more carefully (the if.. is new)
241 243 # N.B. This can't now ever be called. Not sure what it was for.
242 244 # And now, since it wasn't called in the previous version, I'm
243 245 # commenting out these lines so they can't be called with my new changes
244 246 # --TK, 2011-12-10
245 247 #if local_ns is None and module is None:
246 248 # self.user_global_ns.update(__main__.__dict__)
247 249
248 250 # make sure the tab-completer has the correct frame information, so it
249 251 # actually completes using the frame's locals/globals
250 252 self.set_completer_frame()
251 253
252 254 with nested(self.builtin_trap, self.display_trap):
253 255 self.interact(display_banner=display_banner)
254 256
255 257 # now, purge out the local namespace of IPython's hidden variables.
256 258 if local_ns is not None:
257 259 for name in self.user_ns_hidden:
258 260 local_ns.pop(name, None)
259 261
260 262 # Restore original namespace so shell can shut down when we exit.
261 263 self.user_module = orig_user_module
262 264 self.user_ns = orig_user_ns
263 265 self.compile.flags = orig_compile_flags
264 266
265 267 _embedded_shell = None
266 268
267 269
268 270 def embed(**kwargs):
269 271 """Call this to embed IPython at the current point in your program.
270 272
271 273 The first invocation of this will create an :class:`InteractiveShellEmbed`
272 274 instance and then call it. Consecutive calls just call the already
273 275 created instance.
274 276
275 277 Here is a simple example::
276 278
277 279 from IPython import embed
278 280 a = 10
279 281 b = 20
280 282 embed('First time')
281 283 c = 30
282 284 d = 40
283 285 embed
284 286
285 287 Full customization can be done by passing a :class:`Struct` in as the
286 288 config argument.
287 289 """
288 290 config = kwargs.get('config')
289 291 header = kwargs.pop('header', u'')
290 292 compile_flags = kwargs.pop('compile_flags', None)
291 293 if config is None:
292 294 config = load_default_config()
293 295 config.InteractiveShellEmbed = config.TerminalInteractiveShell
294 296 kwargs['config'] = config
295 297 global _embedded_shell
296 298 if _embedded_shell is None:
297 299 _embedded_shell = InteractiveShellEmbed(**kwargs)
298 300 _embedded_shell(header=header, stack_depth=2, compile_flags=compile_flags)
General Comments 0
You need to be logged in to leave comments. Login now