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