Show More
@@ -1,507 +1,507 b'' | |||
|
1 | 1 | """Implementation of code management magic functions. |
|
2 | 2 | """ |
|
3 | 3 | #----------------------------------------------------------------------------- |
|
4 | 4 | # Copyright (c) 2012 The IPython Development Team. |
|
5 | 5 | # |
|
6 | 6 | # Distributed under the terms of the Modified BSD License. |
|
7 | 7 | # |
|
8 | 8 | # The full license is in the file COPYING.txt, distributed with this software. |
|
9 | 9 | #----------------------------------------------------------------------------- |
|
10 | 10 | |
|
11 | 11 | #----------------------------------------------------------------------------- |
|
12 | 12 | # Imports |
|
13 | 13 | #----------------------------------------------------------------------------- |
|
14 | 14 | |
|
15 | 15 | # Stdlib |
|
16 | 16 | import inspect |
|
17 | 17 | import io |
|
18 | 18 | import json |
|
19 | 19 | import os |
|
20 | 20 | import sys |
|
21 | 21 | from urllib2 import urlopen |
|
22 | 22 | |
|
23 | 23 | # Our own packages |
|
24 | 24 | from IPython.core.error import TryNext |
|
25 | 25 | from IPython.core.macro import Macro |
|
26 | 26 | from IPython.core.magic import Magics, magics_class, line_magic |
|
27 | 27 | from IPython.testing.skipdoctest import skip_doctest |
|
28 | 28 | from IPython.utils import openpy |
|
29 | 29 | from IPython.utils import py3compat |
|
30 | 30 | from IPython.utils.io import file_read |
|
31 | 31 | from IPython.utils.path import get_py_filename, unquote_filename |
|
32 | 32 | from IPython.utils.warn import warn |
|
33 | 33 | |
|
34 | 34 | #----------------------------------------------------------------------------- |
|
35 | 35 | # Magic implementation classes |
|
36 | 36 | #----------------------------------------------------------------------------- |
|
37 | 37 | |
|
38 | 38 | # Used for exception handling in magic_edit |
|
39 | 39 | class MacroToEdit(ValueError): pass |
|
40 | 40 | |
|
41 | 41 | |
|
42 | 42 | @magics_class |
|
43 | 43 | class CodeMagics(Magics): |
|
44 | 44 | """Magics related to code management (loading, saving, editing, ...).""" |
|
45 | 45 | |
|
46 | 46 | @line_magic |
|
47 | 47 | def save(self, parameter_s=''): |
|
48 | 48 | """Save a set of lines or a macro to a given filename. |
|
49 | 49 | |
|
50 | 50 | Usage:\\ |
|
51 | 51 | %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ... |
|
52 | 52 | |
|
53 | 53 | Options: |
|
54 | 54 | |
|
55 | 55 | -r: use 'raw' input. By default, the 'processed' history is used, |
|
56 | 56 | so that magics are loaded in their transformed version to valid |
|
57 | 57 | Python. If this option is given, the raw input as typed as the |
|
58 | 58 | command line is used instead. |
|
59 | 59 | |
|
60 | 60 | This function uses the same syntax as %history for input ranges, |
|
61 | 61 | then saves the lines to the filename you specify. |
|
62 | 62 | |
|
63 | 63 | It adds a '.py' extension to the file if you don't do so yourself, and |
|
64 | 64 | it asks for confirmation before overwriting existing files.""" |
|
65 | 65 | |
|
66 | 66 | opts,args = self.parse_options(parameter_s,'r',mode='list') |
|
67 | 67 | fname, codefrom = unquote_filename(args[0]), " ".join(args[1:]) |
|
68 | 68 | if not fname.endswith('.py'): |
|
69 | 69 | fname += '.py' |
|
70 | 70 | if os.path.isfile(fname): |
|
71 | 71 | overwrite = self.shell.ask_yes_no('File `%s` exists. Overwrite (y/[N])? ' % fname, default='n') |
|
72 | 72 | if not overwrite : |
|
73 | 73 | print 'Operation cancelled.' |
|
74 | 74 | return |
|
75 | 75 | try: |
|
76 | 76 | cmds = self.shell.find_user_code(codefrom, 'r' in opts) |
|
77 | 77 | except (TypeError, ValueError) as e: |
|
78 | 78 | print e.args[0] |
|
79 | 79 | return |
|
80 | 80 | with io.open(fname,'w', encoding="utf-8") as f: |
|
81 | 81 | f.write(u"# coding: utf-8\n") |
|
82 | 82 | f.write(py3compat.cast_unicode(cmds)) |
|
83 | 83 | print 'The following commands were written to file `%s`:' % fname |
|
84 | 84 | print cmds |
|
85 | 85 | |
|
86 | 86 | @line_magic |
|
87 | 87 | def pastebin(self, parameter_s=''): |
|
88 | 88 | """Upload code to Github's Gist paste bin, returning the URL. |
|
89 | 89 | |
|
90 | 90 | Usage:\\ |
|
91 | 91 | %pastebin [-d "Custom description"] 1-7 |
|
92 | 92 | |
|
93 | 93 | The argument can be an input history range, a filename, or the name of a |
|
94 | 94 | string or macro. |
|
95 | 95 | |
|
96 | 96 | Options: |
|
97 | 97 | |
|
98 | 98 | -d: Pass a custom description for the gist. The default will say |
|
99 | 99 | "Pasted from IPython". |
|
100 | 100 | """ |
|
101 | 101 | opts, args = self.parse_options(parameter_s, 'd:') |
|
102 | 102 | |
|
103 | 103 | try: |
|
104 | 104 | code = self.shell.find_user_code(args) |
|
105 | 105 | except (ValueError, TypeError) as e: |
|
106 | 106 | print e.args[0] |
|
107 | 107 | return |
|
108 | 108 | |
|
109 | 109 | post_data = json.dumps({ |
|
110 | 110 | "description": opts.get('d', "Pasted from IPython"), |
|
111 | 111 | "public": True, |
|
112 | 112 | "files": { |
|
113 | 113 | "file1.py": { |
|
114 | 114 | "content": code |
|
115 | 115 | } |
|
116 | 116 | } |
|
117 | 117 | }).encode('utf-8') |
|
118 | 118 | |
|
119 | 119 | response = urlopen("https://api.github.com/gists", post_data) |
|
120 | 120 | response_data = json.loads(response.read().decode('utf-8')) |
|
121 | 121 | return response_data['html_url'] |
|
122 | 122 | |
|
123 | 123 | @line_magic |
|
124 | 124 | def loadpy(self, arg_s): |
|
125 | 125 | """Alias of `%load` |
|
126 | 126 | |
|
127 | 127 | `%loadpy` has gained some flexibility and droped the requirement of a `.py` |
|
128 | 128 | extension. So it has been renamed simply into %load. You can look at |
|
129 | 129 | `%load`'s docstring for more info. |
|
130 | 130 | """ |
|
131 |
self. |
|
|
131 | self.load(arg_s) | |
|
132 | 132 | |
|
133 | 133 | @line_magic |
|
134 | 134 | def load(self, arg_s): |
|
135 | 135 | """Load code into the current frontend. |
|
136 | 136 | |
|
137 | 137 | Usage:\\ |
|
138 | 138 | %load [options] source |
|
139 | 139 | |
|
140 | 140 | where source can be a filename, URL, input history range or macro |
|
141 | 141 | |
|
142 | 142 | Options: |
|
143 | 143 | -------- |
|
144 | 144 | -y : Don't ask confirmation for loading source above 200 000 characters. |
|
145 | 145 | |
|
146 | 146 | This magic command can either take a local filename, a URL, an history |
|
147 | 147 | range (see %history) or a macro as argument, it will prompt for |
|
148 | 148 | confirmation before loading source with more than 200 000 characters, unless |
|
149 | 149 | -y flag is passed or if the frontend does not support raw_input:: |
|
150 | 150 | |
|
151 | 151 | %load myscript.py |
|
152 | 152 | %load 7-27 |
|
153 | 153 | %load myMacro |
|
154 | 154 | %load http://www.example.com/myscript.py |
|
155 | 155 | """ |
|
156 | 156 | opts,args = self.parse_options(arg_s,'y') |
|
157 | 157 | |
|
158 | 158 | contents = self.shell.find_user_code(args) |
|
159 | 159 | l = len(contents) |
|
160 | 160 | |
|
161 | 161 | # 200 000 is ~ 2500 full 80 caracter lines |
|
162 | 162 | # so in average, more than 5000 lines |
|
163 | 163 | if l > 200000 and 'y' not in opts: |
|
164 | 164 | try: |
|
165 | 165 | ans = self.shell.ask_yes_no(("The text you're trying to load seems pretty big"\ |
|
166 | 166 | " (%d characters). Continue (y/[N]) ?" % l), default='n' ) |
|
167 | 167 | except StdinNotImplementedError: |
|
168 | 168 | #asume yes if raw input not implemented |
|
169 | 169 | ans = True |
|
170 | 170 | |
|
171 | 171 | if ans is False : |
|
172 | 172 | print 'Operation cancelled.' |
|
173 | 173 | return |
|
174 | 174 | |
|
175 | 175 | self.shell.set_next_input(contents) |
|
176 | 176 | |
|
177 | 177 | @staticmethod |
|
178 | 178 | def _find_edit_target(shell, args, opts, last_call): |
|
179 | 179 | """Utility method used by magic_edit to find what to edit.""" |
|
180 | 180 | |
|
181 | 181 | def make_filename(arg): |
|
182 | 182 | "Make a filename from the given args" |
|
183 | 183 | arg = unquote_filename(arg) |
|
184 | 184 | try: |
|
185 | 185 | filename = get_py_filename(arg) |
|
186 | 186 | except IOError: |
|
187 | 187 | # If it ends with .py but doesn't already exist, assume we want |
|
188 | 188 | # a new file. |
|
189 | 189 | if arg.endswith('.py'): |
|
190 | 190 | filename = arg |
|
191 | 191 | else: |
|
192 | 192 | filename = None |
|
193 | 193 | return filename |
|
194 | 194 | |
|
195 | 195 | # Set a few locals from the options for convenience: |
|
196 | 196 | opts_prev = 'p' in opts |
|
197 | 197 | opts_raw = 'r' in opts |
|
198 | 198 | |
|
199 | 199 | # custom exceptions |
|
200 | 200 | class DataIsObject(Exception): pass |
|
201 | 201 | |
|
202 | 202 | # Default line number value |
|
203 | 203 | lineno = opts.get('n',None) |
|
204 | 204 | |
|
205 | 205 | if opts_prev: |
|
206 | 206 | args = '_%s' % last_call[0] |
|
207 | 207 | if not shell.user_ns.has_key(args): |
|
208 | 208 | args = last_call[1] |
|
209 | 209 | |
|
210 | 210 | # use last_call to remember the state of the previous call, but don't |
|
211 | 211 | # let it be clobbered by successive '-p' calls. |
|
212 | 212 | try: |
|
213 | 213 | last_call[0] = shell.displayhook.prompt_count |
|
214 | 214 | if not opts_prev: |
|
215 | 215 | last_call[1] = args |
|
216 | 216 | except: |
|
217 | 217 | pass |
|
218 | 218 | |
|
219 | 219 | # by default this is done with temp files, except when the given |
|
220 | 220 | # arg is a filename |
|
221 | 221 | use_temp = True |
|
222 | 222 | |
|
223 | 223 | data = '' |
|
224 | 224 | |
|
225 | 225 | # First, see if the arguments should be a filename. |
|
226 | 226 | filename = make_filename(args) |
|
227 | 227 | if filename: |
|
228 | 228 | use_temp = False |
|
229 | 229 | elif args: |
|
230 | 230 | # Mode where user specifies ranges of lines, like in %macro. |
|
231 | 231 | data = shell.extract_input_lines(args, opts_raw) |
|
232 | 232 | if not data: |
|
233 | 233 | try: |
|
234 | 234 | # Load the parameter given as a variable. If not a string, |
|
235 | 235 | # process it as an object instead (below) |
|
236 | 236 | |
|
237 | 237 | #print '*** args',args,'type',type(args) # dbg |
|
238 | 238 | data = eval(args, shell.user_ns) |
|
239 | 239 | if not isinstance(data, basestring): |
|
240 | 240 | raise DataIsObject |
|
241 | 241 | |
|
242 | 242 | except (NameError,SyntaxError): |
|
243 | 243 | # given argument is not a variable, try as a filename |
|
244 | 244 | filename = make_filename(args) |
|
245 | 245 | if filename is None: |
|
246 | 246 | warn("Argument given (%s) can't be found as a variable " |
|
247 | 247 | "or as a filename." % args) |
|
248 | 248 | return |
|
249 | 249 | use_temp = False |
|
250 | 250 | |
|
251 | 251 | except DataIsObject: |
|
252 | 252 | # macros have a special edit function |
|
253 | 253 | if isinstance(data, Macro): |
|
254 | 254 | raise MacroToEdit(data) |
|
255 | 255 | |
|
256 | 256 | # For objects, try to edit the file where they are defined |
|
257 | 257 | try: |
|
258 | 258 | filename = inspect.getabsfile(data) |
|
259 | 259 | if 'fakemodule' in filename.lower() and \ |
|
260 | 260 | inspect.isclass(data): |
|
261 | 261 | # class created by %edit? Try to find source |
|
262 | 262 | # by looking for method definitions instead, the |
|
263 | 263 | # __module__ in those classes is FakeModule. |
|
264 | 264 | attrs = [getattr(data, aname) for aname in dir(data)] |
|
265 | 265 | for attr in attrs: |
|
266 | 266 | if not inspect.ismethod(attr): |
|
267 | 267 | continue |
|
268 | 268 | filename = inspect.getabsfile(attr) |
|
269 | 269 | if filename and \ |
|
270 | 270 | 'fakemodule' not in filename.lower(): |
|
271 | 271 | # change the attribute to be the edit |
|
272 | 272 | # target instead |
|
273 | 273 | data = attr |
|
274 | 274 | break |
|
275 | 275 | |
|
276 | 276 | datafile = 1 |
|
277 | 277 | except TypeError: |
|
278 | 278 | filename = make_filename(args) |
|
279 | 279 | datafile = 1 |
|
280 | 280 | warn('Could not find file where `%s` is defined.\n' |
|
281 | 281 | 'Opening a file named `%s`' % (args, filename)) |
|
282 | 282 | # Now, make sure we can actually read the source (if it was |
|
283 | 283 | # in a temp file it's gone by now). |
|
284 | 284 | if datafile: |
|
285 | 285 | try: |
|
286 | 286 | if lineno is None: |
|
287 | 287 | lineno = inspect.getsourcelines(data)[1] |
|
288 | 288 | except IOError: |
|
289 | 289 | filename = make_filename(args) |
|
290 | 290 | if filename is None: |
|
291 | 291 | warn('The file `%s` where `%s` was defined ' |
|
292 | 292 | 'cannot be read.' % (filename, data)) |
|
293 | 293 | return |
|
294 | 294 | use_temp = False |
|
295 | 295 | |
|
296 | 296 | if use_temp: |
|
297 | 297 | filename = shell.mktempfile(data) |
|
298 | 298 | print 'IPython will make a temporary file named:',filename |
|
299 | 299 | |
|
300 | 300 | return filename, lineno, use_temp |
|
301 | 301 | |
|
302 | 302 | def _edit_macro(self,mname,macro): |
|
303 | 303 | """open an editor with the macro data in a file""" |
|
304 | 304 | filename = self.shell.mktempfile(macro.value) |
|
305 | 305 | self.shell.hooks.editor(filename) |
|
306 | 306 | |
|
307 | 307 | # and make a new macro object, to replace the old one |
|
308 | 308 | mfile = open(filename) |
|
309 | 309 | mvalue = mfile.read() |
|
310 | 310 | mfile.close() |
|
311 | 311 | self.shell.user_ns[mname] = Macro(mvalue) |
|
312 | 312 | |
|
313 | 313 | @line_magic |
|
314 | 314 | def ed(self, parameter_s=''): |
|
315 | 315 | """Alias to %edit.""" |
|
316 | 316 | return self.edit(parameter_s) |
|
317 | 317 | |
|
318 | 318 | @skip_doctest |
|
319 | 319 | @line_magic |
|
320 | 320 | def edit(self, parameter_s='',last_call=['','']): |
|
321 | 321 | """Bring up an editor and execute the resulting code. |
|
322 | 322 | |
|
323 | 323 | Usage: |
|
324 | 324 | %edit [options] [args] |
|
325 | 325 | |
|
326 | 326 | %edit runs IPython's editor hook. The default version of this hook is |
|
327 | 327 | set to call the editor specified by your $EDITOR environment variable. |
|
328 | 328 | If this isn't found, it will default to vi under Linux/Unix and to |
|
329 | 329 | notepad under Windows. See the end of this docstring for how to change |
|
330 | 330 | the editor hook. |
|
331 | 331 | |
|
332 | 332 | You can also set the value of this editor via the |
|
333 | 333 | ``TerminalInteractiveShell.editor`` option in your configuration file. |
|
334 | 334 | This is useful if you wish to use a different editor from your typical |
|
335 | 335 | default with IPython (and for Windows users who typically don't set |
|
336 | 336 | environment variables). |
|
337 | 337 | |
|
338 | 338 | This command allows you to conveniently edit multi-line code right in |
|
339 | 339 | your IPython session. |
|
340 | 340 | |
|
341 | 341 | If called without arguments, %edit opens up an empty editor with a |
|
342 | 342 | temporary file and will execute the contents of this file when you |
|
343 | 343 | close it (don't forget to save it!). |
|
344 | 344 | |
|
345 | 345 | |
|
346 | 346 | Options: |
|
347 | 347 | |
|
348 | 348 | -n <number>: open the editor at a specified line number. By default, |
|
349 | 349 | the IPython editor hook uses the unix syntax 'editor +N filename', but |
|
350 | 350 | you can configure this by providing your own modified hook if your |
|
351 | 351 | favorite editor supports line-number specifications with a different |
|
352 | 352 | syntax. |
|
353 | 353 | |
|
354 | 354 | -p: this will call the editor with the same data as the previous time |
|
355 | 355 | it was used, regardless of how long ago (in your current session) it |
|
356 | 356 | was. |
|
357 | 357 | |
|
358 | 358 | -r: use 'raw' input. This option only applies to input taken from the |
|
359 | 359 | user's history. By default, the 'processed' history is used, so that |
|
360 | 360 | magics are loaded in their transformed version to valid Python. If |
|
361 | 361 | this option is given, the raw input as typed as the command line is |
|
362 | 362 | used instead. When you exit the editor, it will be executed by |
|
363 | 363 | IPython's own processor. |
|
364 | 364 | |
|
365 | 365 | -x: do not execute the edited code immediately upon exit. This is |
|
366 | 366 | mainly useful if you are editing programs which need to be called with |
|
367 | 367 | command line arguments, which you can then do using %run. |
|
368 | 368 | |
|
369 | 369 | |
|
370 | 370 | Arguments: |
|
371 | 371 | |
|
372 | 372 | If arguments are given, the following possibilities exist: |
|
373 | 373 | |
|
374 | 374 | - If the argument is a filename, IPython will load that into the |
|
375 | 375 | editor. It will execute its contents with execfile() when you exit, |
|
376 | 376 | loading any code in the file into your interactive namespace. |
|
377 | 377 | |
|
378 | 378 | - The arguments are ranges of input history, e.g. "7 ~1/4-6". |
|
379 | 379 | The syntax is the same as in the %history magic. |
|
380 | 380 | |
|
381 | 381 | - If the argument is a string variable, its contents are loaded |
|
382 | 382 | into the editor. You can thus edit any string which contains |
|
383 | 383 | python code (including the result of previous edits). |
|
384 | 384 | |
|
385 | 385 | - If the argument is the name of an object (other than a string), |
|
386 | 386 | IPython will try to locate the file where it was defined and open the |
|
387 | 387 | editor at the point where it is defined. You can use `%edit function` |
|
388 | 388 | to load an editor exactly at the point where 'function' is defined, |
|
389 | 389 | edit it and have the file be executed automatically. |
|
390 | 390 | |
|
391 | 391 | - If the object is a macro (see %macro for details), this opens up your |
|
392 | 392 | specified editor with a temporary file containing the macro's data. |
|
393 | 393 | Upon exit, the macro is reloaded with the contents of the file. |
|
394 | 394 | |
|
395 | 395 | Note: opening at an exact line is only supported under Unix, and some |
|
396 | 396 | editors (like kedit and gedit up to Gnome 2.8) do not understand the |
|
397 | 397 | '+NUMBER' parameter necessary for this feature. Good editors like |
|
398 | 398 | (X)Emacs, vi, jed, pico and joe all do. |
|
399 | 399 | |
|
400 | 400 | After executing your code, %edit will return as output the code you |
|
401 | 401 | typed in the editor (except when it was an existing file). This way |
|
402 | 402 | you can reload the code in further invocations of %edit as a variable, |
|
403 | 403 | via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of |
|
404 | 404 | the output. |
|
405 | 405 | |
|
406 | 406 | Note that %edit is also available through the alias %ed. |
|
407 | 407 | |
|
408 | 408 | This is an example of creating a simple function inside the editor and |
|
409 | 409 | then modifying it. First, start up the editor:: |
|
410 | 410 | |
|
411 | 411 | In [1]: ed |
|
412 | 412 | Editing... done. Executing edited code... |
|
413 | 413 | Out[1]: 'def foo():\\n print "foo() was defined in an editing |
|
414 | 414 | session"\\n' |
|
415 | 415 | |
|
416 | 416 | We can then call the function foo():: |
|
417 | 417 | |
|
418 | 418 | In [2]: foo() |
|
419 | 419 | foo() was defined in an editing session |
|
420 | 420 | |
|
421 | 421 | Now we edit foo. IPython automatically loads the editor with the |
|
422 | 422 | (temporary) file where foo() was previously defined:: |
|
423 | 423 | |
|
424 | 424 | In [3]: ed foo |
|
425 | 425 | Editing... done. Executing edited code... |
|
426 | 426 | |
|
427 | 427 | And if we call foo() again we get the modified version:: |
|
428 | 428 | |
|
429 | 429 | In [4]: foo() |
|
430 | 430 | foo() has now been changed! |
|
431 | 431 | |
|
432 | 432 | Here is an example of how to edit a code snippet successive |
|
433 | 433 | times. First we call the editor:: |
|
434 | 434 | |
|
435 | 435 | In [5]: ed |
|
436 | 436 | Editing... done. Executing edited code... |
|
437 | 437 | hello |
|
438 | 438 | Out[5]: "print 'hello'\\n" |
|
439 | 439 | |
|
440 | 440 | Now we call it again with the previous output (stored in _):: |
|
441 | 441 | |
|
442 | 442 | In [6]: ed _ |
|
443 | 443 | Editing... done. Executing edited code... |
|
444 | 444 | hello world |
|
445 | 445 | Out[6]: "print 'hello world'\\n" |
|
446 | 446 | |
|
447 | 447 | Now we call it with the output #8 (stored in _8, also as Out[8]):: |
|
448 | 448 | |
|
449 | 449 | In [7]: ed _8 |
|
450 | 450 | Editing... done. Executing edited code... |
|
451 | 451 | hello again |
|
452 | 452 | Out[7]: "print 'hello again'\\n" |
|
453 | 453 | |
|
454 | 454 | |
|
455 | 455 | Changing the default editor hook: |
|
456 | 456 | |
|
457 | 457 | If you wish to write your own editor hook, you can put it in a |
|
458 | 458 | configuration file which you load at startup time. The default hook |
|
459 | 459 | is defined in the IPython.core.hooks module, and you can use that as a |
|
460 | 460 | starting example for further modifications. That file also has |
|
461 | 461 | general instructions on how to set a new hook for use once you've |
|
462 | 462 | defined it.""" |
|
463 | 463 | opts,args = self.parse_options(parameter_s,'prxn:') |
|
464 | 464 | |
|
465 | 465 | try: |
|
466 | 466 | filename, lineno, is_temp = self._find_edit_target(args, opts, last_call) |
|
467 | 467 | except MacroToEdit as e: |
|
468 | 468 | self._edit_macro(args, e.args[0]) |
|
469 | 469 | return |
|
470 | 470 | |
|
471 | 471 | # do actual editing here |
|
472 | 472 | print 'Editing...', |
|
473 | 473 | sys.stdout.flush() |
|
474 | 474 | try: |
|
475 | 475 | # Quote filenames that may have spaces in them |
|
476 | 476 | if ' ' in filename: |
|
477 | 477 | filename = "'%s'" % filename |
|
478 | 478 | self.shell.hooks.editor(filename,lineno) |
|
479 | 479 | except TryNext: |
|
480 | 480 | warn('Could not open editor') |
|
481 | 481 | return |
|
482 | 482 | |
|
483 | 483 | # XXX TODO: should this be generalized for all string vars? |
|
484 | 484 | # For now, this is special-cased to blocks created by cpaste |
|
485 | 485 | if args.strip() == 'pasted_block': |
|
486 | 486 | self.shell.user_ns['pasted_block'] = file_read(filename) |
|
487 | 487 | |
|
488 | 488 | if 'x' in opts: # -x prevents actual execution |
|
489 | 489 | |
|
490 | 490 | else: |
|
491 | 491 | print 'done. Executing edited code...' |
|
492 | 492 | if 'r' in opts: # Untranslated IPython code |
|
493 | 493 | self.shell.run_cell(file_read(filename), |
|
494 | 494 | store_history=False) |
|
495 | 495 | else: |
|
496 | 496 | self.shell.safe_execfile(filename, self.shell.user_ns, |
|
497 | 497 | self.shell.user_ns) |
|
498 | 498 | |
|
499 | 499 | if is_temp: |
|
500 | 500 | try: |
|
501 | 501 | return open(filename).read() |
|
502 | 502 | except IOError,msg: |
|
503 | 503 | if msg.filename == filename: |
|
504 | 504 | warn('File not found. Did you forget to save?') |
|
505 | 505 | return |
|
506 | 506 | else: |
|
507 | 507 | self.shell.showtraceback() |
General Comments 0
You need to be logged in to leave comments.
Login now