##// END OF EJS Templates
Paging using payloads now works.
Brian Granger -
Show More

The requested changes are too big and content was truncated. Show full diff

@@ -0,0 +1,50 b''
1 #!/usr/bin/env python
2 # encoding: utf-8
3 """
4 A payload based version of page.
5
6 Authors:
7
8 * Brian Granger
9 * Fernando Perez
10 """
11
12 #-----------------------------------------------------------------------------
13 # Copyright (C) 2008-2010 The IPython Development Team
14 #
15 # Distributed under the terms of the BSD License. The full license is in
16 # the file COPYING, distributed as part of this software.
17 #-----------------------------------------------------------------------------
18
19 #-----------------------------------------------------------------------------
20 # Imports
21 #-----------------------------------------------------------------------------
22
23 from IPython.core.interactiveshell import InteractiveShell
24
25 #-----------------------------------------------------------------------------
26 # Classes and functions
27 #-----------------------------------------------------------------------------
28
29 def page(strng, start=0, screen_lines=0, pager_cmd=None):
30 """Print a string, piping through a pager.
31
32 This version ignores the screen_lines and pager_cmd arguments and uses
33 IPython's payload system instead.
34 """
35
36 # Some routines may auto-compute start offsets incorrectly and pass a
37 # negative value. Offset to 0 for robustness.
38 start = max(0, start)
39 shell = InteractiveShell.instance()
40 payload = dict(
41 source='IPython.zmq.page.page',
42 data=strng,
43 start_line_number=start
44 )
45 shell.payload_manager.write_payload(payload)
46
47 def install_payload_page():
48 """Install this version of page as IPython.core.page.page."""
49 from IPython.core import page as corepage
50 corepage.page = page
@@ -1,2130 +1,2127 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Main IPython class."""
3 3
4 4 #-----------------------------------------------------------------------------
5 5 # Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
6 6 # Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
7 7 # Copyright (C) 2008-2010 The IPython Development Team
8 8 #
9 9 # Distributed under the terms of the BSD License. The full license is in
10 10 # the file COPYING, distributed as part of this software.
11 11 #-----------------------------------------------------------------------------
12 12
13 13 #-----------------------------------------------------------------------------
14 14 # Imports
15 15 #-----------------------------------------------------------------------------
16 16
17 17 from __future__ import with_statement
18 18 from __future__ import absolute_import
19 19
20 20 import __builtin__
21 21 import abc
22 22 import codeop
23 23 import exceptions
24 24 import new
25 25 import os
26 26 import re
27 27 import string
28 28 import sys
29 29 import tempfile
30 30 from contextlib import nested
31 31
32 32 from IPython.core import debugger, oinspect
33 33 from IPython.core import history as ipcorehist
34 34 from IPython.core import prefilter
35 35 from IPython.core import shadowns
36 36 from IPython.core import ultratb
37 37 from IPython.core.alias import AliasManager
38 38 from IPython.core.builtin_trap import BuiltinTrap
39 39 from IPython.config.configurable import Configurable
40 40 from IPython.core.display_trap import DisplayTrap
41 41 from IPython.core.error import UsageError
42 42 from IPython.core.extensions import ExtensionManager
43 43 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
44 44 from IPython.core.inputlist import InputList
45 45 from IPython.core.logger import Logger
46 46 from IPython.core.magic import Magic
47 47 from IPython.core.payload import PayloadManager
48 48 from IPython.core.plugin import PluginManager
49 49 from IPython.core.prefilter import PrefilterManager
50 50 from IPython.core.displayhook import DisplayHook
51 51 import IPython.core.hooks
52 52 from IPython.external.Itpl import ItplNS
53 53 from IPython.utils import PyColorize
54 54 from IPython.utils import pickleshare
55 55 from IPython.utils.doctestreload import doctest_reload
56 56 from IPython.utils.ipstruct import Struct
57 57 import IPython.utils.io
58 58 from IPython.utils.io import ask_yes_no
59 59 from IPython.utils.path import get_home_dir, get_ipython_dir, HomeDirError
60 60 from IPython.utils.process import getoutput, getoutputerror
61 61 from IPython.utils.strdispatch import StrDispatch
62 62 from IPython.utils.syspathcontext import prepended_to_syspath
63 63 from IPython.utils.text import num_ini_spaces
64 64 from IPython.utils.warn import warn, error, fatal
65 65 from IPython.utils.traitlets import (
66 66 Int, Str, CBool, CaselessStrEnum, Enum, List, Unicode, Instance, Type
67 67 )
68 68
69 69 # from IPython.utils import growl
70 70 # growl.start("IPython")
71 71
72 72 #-----------------------------------------------------------------------------
73 73 # Globals
74 74 #-----------------------------------------------------------------------------
75 75
76 76 # compiled regexps for autoindent management
77 77 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
78 78
79 79 #-----------------------------------------------------------------------------
80 80 # Utilities
81 81 #-----------------------------------------------------------------------------
82 82
83 83 # store the builtin raw_input globally, and use this always, in case user code
84 84 # overwrites it (like wx.py.PyShell does)
85 85 raw_input_original = raw_input
86 86
87 87 def softspace(file, newvalue):
88 88 """Copied from code.py, to remove the dependency"""
89 89
90 90 oldvalue = 0
91 91 try:
92 92 oldvalue = file.softspace
93 93 except AttributeError:
94 94 pass
95 95 try:
96 96 file.softspace = newvalue
97 97 except (AttributeError, TypeError):
98 98 # "attribute-less object" or "read-only attributes"
99 99 pass
100 100 return oldvalue
101 101
102 102
103 103 def no_op(*a, **kw): pass
104 104
105 105 class SpaceInInput(exceptions.Exception): pass
106 106
107 107 class Bunch: pass
108 108
109 109
110 110 def get_default_colors():
111 111 if sys.platform=='darwin':
112 112 return "LightBG"
113 113 elif os.name=='nt':
114 114 return 'Linux'
115 115 else:
116 116 return 'Linux'
117 117
118 118
119 119 class SeparateStr(Str):
120 120 """A Str subclass to validate separate_in, separate_out, etc.
121 121
122 122 This is a Str based trait that converts '0'->'' and '\\n'->'\n'.
123 123 """
124 124
125 125 def validate(self, obj, value):
126 126 if value == '0': value = ''
127 127 value = value.replace('\\n','\n')
128 128 return super(SeparateStr, self).validate(obj, value)
129 129
130 130 class MultipleInstanceError(Exception):
131 131 pass
132 132
133 133
134 134 #-----------------------------------------------------------------------------
135 135 # Main IPython class
136 136 #-----------------------------------------------------------------------------
137 137
138 138
139 139 class InteractiveShell(Configurable, Magic):
140 140 """An enhanced, interactive shell for Python."""
141 141
142 142 _instance = None
143 143 autocall = Enum((0,1,2), default_value=1, config=True)
144 144 # TODO: remove all autoindent logic and put into frontends.
145 145 # We can't do this yet because even runlines uses the autoindent.
146 146 autoindent = CBool(True, config=True)
147 147 automagic = CBool(True, config=True)
148 148 cache_size = Int(1000, config=True)
149 149 color_info = CBool(True, config=True)
150 150 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
151 151 default_value=get_default_colors(), config=True)
152 152 debug = CBool(False, config=True)
153 153 deep_reload = CBool(False, config=True)
154 154 displayhook_class = Type(DisplayHook)
155 155 filename = Str("<ipython console>")
156 156 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
157 157 logstart = CBool(False, config=True)
158 158 logfile = Str('', config=True)
159 159 logappend = Str('', config=True)
160 160 object_info_string_level = Enum((0,1,2), default_value=0,
161 161 config=True)
162 162 pdb = CBool(False, config=True)
163 163 pprint = CBool(True, config=True)
164 164 profile = Str('', config=True)
165 165 prompt_in1 = Str('In [\\#]: ', config=True)
166 166 prompt_in2 = Str(' .\\D.: ', config=True)
167 167 prompt_out = Str('Out[\\#]: ', config=True)
168 168 prompts_pad_left = CBool(True, config=True)
169 169 quiet = CBool(False, config=True)
170 170
171 171 # The readline stuff will eventually be moved to the terminal subclass
172 172 # but for now, we can't do that as readline is welded in everywhere.
173 173 readline_use = CBool(True, config=True)
174 174 readline_merge_completions = CBool(True, config=True)
175 175 readline_omit__names = Enum((0,1,2), default_value=0, config=True)
176 176 readline_remove_delims = Str('-/~', config=True)
177 177 readline_parse_and_bind = List([
178 178 'tab: complete',
179 179 '"\C-l": clear-screen',
180 180 'set show-all-if-ambiguous on',
181 181 '"\C-o": tab-insert',
182 182 '"\M-i": " "',
183 183 '"\M-o": "\d\d\d\d"',
184 184 '"\M-I": "\d\d\d\d"',
185 185 '"\C-r": reverse-search-history',
186 186 '"\C-s": forward-search-history',
187 187 '"\C-p": history-search-backward',
188 188 '"\C-n": history-search-forward',
189 189 '"\e[A": history-search-backward',
190 190 '"\e[B": history-search-forward',
191 191 '"\C-k": kill-line',
192 192 '"\C-u": unix-line-discard',
193 193 ], allow_none=False, config=True)
194 194
195 195 # TODO: this part of prompt management should be moved to the frontends.
196 196 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
197 197 separate_in = SeparateStr('\n', config=True)
198 198 separate_out = SeparateStr('\n', config=True)
199 199 separate_out2 = SeparateStr('\n', config=True)
200 200 system_header = Str('IPython system call: ', config=True)
201 201 system_verbose = CBool(False, config=True)
202 202 wildcards_case_sensitive = CBool(True, config=True)
203 203 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
204 204 default_value='Context', config=True)
205 205
206 206 # Subcomponents of InteractiveShell
207 207 alias_manager = Instance('IPython.core.alias.AliasManager')
208 208 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
209 209 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
210 210 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
211 211 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
212 212 plugin_manager = Instance('IPython.core.plugin.PluginManager')
213 213 payload_manager = Instance('IPython.core.payload.PayloadManager')
214 214
215 215 def __init__(self, config=None, ipython_dir=None,
216 216 user_ns=None, user_global_ns=None,
217 217 custom_exceptions=((),None)):
218 218
219 219 # This is where traits with a config_key argument are updated
220 220 # from the values on config.
221 221 super(InteractiveShell, self).__init__(config=config)
222 222
223 223 # These are relatively independent and stateless
224 224 self.init_ipython_dir(ipython_dir)
225 225 self.init_instance_attrs()
226 226
227 227 # Create namespaces (user_ns, user_global_ns, etc.)
228 228 self.init_create_namespaces(user_ns, user_global_ns)
229 229 # This has to be done after init_create_namespaces because it uses
230 230 # something in self.user_ns, but before init_sys_modules, which
231 231 # is the first thing to modify sys.
232 232 # TODO: When we override sys.stdout and sys.stderr before this class
233 233 # is created, we are saving the overridden ones here. Not sure if this
234 234 # is what we want to do.
235 235 self.save_sys_module_state()
236 236 self.init_sys_modules()
237 237
238 238 self.init_history()
239 239 self.init_encoding()
240 240 self.init_prefilter()
241 241
242 242 Magic.__init__(self, self)
243 243
244 244 self.init_syntax_highlighting()
245 245 self.init_hooks()
246 246 self.init_pushd_popd_magic()
247 247 # self.init_traceback_handlers use to be here, but we moved it below
248 248 # because it and init_io have to come after init_readline.
249 249 self.init_user_ns()
250 250 self.init_logger()
251 251 self.init_alias()
252 252 self.init_builtins()
253 253
254 254 # pre_config_initialization
255 255 self.init_shadow_hist()
256 256
257 257 # The next section should contain averything that was in ipmaker.
258 258 self.init_logstart()
259 259
260 260 # The following was in post_config_initialization
261 261 self.init_inspector()
262 262 # init_readline() must come before init_io(), because init_io uses
263 263 # readline related things.
264 264 self.init_readline()
265 265 # TODO: init_io() needs to happen before init_traceback handlers
266 266 # because the traceback handlers hardcode the stdout/stderr streams.
267 267 # This logic in in debugger.Pdb and should eventually be changed.
268 268 self.init_io()
269 269 self.init_traceback_handlers(custom_exceptions)
270 270 self.init_prompts()
271 271 self.init_displayhook()
272 272 self.init_reload_doctest()
273 273 self.init_magics()
274 274 self.init_pdb()
275 275 self.init_extension_manager()
276 276 self.init_plugin_manager()
277 277 self.init_payload()
278 278 self.hooks.late_startup_hook()
279 279
280 280 @classmethod
281 281 def instance(cls, *args, **kwargs):
282 282 """Returns a global InteractiveShell instance."""
283 283 if cls._instance is None:
284 284 inst = cls(*args, **kwargs)
285 285 # Now make sure that the instance will also be returned by
286 286 # the subclasses instance attribute.
287 287 for subclass in cls.mro():
288 288 if issubclass(cls, subclass) and issubclass(subclass, InteractiveShell):
289 289 subclass._instance = inst
290 290 else:
291 291 break
292 292 if isinstance(cls._instance, cls):
293 293 return cls._instance
294 294 else:
295 295 raise MultipleInstanceError(
296 296 'Multiple incompatible subclass instances of '
297 297 'InteractiveShell are being created.'
298 298 )
299 299
300 300 @classmethod
301 301 def initialized(cls):
302 302 return hasattr(cls, "_instance")
303 303
304 304 def get_ipython(self):
305 305 """Return the currently running IPython instance."""
306 306 return self
307 307
308 308 #-------------------------------------------------------------------------
309 309 # Trait changed handlers
310 310 #-------------------------------------------------------------------------
311 311
312 312 def _ipython_dir_changed(self, name, new):
313 313 if not os.path.isdir(new):
314 314 os.makedirs(new, mode = 0777)
315 315
316 316 def set_autoindent(self,value=None):
317 317 """Set the autoindent flag, checking for readline support.
318 318
319 319 If called with no arguments, it acts as a toggle."""
320 320
321 321 if not self.has_readline:
322 322 if os.name == 'posix':
323 323 warn("The auto-indent feature requires the readline library")
324 324 self.autoindent = 0
325 325 return
326 326 if value is None:
327 327 self.autoindent = not self.autoindent
328 328 else:
329 329 self.autoindent = value
330 330
331 331 #-------------------------------------------------------------------------
332 332 # init_* methods called by __init__
333 333 #-------------------------------------------------------------------------
334 334
335 335 def init_ipython_dir(self, ipython_dir):
336 336 if ipython_dir is not None:
337 337 self.ipython_dir = ipython_dir
338 338 self.config.Global.ipython_dir = self.ipython_dir
339 339 return
340 340
341 341 if hasattr(self.config.Global, 'ipython_dir'):
342 342 self.ipython_dir = self.config.Global.ipython_dir
343 343 else:
344 344 self.ipython_dir = get_ipython_dir()
345 345
346 346 # All children can just read this
347 347 self.config.Global.ipython_dir = self.ipython_dir
348 348
349 349 def init_instance_attrs(self):
350 350 self.more = False
351 351
352 352 # command compiler
353 353 self.compile = codeop.CommandCompiler()
354 354
355 355 # User input buffer
356 356 self.buffer = []
357 357
358 358 # Make an empty namespace, which extension writers can rely on both
359 359 # existing and NEVER being used by ipython itself. This gives them a
360 360 # convenient location for storing additional information and state
361 361 # their extensions may require, without fear of collisions with other
362 362 # ipython names that may develop later.
363 363 self.meta = Struct()
364 364
365 365 # Object variable to store code object waiting execution. This is
366 366 # used mainly by the multithreaded shells, but it can come in handy in
367 367 # other situations. No need to use a Queue here, since it's a single
368 368 # item which gets cleared once run.
369 369 self.code_to_run = None
370 370
371 371 # Temporary files used for various purposes. Deleted at exit.
372 372 self.tempfiles = []
373 373
374 374 # Keep track of readline usage (later set by init_readline)
375 375 self.has_readline = False
376 376
377 377 # keep track of where we started running (mainly for crash post-mortem)
378 378 # This is not being used anywhere currently.
379 379 self.starting_dir = os.getcwd()
380 380
381 381 # Indentation management
382 382 self.indent_current_nsp = 0
383 383
384 384 def init_encoding(self):
385 385 # Get system encoding at startup time. Certain terminals (like Emacs
386 386 # under Win32 have it set to None, and we need to have a known valid
387 387 # encoding to use in the raw_input() method
388 388 try:
389 389 self.stdin_encoding = sys.stdin.encoding or 'ascii'
390 390 except AttributeError:
391 391 self.stdin_encoding = 'ascii'
392 392
393 393 def init_syntax_highlighting(self):
394 394 # Python source parser/formatter for syntax highlighting
395 395 pyformat = PyColorize.Parser().format
396 396 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
397 397
398 398 def init_pushd_popd_magic(self):
399 399 # for pushd/popd management
400 400 try:
401 401 self.home_dir = get_home_dir()
402 402 except HomeDirError, msg:
403 403 fatal(msg)
404 404
405 405 self.dir_stack = []
406 406
407 407 def init_logger(self):
408 408 self.logger = Logger(self, logfname='ipython_log.py', logmode='rotate')
409 409 # local shortcut, this is used a LOT
410 410 self.log = self.logger.log
411 411
412 412 def init_logstart(self):
413 413 if self.logappend:
414 414 self.magic_logstart(self.logappend + ' append')
415 415 elif self.logfile:
416 416 self.magic_logstart(self.logfile)
417 417 elif self.logstart:
418 418 self.magic_logstart()
419 419
420 420 def init_builtins(self):
421 421 self.builtin_trap = BuiltinTrap(shell=self)
422 422
423 423 def init_inspector(self):
424 424 # Object inspector
425 425 self.inspector = oinspect.Inspector(oinspect.InspectColors,
426 426 PyColorize.ANSICodeColors,
427 427 'NoColor',
428 428 self.object_info_string_level)
429 429
430 430 def init_io(self):
431 431 import IPython.utils.io
432 432 if sys.platform == 'win32' and self.has_readline:
433 433 Term = IPython.utils.io.IOTerm(
434 434 cout=self.readline._outputfile,cerr=self.readline._outputfile
435 435 )
436 436 else:
437 437 Term = IPython.utils.io.IOTerm()
438 438 IPython.utils.io.Term = Term
439 439
440 440 def init_prompts(self):
441 441 # TODO: This is a pass for now because the prompts are managed inside
442 442 # the DisplayHook. Once there is a separate prompt manager, this
443 443 # will initialize that object and all prompt related information.
444 444 pass
445 445
446 446 def init_displayhook(self):
447 447 # Initialize displayhook, set in/out prompts and printing system
448 448 self.displayhook = self.displayhook_class(
449 449 shell=self,
450 450 cache_size=self.cache_size,
451 451 input_sep = self.separate_in,
452 452 output_sep = self.separate_out,
453 453 output_sep2 = self.separate_out2,
454 454 ps1 = self.prompt_in1,
455 455 ps2 = self.prompt_in2,
456 456 ps_out = self.prompt_out,
457 457 pad_left = self.prompts_pad_left
458 458 )
459 459 # This is a context manager that installs/revmoes the displayhook at
460 460 # the appropriate time.
461 461 self.display_trap = DisplayTrap(hook=self.displayhook)
462 462
463 463 def init_reload_doctest(self):
464 464 # Do a proper resetting of doctest, including the necessary displayhook
465 465 # monkeypatching
466 466 try:
467 467 doctest_reload()
468 468 except ImportError:
469 469 warn("doctest module does not exist.")
470 470
471 471 #-------------------------------------------------------------------------
472 472 # Things related to injections into the sys module
473 473 #-------------------------------------------------------------------------
474 474
475 475 def save_sys_module_state(self):
476 476 """Save the state of hooks in the sys module.
477 477
478 478 This has to be called after self.user_ns is created.
479 479 """
480 480 self._orig_sys_module_state = {}
481 481 self._orig_sys_module_state['stdin'] = sys.stdin
482 482 self._orig_sys_module_state['stdout'] = sys.stdout
483 483 self._orig_sys_module_state['stderr'] = sys.stderr
484 484 self._orig_sys_module_state['excepthook'] = sys.excepthook
485 485 try:
486 486 self._orig_sys_modules_main_name = self.user_ns['__name__']
487 487 except KeyError:
488 488 pass
489 489
490 490 def restore_sys_module_state(self):
491 491 """Restore the state of the sys module."""
492 492 try:
493 493 for k, v in self._orig_sys_module_state.items():
494 494 setattr(sys, k, v)
495 495 except AttributeError:
496 496 pass
497 497 try:
498 498 delattr(sys, 'ipcompleter')
499 499 except AttributeError:
500 500 pass
501 501 # Reset what what done in self.init_sys_modules
502 502 try:
503 503 sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
504 504 except (AttributeError, KeyError):
505 505 pass
506 506
507 507 #-------------------------------------------------------------------------
508 508 # Things related to hooks
509 509 #-------------------------------------------------------------------------
510 510
511 511 def init_hooks(self):
512 512 # hooks holds pointers used for user-side customizations
513 513 self.hooks = Struct()
514 514
515 515 self.strdispatchers = {}
516 516
517 517 # Set all default hooks, defined in the IPython.hooks module.
518 518 hooks = IPython.core.hooks
519 519 for hook_name in hooks.__all__:
520 520 # default hooks have priority 100, i.e. low; user hooks should have
521 521 # 0-100 priority
522 522 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
523 523
524 524 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
525 525 """set_hook(name,hook) -> sets an internal IPython hook.
526 526
527 527 IPython exposes some of its internal API as user-modifiable hooks. By
528 528 adding your function to one of these hooks, you can modify IPython's
529 529 behavior to call at runtime your own routines."""
530 530
531 531 # At some point in the future, this should validate the hook before it
532 532 # accepts it. Probably at least check that the hook takes the number
533 533 # of args it's supposed to.
534 534
535 535 f = new.instancemethod(hook,self,self.__class__)
536 536
537 537 # check if the hook is for strdispatcher first
538 538 if str_key is not None:
539 539 sdp = self.strdispatchers.get(name, StrDispatch())
540 540 sdp.add_s(str_key, f, priority )
541 541 self.strdispatchers[name] = sdp
542 542 return
543 543 if re_key is not None:
544 544 sdp = self.strdispatchers.get(name, StrDispatch())
545 545 sdp.add_re(re.compile(re_key), f, priority )
546 546 self.strdispatchers[name] = sdp
547 547 return
548 548
549 549 dp = getattr(self.hooks, name, None)
550 550 if name not in IPython.core.hooks.__all__:
551 551 print "Warning! Hook '%s' is not one of %s" % (name, IPython.core.hooks.__all__ )
552 552 if not dp:
553 553 dp = IPython.core.hooks.CommandChainDispatcher()
554 554
555 555 try:
556 556 dp.add(f,priority)
557 557 except AttributeError:
558 558 # it was not commandchain, plain old func - replace
559 559 dp = f
560 560
561 561 setattr(self.hooks,name, dp)
562 562
563 563 #-------------------------------------------------------------------------
564 564 # Things related to the "main" module
565 565 #-------------------------------------------------------------------------
566 566
567 567 def new_main_mod(self,ns=None):
568 568 """Return a new 'main' module object for user code execution.
569 569 """
570 570 main_mod = self._user_main_module
571 571 init_fakemod_dict(main_mod,ns)
572 572 return main_mod
573 573
574 574 def cache_main_mod(self,ns,fname):
575 575 """Cache a main module's namespace.
576 576
577 577 When scripts are executed via %run, we must keep a reference to the
578 578 namespace of their __main__ module (a FakeModule instance) around so
579 579 that Python doesn't clear it, rendering objects defined therein
580 580 useless.
581 581
582 582 This method keeps said reference in a private dict, keyed by the
583 583 absolute path of the module object (which corresponds to the script
584 584 path). This way, for multiple executions of the same script we only
585 585 keep one copy of the namespace (the last one), thus preventing memory
586 586 leaks from old references while allowing the objects from the last
587 587 execution to be accessible.
588 588
589 589 Note: we can not allow the actual FakeModule instances to be deleted,
590 590 because of how Python tears down modules (it hard-sets all their
591 591 references to None without regard for reference counts). This method
592 592 must therefore make a *copy* of the given namespace, to allow the
593 593 original module's __dict__ to be cleared and reused.
594 594
595 595
596 596 Parameters
597 597 ----------
598 598 ns : a namespace (a dict, typically)
599 599
600 600 fname : str
601 601 Filename associated with the namespace.
602 602
603 603 Examples
604 604 --------
605 605
606 606 In [10]: import IPython
607 607
608 608 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
609 609
610 610 In [12]: IPython.__file__ in _ip._main_ns_cache
611 611 Out[12]: True
612 612 """
613 613 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
614 614
615 615 def clear_main_mod_cache(self):
616 616 """Clear the cache of main modules.
617 617
618 618 Mainly for use by utilities like %reset.
619 619
620 620 Examples
621 621 --------
622 622
623 623 In [15]: import IPython
624 624
625 625 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
626 626
627 627 In [17]: len(_ip._main_ns_cache) > 0
628 628 Out[17]: True
629 629
630 630 In [18]: _ip.clear_main_mod_cache()
631 631
632 632 In [19]: len(_ip._main_ns_cache) == 0
633 633 Out[19]: True
634 634 """
635 635 self._main_ns_cache.clear()
636 636
637 637 #-------------------------------------------------------------------------
638 638 # Things related to debugging
639 639 #-------------------------------------------------------------------------
640 640
641 641 def init_pdb(self):
642 642 # Set calling of pdb on exceptions
643 643 # self.call_pdb is a property
644 644 self.call_pdb = self.pdb
645 645
646 646 def _get_call_pdb(self):
647 647 return self._call_pdb
648 648
649 649 def _set_call_pdb(self,val):
650 650
651 651 if val not in (0,1,False,True):
652 652 raise ValueError,'new call_pdb value must be boolean'
653 653
654 654 # store value in instance
655 655 self._call_pdb = val
656 656
657 657 # notify the actual exception handlers
658 658 self.InteractiveTB.call_pdb = val
659 659
660 660 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
661 661 'Control auto-activation of pdb at exceptions')
662 662
663 663 def debugger(self,force=False):
664 664 """Call the pydb/pdb debugger.
665 665
666 666 Keywords:
667 667
668 668 - force(False): by default, this routine checks the instance call_pdb
669 669 flag and does not actually invoke the debugger if the flag is false.
670 670 The 'force' option forces the debugger to activate even if the flag
671 671 is false.
672 672 """
673 673
674 674 if not (force or self.call_pdb):
675 675 return
676 676
677 677 if not hasattr(sys,'last_traceback'):
678 678 error('No traceback has been produced, nothing to debug.')
679 679 return
680 680
681 681 # use pydb if available
682 682 if debugger.has_pydb:
683 683 from pydb import pm
684 684 else:
685 685 # fallback to our internal debugger
686 686 pm = lambda : self.InteractiveTB.debugger(force=True)
687 687 self.history_saving_wrapper(pm)()
688 688
689 689 #-------------------------------------------------------------------------
690 690 # Things related to IPython's various namespaces
691 691 #-------------------------------------------------------------------------
692 692
693 693 def init_create_namespaces(self, user_ns=None, user_global_ns=None):
694 694 # Create the namespace where the user will operate. user_ns is
695 695 # normally the only one used, and it is passed to the exec calls as
696 696 # the locals argument. But we do carry a user_global_ns namespace
697 697 # given as the exec 'globals' argument, This is useful in embedding
698 698 # situations where the ipython shell opens in a context where the
699 699 # distinction between locals and globals is meaningful. For
700 700 # non-embedded contexts, it is just the same object as the user_ns dict.
701 701
702 702 # FIXME. For some strange reason, __builtins__ is showing up at user
703 703 # level as a dict instead of a module. This is a manual fix, but I
704 704 # should really track down where the problem is coming from. Alex
705 705 # Schmolck reported this problem first.
706 706
707 707 # A useful post by Alex Martelli on this topic:
708 708 # Re: inconsistent value from __builtins__
709 709 # Von: Alex Martelli <aleaxit@yahoo.com>
710 710 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
711 711 # Gruppen: comp.lang.python
712 712
713 713 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
714 714 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
715 715 # > <type 'dict'>
716 716 # > >>> print type(__builtins__)
717 717 # > <type 'module'>
718 718 # > Is this difference in return value intentional?
719 719
720 720 # Well, it's documented that '__builtins__' can be either a dictionary
721 721 # or a module, and it's been that way for a long time. Whether it's
722 722 # intentional (or sensible), I don't know. In any case, the idea is
723 723 # that if you need to access the built-in namespace directly, you
724 724 # should start with "import __builtin__" (note, no 's') which will
725 725 # definitely give you a module. Yeah, it's somewhat confusing:-(.
726 726
727 727 # These routines return properly built dicts as needed by the rest of
728 728 # the code, and can also be used by extension writers to generate
729 729 # properly initialized namespaces.
730 730 user_ns, user_global_ns = self.make_user_namespaces(user_ns, user_global_ns)
731 731
732 732 # Assign namespaces
733 733 # This is the namespace where all normal user variables live
734 734 self.user_ns = user_ns
735 735 self.user_global_ns = user_global_ns
736 736
737 737 # An auxiliary namespace that checks what parts of the user_ns were
738 738 # loaded at startup, so we can list later only variables defined in
739 739 # actual interactive use. Since it is always a subset of user_ns, it
740 740 # doesn't need to be separately tracked in the ns_table.
741 741 self.user_ns_hidden = {}
742 742
743 743 # A namespace to keep track of internal data structures to prevent
744 744 # them from cluttering user-visible stuff. Will be updated later
745 745 self.internal_ns = {}
746 746
747 747 # Now that FakeModule produces a real module, we've run into a nasty
748 748 # problem: after script execution (via %run), the module where the user
749 749 # code ran is deleted. Now that this object is a true module (needed
750 750 # so docetst and other tools work correctly), the Python module
751 751 # teardown mechanism runs over it, and sets to None every variable
752 752 # present in that module. Top-level references to objects from the
753 753 # script survive, because the user_ns is updated with them. However,
754 754 # calling functions defined in the script that use other things from
755 755 # the script will fail, because the function's closure had references
756 756 # to the original objects, which are now all None. So we must protect
757 757 # these modules from deletion by keeping a cache.
758 758 #
759 759 # To avoid keeping stale modules around (we only need the one from the
760 760 # last run), we use a dict keyed with the full path to the script, so
761 761 # only the last version of the module is held in the cache. Note,
762 762 # however, that we must cache the module *namespace contents* (their
763 763 # __dict__). Because if we try to cache the actual modules, old ones
764 764 # (uncached) could be destroyed while still holding references (such as
765 765 # those held by GUI objects that tend to be long-lived)>
766 766 #
767 767 # The %reset command will flush this cache. See the cache_main_mod()
768 768 # and clear_main_mod_cache() methods for details on use.
769 769
770 770 # This is the cache used for 'main' namespaces
771 771 self._main_ns_cache = {}
772 772 # And this is the single instance of FakeModule whose __dict__ we keep
773 773 # copying and clearing for reuse on each %run
774 774 self._user_main_module = FakeModule()
775 775
776 776 # A table holding all the namespaces IPython deals with, so that
777 777 # introspection facilities can search easily.
778 778 self.ns_table = {'user':user_ns,
779 779 'user_global':user_global_ns,
780 780 'internal':self.internal_ns,
781 781 'builtin':__builtin__.__dict__
782 782 }
783 783
784 784 # Similarly, track all namespaces where references can be held and that
785 785 # we can safely clear (so it can NOT include builtin). This one can be
786 786 # a simple list.
787 787 self.ns_refs_table = [ user_ns, user_global_ns, self.user_ns_hidden,
788 788 self.internal_ns, self._main_ns_cache ]
789 789
790 790 def make_user_namespaces(self, user_ns=None, user_global_ns=None):
791 791 """Return a valid local and global user interactive namespaces.
792 792
793 793 This builds a dict with the minimal information needed to operate as a
794 794 valid IPython user namespace, which you can pass to the various
795 795 embedding classes in ipython. The default implementation returns the
796 796 same dict for both the locals and the globals to allow functions to
797 797 refer to variables in the namespace. Customized implementations can
798 798 return different dicts. The locals dictionary can actually be anything
799 799 following the basic mapping protocol of a dict, but the globals dict
800 800 must be a true dict, not even a subclass. It is recommended that any
801 801 custom object for the locals namespace synchronize with the globals
802 802 dict somehow.
803 803
804 804 Raises TypeError if the provided globals namespace is not a true dict.
805 805
806 806 Parameters
807 807 ----------
808 808 user_ns : dict-like, optional
809 809 The current user namespace. The items in this namespace should
810 810 be included in the output. If None, an appropriate blank
811 811 namespace should be created.
812 812 user_global_ns : dict, optional
813 813 The current user global namespace. The items in this namespace
814 814 should be included in the output. If None, an appropriate
815 815 blank namespace should be created.
816 816
817 817 Returns
818 818 -------
819 819 A pair of dictionary-like object to be used as the local namespace
820 820 of the interpreter and a dict to be used as the global namespace.
821 821 """
822 822
823 823
824 824 # We must ensure that __builtin__ (without the final 's') is always
825 825 # available and pointing to the __builtin__ *module*. For more details:
826 826 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
827 827
828 828 if user_ns is None:
829 829 # Set __name__ to __main__ to better match the behavior of the
830 830 # normal interpreter.
831 831 user_ns = {'__name__' :'__main__',
832 832 '__builtin__' : __builtin__,
833 833 '__builtins__' : __builtin__,
834 834 }
835 835 else:
836 836 user_ns.setdefault('__name__','__main__')
837 837 user_ns.setdefault('__builtin__',__builtin__)
838 838 user_ns.setdefault('__builtins__',__builtin__)
839 839
840 840 if user_global_ns is None:
841 841 user_global_ns = user_ns
842 842 if type(user_global_ns) is not dict:
843 843 raise TypeError("user_global_ns must be a true dict; got %r"
844 844 % type(user_global_ns))
845 845
846 846 return user_ns, user_global_ns
847 847
848 848 def init_sys_modules(self):
849 849 # We need to insert into sys.modules something that looks like a
850 850 # module but which accesses the IPython namespace, for shelve and
851 851 # pickle to work interactively. Normally they rely on getting
852 852 # everything out of __main__, but for embedding purposes each IPython
853 853 # instance has its own private namespace, so we can't go shoving
854 854 # everything into __main__.
855 855
856 856 # note, however, that we should only do this for non-embedded
857 857 # ipythons, which really mimic the __main__.__dict__ with their own
858 858 # namespace. Embedded instances, on the other hand, should not do
859 859 # this because they need to manage the user local/global namespaces
860 860 # only, but they live within a 'normal' __main__ (meaning, they
861 861 # shouldn't overtake the execution environment of the script they're
862 862 # embedded in).
863 863
864 864 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
865 865
866 866 try:
867 867 main_name = self.user_ns['__name__']
868 868 except KeyError:
869 869 raise KeyError('user_ns dictionary MUST have a "__name__" key')
870 870 else:
871 871 sys.modules[main_name] = FakeModule(self.user_ns)
872 872
873 873 def init_user_ns(self):
874 874 """Initialize all user-visible namespaces to their minimum defaults.
875 875
876 876 Certain history lists are also initialized here, as they effectively
877 877 act as user namespaces.
878 878
879 879 Notes
880 880 -----
881 881 All data structures here are only filled in, they are NOT reset by this
882 882 method. If they were not empty before, data will simply be added to
883 883 therm.
884 884 """
885 885 # This function works in two parts: first we put a few things in
886 886 # user_ns, and we sync that contents into user_ns_hidden so that these
887 887 # initial variables aren't shown by %who. After the sync, we add the
888 888 # rest of what we *do* want the user to see with %who even on a new
889 889 # session (probably nothing, so theye really only see their own stuff)
890 890
891 891 # The user dict must *always* have a __builtin__ reference to the
892 892 # Python standard __builtin__ namespace, which must be imported.
893 893 # This is so that certain operations in prompt evaluation can be
894 894 # reliably executed with builtins. Note that we can NOT use
895 895 # __builtins__ (note the 's'), because that can either be a dict or a
896 896 # module, and can even mutate at runtime, depending on the context
897 897 # (Python makes no guarantees on it). In contrast, __builtin__ is
898 898 # always a module object, though it must be explicitly imported.
899 899
900 900 # For more details:
901 901 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
902 902 ns = dict(__builtin__ = __builtin__)
903 903
904 904 # Put 'help' in the user namespace
905 905 try:
906 906 from site import _Helper
907 907 ns['help'] = _Helper()
908 908 except ImportError:
909 909 warn('help() not available - check site.py')
910 910
911 911 # make global variables for user access to the histories
912 912 ns['_ih'] = self.input_hist
913 913 ns['_oh'] = self.output_hist
914 914 ns['_dh'] = self.dir_hist
915 915
916 916 ns['_sh'] = shadowns
917 917
918 918 # user aliases to input and output histories. These shouldn't show up
919 919 # in %who, as they can have very large reprs.
920 920 ns['In'] = self.input_hist
921 921 ns['Out'] = self.output_hist
922 922
923 923 # Store myself as the public api!!!
924 924 ns['get_ipython'] = self.get_ipython
925 925
926 926 # Sync what we've added so far to user_ns_hidden so these aren't seen
927 927 # by %who
928 928 self.user_ns_hidden.update(ns)
929 929
930 930 # Anything put into ns now would show up in %who. Think twice before
931 931 # putting anything here, as we really want %who to show the user their
932 932 # stuff, not our variables.
933 933
934 934 # Finally, update the real user's namespace
935 935 self.user_ns.update(ns)
936 936
937 937
938 938 def reset(self):
939 939 """Clear all internal namespaces.
940 940
941 941 Note that this is much more aggressive than %reset, since it clears
942 942 fully all namespaces, as well as all input/output lists.
943 943 """
944 944 for ns in self.ns_refs_table:
945 945 ns.clear()
946 946
947 947 self.alias_manager.clear_aliases()
948 948
949 949 # Clear input and output histories
950 950 self.input_hist[:] = []
951 951 self.input_hist_raw[:] = []
952 952 self.output_hist.clear()
953 953
954 954 # Restore the user namespaces to minimal usability
955 955 self.init_user_ns()
956 956
957 957 # Restore the default and user aliases
958 958 self.alias_manager.init_aliases()
959 959
960 960 def reset_selective(self, regex=None):
961 961 """Clear selective variables from internal namespaces based on a specified regular expression.
962 962
963 963 Parameters
964 964 ----------
965 965 regex : string or compiled pattern, optional
966 966 A regular expression pattern that will be used in searching variable names in the users
967 967 namespaces.
968 968 """
969 969 if regex is not None:
970 970 try:
971 971 m = re.compile(regex)
972 972 except TypeError:
973 973 raise TypeError('regex must be a string or compiled pattern')
974 974 # Search for keys in each namespace that match the given regex
975 975 # If a match is found, delete the key/value pair.
976 976 for ns in self.ns_refs_table:
977 977 for var in ns:
978 978 if m.search(var):
979 979 del ns[var]
980 980
981 981 def push(self, variables, interactive=True):
982 982 """Inject a group of variables into the IPython user namespace.
983 983
984 984 Parameters
985 985 ----------
986 986 variables : dict, str or list/tuple of str
987 987 The variables to inject into the user's namespace. If a dict,
988 988 a simple update is done. If a str, the string is assumed to
989 989 have variable names separated by spaces. A list/tuple of str
990 990 can also be used to give the variable names. If just the variable
991 991 names are give (list/tuple/str) then the variable values looked
992 992 up in the callers frame.
993 993 interactive : bool
994 994 If True (default), the variables will be listed with the ``who``
995 995 magic.
996 996 """
997 997 vdict = None
998 998
999 999 # We need a dict of name/value pairs to do namespace updates.
1000 1000 if isinstance(variables, dict):
1001 1001 vdict = variables
1002 1002 elif isinstance(variables, (basestring, list, tuple)):
1003 1003 if isinstance(variables, basestring):
1004 1004 vlist = variables.split()
1005 1005 else:
1006 1006 vlist = variables
1007 1007 vdict = {}
1008 1008 cf = sys._getframe(1)
1009 1009 for name in vlist:
1010 1010 try:
1011 1011 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1012 1012 except:
1013 1013 print ('Could not get variable %s from %s' %
1014 1014 (name,cf.f_code.co_name))
1015 1015 else:
1016 1016 raise ValueError('variables must be a dict/str/list/tuple')
1017 1017
1018 1018 # Propagate variables to user namespace
1019 1019 self.user_ns.update(vdict)
1020 1020
1021 1021 # And configure interactive visibility
1022 1022 config_ns = self.user_ns_hidden
1023 1023 if interactive:
1024 1024 for name, val in vdict.iteritems():
1025 1025 config_ns.pop(name, None)
1026 1026 else:
1027 1027 for name,val in vdict.iteritems():
1028 1028 config_ns[name] = val
1029 1029
1030 1030 #-------------------------------------------------------------------------
1031 1031 # Things related to history management
1032 1032 #-------------------------------------------------------------------------
1033 1033
1034 1034 def init_history(self):
1035 1035 # List of input with multi-line handling.
1036 1036 self.input_hist = InputList()
1037 1037 # This one will hold the 'raw' input history, without any
1038 1038 # pre-processing. This will allow users to retrieve the input just as
1039 1039 # it was exactly typed in by the user, with %hist -r.
1040 1040 self.input_hist_raw = InputList()
1041 1041
1042 1042 # list of visited directories
1043 1043 try:
1044 1044 self.dir_hist = [os.getcwd()]
1045 1045 except OSError:
1046 1046 self.dir_hist = []
1047 1047
1048 1048 # dict of output history
1049 1049 self.output_hist = {}
1050 1050
1051 1051 # Now the history file
1052 1052 if self.profile:
1053 1053 histfname = 'history-%s' % self.profile
1054 1054 else:
1055 1055 histfname = 'history'
1056 1056 self.histfile = os.path.join(self.ipython_dir, histfname)
1057 1057
1058 1058 # Fill the history zero entry, user counter starts at 1
1059 1059 self.input_hist.append('\n')
1060 1060 self.input_hist_raw.append('\n')
1061 1061
1062 1062 def init_shadow_hist(self):
1063 1063 try:
1064 1064 self.db = pickleshare.PickleShareDB(self.ipython_dir + "/db")
1065 1065 except exceptions.UnicodeDecodeError:
1066 1066 print "Your ipython_dir can't be decoded to unicode!"
1067 1067 print "Please set HOME environment variable to something that"
1068 1068 print r"only has ASCII characters, e.g. c:\home"
1069 1069 print "Now it is", self.ipython_dir
1070 1070 sys.exit()
1071 1071 self.shadowhist = ipcorehist.ShadowHist(self.db)
1072 1072
1073 1073 def savehist(self):
1074 1074 """Save input history to a file (via readline library)."""
1075 1075
1076 1076 try:
1077 1077 self.readline.write_history_file(self.histfile)
1078 1078 except:
1079 1079 print 'Unable to save IPython command history to file: ' + \
1080 1080 `self.histfile`
1081 1081
1082 1082 def reloadhist(self):
1083 1083 """Reload the input history from disk file."""
1084 1084
1085 1085 try:
1086 1086 self.readline.clear_history()
1087 1087 self.readline.read_history_file(self.shell.histfile)
1088 1088 except AttributeError:
1089 1089 pass
1090 1090
1091 1091 def history_saving_wrapper(self, func):
1092 1092 """ Wrap func for readline history saving
1093 1093
1094 1094 Convert func into callable that saves & restores
1095 1095 history around the call """
1096 1096
1097 1097 if self.has_readline:
1098 1098 from IPython.utils import rlineimpl as readline
1099 1099 else:
1100 1100 return func
1101 1101
1102 1102 def wrapper():
1103 1103 self.savehist()
1104 1104 try:
1105 1105 func()
1106 1106 finally:
1107 1107 readline.read_history_file(self.histfile)
1108 1108 return wrapper
1109 1109
1110 1110 def get_history(self, index=None, raw=False, output=True):
1111 1111 """Get the history list.
1112 1112
1113 1113 Get the input and output history.
1114 1114
1115 1115 Parameters
1116 1116 ----------
1117 1117 index : n or (n1, n2) or None
1118 1118 If n, then the last entries. If a tuple, then all in
1119 1119 range(n1, n2). If None, then all entries. Raises IndexError if
1120 1120 the format of index is incorrect.
1121 1121 raw : bool
1122 1122 If True, return the raw input.
1123 1123 output : bool
1124 1124 If True, then return the output as well.
1125 1125
1126 1126 Returns
1127 1127 -------
1128 1128 If output is True, then return a dict of tuples, keyed by the prompt
1129 1129 numbers and with values of (input, output). If output is False, then
1130 1130 a dict, keyed by the prompt number with the values of input. Raises
1131 1131 IndexError if no history is found.
1132 1132 """
1133 1133 if raw:
1134 1134 input_hist = self.input_hist_raw
1135 1135 else:
1136 1136 input_hist = self.input_hist
1137 1137 if output:
1138 1138 output_hist = self.user_ns['Out']
1139 1139 n = len(input_hist)
1140 1140 if index is None:
1141 1141 start=0; stop=n
1142 1142 elif isinstance(index, int):
1143 1143 start=n-index; stop=n
1144 1144 elif isinstance(index, tuple) and len(index) == 2:
1145 1145 start=index[0]; stop=index[1]
1146 1146 else:
1147 1147 raise IndexError('Not a valid index for the input history: %r' % index)
1148 1148 hist = {}
1149 1149 for i in range(start, stop):
1150 1150 if output:
1151 1151 hist[i] = (input_hist[i], output_hist.get(i))
1152 1152 else:
1153 1153 hist[i] = input_hist[i]
1154 1154 if len(hist)==0:
1155 1155 raise IndexError('No history for range of indices: %r' % index)
1156 1156 return hist
1157 1157
1158 1158 #-------------------------------------------------------------------------
1159 1159 # Things related to exception handling and tracebacks (not debugging)
1160 1160 #-------------------------------------------------------------------------
1161 1161
1162 1162 def init_traceback_handlers(self, custom_exceptions):
1163 1163 # Syntax error handler.
1164 1164 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1165 1165
1166 1166 # The interactive one is initialized with an offset, meaning we always
1167 1167 # want to remove the topmost item in the traceback, which is our own
1168 1168 # internal code. Valid modes: ['Plain','Context','Verbose']
1169 1169 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1170 1170 color_scheme='NoColor',
1171 1171 tb_offset = 1)
1172 1172
1173 1173 # The instance will store a pointer to the system-wide exception hook,
1174 1174 # so that runtime code (such as magics) can access it. This is because
1175 1175 # during the read-eval loop, it may get temporarily overwritten.
1176 1176 self.sys_excepthook = sys.excepthook
1177 1177
1178 1178 # and add any custom exception handlers the user may have specified
1179 1179 self.set_custom_exc(*custom_exceptions)
1180 1180
1181 1181 # Set the exception mode
1182 1182 self.InteractiveTB.set_mode(mode=self.xmode)
1183 1183
1184 1184 def set_custom_exc(self,exc_tuple,handler):
1185 1185 """set_custom_exc(exc_tuple,handler)
1186 1186
1187 1187 Set a custom exception handler, which will be called if any of the
1188 1188 exceptions in exc_tuple occur in the mainloop (specifically, in the
1189 1189 runcode() method.
1190 1190
1191 1191 Inputs:
1192 1192
1193 1193 - exc_tuple: a *tuple* of valid exceptions to call the defined
1194 1194 handler for. It is very important that you use a tuple, and NOT A
1195 1195 LIST here, because of the way Python's except statement works. If
1196 1196 you only want to trap a single exception, use a singleton tuple:
1197 1197
1198 1198 exc_tuple == (MyCustomException,)
1199 1199
1200 1200 - handler: this must be defined as a function with the following
1201 1201 basic interface: def my_handler(self,etype,value,tb).
1202 1202
1203 1203 This will be made into an instance method (via new.instancemethod)
1204 1204 of IPython itself, and it will be called if any of the exceptions
1205 1205 listed in the exc_tuple are caught. If the handler is None, an
1206 1206 internal basic one is used, which just prints basic info.
1207 1207
1208 1208 WARNING: by putting in your own exception handler into IPython's main
1209 1209 execution loop, you run a very good chance of nasty crashes. This
1210 1210 facility should only be used if you really know what you are doing."""
1211 1211
1212 1212 assert type(exc_tuple)==type(()) , \
1213 1213 "The custom exceptions must be given AS A TUPLE."
1214 1214
1215 1215 def dummy_handler(self,etype,value,tb):
1216 1216 print '*** Simple custom exception handler ***'
1217 1217 print 'Exception type :',etype
1218 1218 print 'Exception value:',value
1219 1219 print 'Traceback :',tb
1220 1220 print 'Source code :','\n'.join(self.buffer)
1221 1221
1222 1222 if handler is None: handler = dummy_handler
1223 1223
1224 1224 self.CustomTB = new.instancemethod(handler,self,self.__class__)
1225 1225 self.custom_exceptions = exc_tuple
1226 1226
1227 1227 def excepthook(self, etype, value, tb):
1228 1228 """One more defense for GUI apps that call sys.excepthook.
1229 1229
1230 1230 GUI frameworks like wxPython trap exceptions and call
1231 1231 sys.excepthook themselves. I guess this is a feature that
1232 1232 enables them to keep running after exceptions that would
1233 1233 otherwise kill their mainloop. This is a bother for IPython
1234 1234 which excepts to catch all of the program exceptions with a try:
1235 1235 except: statement.
1236 1236
1237 1237 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1238 1238 any app directly invokes sys.excepthook, it will look to the user like
1239 1239 IPython crashed. In order to work around this, we can disable the
1240 1240 CrashHandler and replace it with this excepthook instead, which prints a
1241 1241 regular traceback using our InteractiveTB. In this fashion, apps which
1242 1242 call sys.excepthook will generate a regular-looking exception from
1243 1243 IPython, and the CrashHandler will only be triggered by real IPython
1244 1244 crashes.
1245 1245
1246 1246 This hook should be used sparingly, only in places which are not likely
1247 1247 to be true IPython errors.
1248 1248 """
1249 1249 self.showtraceback((etype,value,tb),tb_offset=0)
1250 1250
1251 1251 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1252 1252 exception_only=False):
1253 1253 """Display the exception that just occurred.
1254 1254
1255 1255 If nothing is known about the exception, this is the method which
1256 1256 should be used throughout the code for presenting user tracebacks,
1257 1257 rather than directly invoking the InteractiveTB object.
1258 1258
1259 1259 A specific showsyntaxerror() also exists, but this method can take
1260 1260 care of calling it if needed, so unless you are explicitly catching a
1261 1261 SyntaxError exception, don't try to analyze the stack manually and
1262 1262 simply call this method."""
1263 1263
1264 1264 try:
1265 1265 if exc_tuple is None:
1266 1266 etype, value, tb = sys.exc_info()
1267 1267 else:
1268 1268 etype, value, tb = exc_tuple
1269 1269
1270 1270 if etype is None:
1271 1271 if hasattr(sys, 'last_type'):
1272 1272 etype, value, tb = sys.last_type, sys.last_value, \
1273 1273 sys.last_traceback
1274 1274 else:
1275 1275 self.write('No traceback available to show.\n')
1276 1276 return
1277 1277
1278 1278 if etype is SyntaxError:
1279 1279 # Though this won't be called by syntax errors in the input
1280 1280 # line, there may be SyntaxError cases whith imported code.
1281 1281 self.showsyntaxerror(filename)
1282 1282 elif etype is UsageError:
1283 1283 print "UsageError:", value
1284 1284 else:
1285 1285 # WARNING: these variables are somewhat deprecated and not
1286 1286 # necessarily safe to use in a threaded environment, but tools
1287 1287 # like pdb depend on their existence, so let's set them. If we
1288 1288 # find problems in the field, we'll need to revisit their use.
1289 1289 sys.last_type = etype
1290 1290 sys.last_value = value
1291 1291 sys.last_traceback = tb
1292 1292
1293 1293 if etype in self.custom_exceptions:
1294 1294 self.CustomTB(etype,value,tb)
1295 1295 else:
1296 1296 if exception_only:
1297 1297 m = ('An exception has occurred, use %tb to see the '
1298 1298 'full traceback.')
1299 1299 print m
1300 1300 self.InteractiveTB.show_exception_only(etype, value)
1301 1301 else:
1302 1302 self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
1303 1303 if self.InteractiveTB.call_pdb:
1304 1304 # pdb mucks up readline, fix it back
1305 1305 self.set_completer()
1306 1306
1307 1307 except KeyboardInterrupt:
1308 1308 self.write("\nKeyboardInterrupt\n")
1309 1309
1310 1310
1311 1311 def showsyntaxerror(self, filename=None):
1312 1312 """Display the syntax error that just occurred.
1313 1313
1314 1314 This doesn't display a stack trace because there isn't one.
1315 1315
1316 1316 If a filename is given, it is stuffed in the exception instead
1317 1317 of what was there before (because Python's parser always uses
1318 1318 "<string>" when reading from a string).
1319 1319 """
1320 1320 etype, value, last_traceback = sys.exc_info()
1321 1321
1322 1322 # See note about these variables in showtraceback() above
1323 1323 sys.last_type = etype
1324 1324 sys.last_value = value
1325 1325 sys.last_traceback = last_traceback
1326 1326
1327 1327 if filename and etype is SyntaxError:
1328 1328 # Work hard to stuff the correct filename in the exception
1329 1329 try:
1330 1330 msg, (dummy_filename, lineno, offset, line) = value
1331 1331 except:
1332 1332 # Not the format we expect; leave it alone
1333 1333 pass
1334 1334 else:
1335 1335 # Stuff in the right filename
1336 1336 try:
1337 1337 # Assume SyntaxError is a class exception
1338 1338 value = SyntaxError(msg, (filename, lineno, offset, line))
1339 1339 except:
1340 1340 # If that failed, assume SyntaxError is a string
1341 1341 value = msg, (filename, lineno, offset, line)
1342 1342 self.SyntaxTB(etype,value,[])
1343 1343
1344 1344 #-------------------------------------------------------------------------
1345 1345 # Things related to tab completion
1346 1346 #-------------------------------------------------------------------------
1347 1347
1348 1348 def complete(self, text):
1349 1349 """Return a sorted list of all possible completions on text.
1350 1350
1351 1351 Inputs:
1352 1352
1353 1353 - text: a string of text to be completed on.
1354 1354
1355 1355 This is a wrapper around the completion mechanism, similar to what
1356 1356 readline does at the command line when the TAB key is hit. By
1357 1357 exposing it as a method, it can be used by other non-readline
1358 1358 environments (such as GUIs) for text completion.
1359 1359
1360 1360 Simple usage example:
1361 1361
1362 1362 In [7]: x = 'hello'
1363 1363
1364 1364 In [8]: x
1365 1365 Out[8]: 'hello'
1366 1366
1367 1367 In [9]: print x
1368 1368 hello
1369 1369
1370 1370 In [10]: _ip.complete('x.l')
1371 1371 Out[10]: ['x.ljust', 'x.lower', 'x.lstrip']
1372 1372 """
1373 1373
1374 1374 # Inject names into __builtin__ so we can complete on the added names.
1375 1375 with self.builtin_trap:
1376 1376 complete = self.Completer.complete
1377 1377 state = 0
1378 1378 # use a dict so we get unique keys, since ipyhton's multiple
1379 1379 # completers can return duplicates. When we make 2.4 a requirement,
1380 1380 # start using sets instead, which are faster.
1381 1381 comps = {}
1382 1382 while True:
1383 1383 newcomp = complete(text,state,line_buffer=text)
1384 1384 if newcomp is None:
1385 1385 break
1386 1386 comps[newcomp] = 1
1387 1387 state += 1
1388 1388 outcomps = comps.keys()
1389 1389 outcomps.sort()
1390 1390 #print "T:",text,"OC:",outcomps # dbg
1391 1391 #print "vars:",self.user_ns.keys()
1392 1392 return outcomps
1393 1393
1394 1394 def set_custom_completer(self,completer,pos=0):
1395 1395 """Adds a new custom completer function.
1396 1396
1397 1397 The position argument (defaults to 0) is the index in the completers
1398 1398 list where you want the completer to be inserted."""
1399 1399
1400 1400 newcomp = new.instancemethod(completer,self.Completer,
1401 1401 self.Completer.__class__)
1402 1402 self.Completer.matchers.insert(pos,newcomp)
1403 1403
1404 1404 def set_completer(self):
1405 1405 """Reset readline's completer to be our own."""
1406 1406 self.readline.set_completer(self.Completer.complete)
1407 1407
1408 1408 def set_completer_frame(self, frame=None):
1409 1409 """Set the frame of the completer."""
1410 1410 if frame:
1411 1411 self.Completer.namespace = frame.f_locals
1412 1412 self.Completer.global_namespace = frame.f_globals
1413 1413 else:
1414 1414 self.Completer.namespace = self.user_ns
1415 1415 self.Completer.global_namespace = self.user_global_ns
1416 1416
1417 1417 #-------------------------------------------------------------------------
1418 1418 # Things related to readline
1419 1419 #-------------------------------------------------------------------------
1420 1420
1421 1421 def init_readline(self):
1422 1422 """Command history completion/saving/reloading."""
1423 1423
1424 1424 if self.readline_use:
1425 1425 import IPython.utils.rlineimpl as readline
1426 1426
1427 1427 self.rl_next_input = None
1428 1428 self.rl_do_indent = False
1429 1429
1430 1430 if not self.readline_use or not readline.have_readline:
1431 1431 self.has_readline = False
1432 1432 self.readline = None
1433 1433 # Set a number of methods that depend on readline to be no-op
1434 1434 self.savehist = no_op
1435 1435 self.reloadhist = no_op
1436 1436 self.set_completer = no_op
1437 1437 self.set_custom_completer = no_op
1438 1438 self.set_completer_frame = no_op
1439 1439 warn('Readline services not available or not loaded.')
1440 1440 else:
1441 1441 self.has_readline = True
1442 1442 self.readline = readline
1443 1443 sys.modules['readline'] = readline
1444 1444 import atexit
1445 1445 from IPython.core.completer import IPCompleter
1446 1446 self.Completer = IPCompleter(self,
1447 1447 self.user_ns,
1448 1448 self.user_global_ns,
1449 1449 self.readline_omit__names,
1450 1450 self.alias_manager.alias_table)
1451 1451 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1452 1452 self.strdispatchers['complete_command'] = sdisp
1453 1453 self.Completer.custom_completers = sdisp
1454 1454 # Platform-specific configuration
1455 1455 if os.name == 'nt':
1456 1456 self.readline_startup_hook = readline.set_pre_input_hook
1457 1457 else:
1458 1458 self.readline_startup_hook = readline.set_startup_hook
1459 1459
1460 1460 # Load user's initrc file (readline config)
1461 1461 # Or if libedit is used, load editrc.
1462 1462 inputrc_name = os.environ.get('INPUTRC')
1463 1463 if inputrc_name is None:
1464 1464 home_dir = get_home_dir()
1465 1465 if home_dir is not None:
1466 1466 inputrc_name = '.inputrc'
1467 1467 if readline.uses_libedit:
1468 1468 inputrc_name = '.editrc'
1469 1469 inputrc_name = os.path.join(home_dir, inputrc_name)
1470 1470 if os.path.isfile(inputrc_name):
1471 1471 try:
1472 1472 readline.read_init_file(inputrc_name)
1473 1473 except:
1474 1474 warn('Problems reading readline initialization file <%s>'
1475 1475 % inputrc_name)
1476 1476
1477 1477 # save this in sys so embedded copies can restore it properly
1478 1478 sys.ipcompleter = self.Completer.complete
1479 1479 self.set_completer()
1480 1480
1481 1481 # Configure readline according to user's prefs
1482 1482 # This is only done if GNU readline is being used. If libedit
1483 1483 # is being used (as on Leopard) the readline config is
1484 1484 # not run as the syntax for libedit is different.
1485 1485 if not readline.uses_libedit:
1486 1486 for rlcommand in self.readline_parse_and_bind:
1487 1487 #print "loading rl:",rlcommand # dbg
1488 1488 readline.parse_and_bind(rlcommand)
1489 1489
1490 1490 # Remove some chars from the delimiters list. If we encounter
1491 1491 # unicode chars, discard them.
1492 1492 delims = readline.get_completer_delims().encode("ascii", "ignore")
1493 1493 delims = delims.translate(string._idmap,
1494 1494 self.readline_remove_delims)
1495 1495 readline.set_completer_delims(delims)
1496 1496 # otherwise we end up with a monster history after a while:
1497 1497 readline.set_history_length(1000)
1498 1498 try:
1499 1499 #print '*** Reading readline history' # dbg
1500 1500 readline.read_history_file(self.histfile)
1501 1501 except IOError:
1502 1502 pass # It doesn't exist yet.
1503 1503
1504 1504 atexit.register(self.atexit_operations)
1505 1505 del atexit
1506 1506
1507 1507 # Configure auto-indent for all platforms
1508 1508 self.set_autoindent(self.autoindent)
1509 1509
1510 1510 def set_next_input(self, s):
1511 1511 """ Sets the 'default' input string for the next command line.
1512 1512
1513 1513 Requires readline.
1514 1514
1515 1515 Example:
1516 1516
1517 1517 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1518 1518 [D:\ipython]|2> Hello Word_ # cursor is here
1519 1519 """
1520 1520
1521 1521 self.rl_next_input = s
1522 1522
1523 1523 # Maybe move this to the terminal subclass?
1524 1524 def pre_readline(self):
1525 1525 """readline hook to be used at the start of each line.
1526 1526
1527 1527 Currently it handles auto-indent only."""
1528 1528
1529 1529 if self.rl_do_indent:
1530 1530 self.readline.insert_text(self._indent_current_str())
1531 1531 if self.rl_next_input is not None:
1532 1532 self.readline.insert_text(self.rl_next_input)
1533 1533 self.rl_next_input = None
1534 1534
1535 1535 def _indent_current_str(self):
1536 1536 """return the current level of indentation as a string"""
1537 1537 return self.indent_current_nsp * ' '
1538 1538
1539 1539 #-------------------------------------------------------------------------
1540 1540 # Things related to magics
1541 1541 #-------------------------------------------------------------------------
1542 1542
1543 1543 def init_magics(self):
1544 1544 # FIXME: Move the color initialization to the DisplayHook, which
1545 1545 # should be split into a prompt manager and displayhook. We probably
1546 1546 # even need a centralize colors management object.
1547 1547 self.magic_colors(self.colors)
1548 1548 # History was moved to a separate module
1549 1549 from . import history
1550 1550 history.init_ipython(self)
1551 1551
1552 1552 def magic(self,arg_s):
1553 1553 """Call a magic function by name.
1554 1554
1555 1555 Input: a string containing the name of the magic function to call and any
1556 1556 additional arguments to be passed to the magic.
1557 1557
1558 1558 magic('name -opt foo bar') is equivalent to typing at the ipython
1559 1559 prompt:
1560 1560
1561 1561 In[1]: %name -opt foo bar
1562 1562
1563 1563 To call a magic without arguments, simply use magic('name').
1564 1564
1565 1565 This provides a proper Python function to call IPython's magics in any
1566 1566 valid Python code you can type at the interpreter, including loops and
1567 1567 compound statements.
1568 1568 """
1569 1569 args = arg_s.split(' ',1)
1570 1570 magic_name = args[0]
1571 1571 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1572 1572
1573 1573 try:
1574 1574 magic_args = args[1]
1575 1575 except IndexError:
1576 1576 magic_args = ''
1577 1577 fn = getattr(self,'magic_'+magic_name,None)
1578 1578 if fn is None:
1579 1579 error("Magic function `%s` not found." % magic_name)
1580 1580 else:
1581 1581 magic_args = self.var_expand(magic_args,1)
1582 1582 with nested(self.builtin_trap,):
1583 1583 result = fn(magic_args)
1584 1584 return result
1585 1585
1586 1586 def define_magic(self, magicname, func):
1587 1587 """Expose own function as magic function for ipython
1588 1588
1589 1589 def foo_impl(self,parameter_s=''):
1590 1590 'My very own magic!. (Use docstrings, IPython reads them).'
1591 1591 print 'Magic function. Passed parameter is between < >:'
1592 1592 print '<%s>' % parameter_s
1593 1593 print 'The self object is:',self
1594 1594
1595 1595 self.define_magic('foo',foo_impl)
1596 1596 """
1597 1597
1598 1598 import new
1599 1599 im = new.instancemethod(func,self, self.__class__)
1600 1600 old = getattr(self, "magic_" + magicname, None)
1601 1601 setattr(self, "magic_" + magicname, im)
1602 1602 return old
1603 1603
1604 1604 #-------------------------------------------------------------------------
1605 1605 # Things related to macros
1606 1606 #-------------------------------------------------------------------------
1607 1607
1608 1608 def define_macro(self, name, themacro):
1609 1609 """Define a new macro
1610 1610
1611 1611 Parameters
1612 1612 ----------
1613 1613 name : str
1614 1614 The name of the macro.
1615 1615 themacro : str or Macro
1616 1616 The action to do upon invoking the macro. If a string, a new
1617 1617 Macro object is created by passing the string to it.
1618 1618 """
1619 1619
1620 1620 from IPython.core import macro
1621 1621
1622 1622 if isinstance(themacro, basestring):
1623 1623 themacro = macro.Macro(themacro)
1624 1624 if not isinstance(themacro, macro.Macro):
1625 1625 raise ValueError('A macro must be a string or a Macro instance.')
1626 1626 self.user_ns[name] = themacro
1627 1627
1628 1628 #-------------------------------------------------------------------------
1629 1629 # Things related to the running of system commands
1630 1630 #-------------------------------------------------------------------------
1631 1631
1632 1632 def system(self, cmd):
1633 1633 """Make a system call, using IPython."""
1634 1634 return self.hooks.shell_hook(self.var_expand(cmd, depth=2))
1635 1635
1636 1636 #-------------------------------------------------------------------------
1637 1637 # Things related to aliases
1638 1638 #-------------------------------------------------------------------------
1639 1639
1640 1640 def init_alias(self):
1641 1641 self.alias_manager = AliasManager(shell=self, config=self.config)
1642 1642 self.ns_table['alias'] = self.alias_manager.alias_table,
1643 1643
1644 1644 #-------------------------------------------------------------------------
1645 1645 # Things related to extensions and plugins
1646 1646 #-------------------------------------------------------------------------
1647 1647
1648 1648 def init_extension_manager(self):
1649 1649 self.extension_manager = ExtensionManager(shell=self, config=self.config)
1650 1650
1651 1651 def init_plugin_manager(self):
1652 1652 self.plugin_manager = PluginManager(config=self.config)
1653 1653
1654 1654 #-------------------------------------------------------------------------
1655 1655 # Things related to payloads
1656 1656 #-------------------------------------------------------------------------
1657 1657
1658 1658 def init_payload(self):
1659 1659 self.payload_manager = PayloadManager(config=self.config)
1660 1660
1661 1661 #-------------------------------------------------------------------------
1662 1662 # Things related to the prefilter
1663 1663 #-------------------------------------------------------------------------
1664 1664
1665 1665 def init_prefilter(self):
1666 1666 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
1667 1667 # Ultimately this will be refactored in the new interpreter code, but
1668 1668 # for now, we should expose the main prefilter method (there's legacy
1669 1669 # code out there that may rely on this).
1670 1670 self.prefilter = self.prefilter_manager.prefilter_lines
1671 1671
1672 1672 #-------------------------------------------------------------------------
1673 1673 # Things related to the running of code
1674 1674 #-------------------------------------------------------------------------
1675 1675
1676 1676 def ex(self, cmd):
1677 1677 """Execute a normal python statement in user namespace."""
1678 1678 with nested(self.builtin_trap,):
1679 1679 exec cmd in self.user_global_ns, self.user_ns
1680 1680
1681 1681 def ev(self, expr):
1682 1682 """Evaluate python expression expr in user namespace.
1683 1683
1684 1684 Returns the result of evaluation
1685 1685 """
1686 1686 with nested(self.builtin_trap,):
1687 1687 return eval(expr, self.user_global_ns, self.user_ns)
1688 1688
1689 1689 def safe_execfile(self, fname, *where, **kw):
1690 1690 """A safe version of the builtin execfile().
1691 1691
1692 1692 This version will never throw an exception, but instead print
1693 1693 helpful error messages to the screen. This only works on pure
1694 1694 Python files with the .py extension.
1695 1695
1696 1696 Parameters
1697 1697 ----------
1698 1698 fname : string
1699 1699 The name of the file to be executed.
1700 1700 where : tuple
1701 1701 One or two namespaces, passed to execfile() as (globals,locals).
1702 1702 If only one is given, it is passed as both.
1703 1703 exit_ignore : bool (False)
1704 1704 If True, then silence SystemExit for non-zero status (it is always
1705 1705 silenced for zero status, as it is so common).
1706 1706 """
1707 1707 kw.setdefault('exit_ignore', False)
1708 1708
1709 1709 fname = os.path.abspath(os.path.expanduser(fname))
1710 1710
1711 1711 # Make sure we have a .py file
1712 1712 if not fname.endswith('.py'):
1713 1713 warn('File must end with .py to be run using execfile: <%s>' % fname)
1714 1714
1715 1715 # Make sure we can open the file
1716 1716 try:
1717 1717 with open(fname) as thefile:
1718 1718 pass
1719 1719 except:
1720 1720 warn('Could not open file <%s> for safe execution.' % fname)
1721 1721 return
1722 1722
1723 1723 # Find things also in current directory. This is needed to mimic the
1724 1724 # behavior of running a script from the system command line, where
1725 1725 # Python inserts the script's directory into sys.path
1726 1726 dname = os.path.dirname(fname)
1727 1727
1728 1728 with prepended_to_syspath(dname):
1729 1729 try:
1730 1730 execfile(fname,*where)
1731 1731 except SystemExit, status:
1732 1732 # If the call was made with 0 or None exit status (sys.exit(0)
1733 1733 # or sys.exit() ), don't bother showing a traceback, as both of
1734 1734 # these are considered normal by the OS:
1735 1735 # > python -c'import sys;sys.exit(0)'; echo $?
1736 1736 # 0
1737 1737 # > python -c'import sys;sys.exit()'; echo $?
1738 1738 # 0
1739 1739 # For other exit status, we show the exception unless
1740 1740 # explicitly silenced, but only in short form.
1741 1741 if status.code not in (0, None) and not kw['exit_ignore']:
1742 1742 self.showtraceback(exception_only=True)
1743 1743 except:
1744 1744 self.showtraceback()
1745 1745
1746 1746 def safe_execfile_ipy(self, fname):
1747 1747 """Like safe_execfile, but for .ipy files with IPython syntax.
1748 1748
1749 1749 Parameters
1750 1750 ----------
1751 1751 fname : str
1752 1752 The name of the file to execute. The filename must have a
1753 1753 .ipy extension.
1754 1754 """
1755 1755 fname = os.path.abspath(os.path.expanduser(fname))
1756 1756
1757 1757 # Make sure we have a .py file
1758 1758 if not fname.endswith('.ipy'):
1759 1759 warn('File must end with .py to be run using execfile: <%s>' % fname)
1760 1760
1761 1761 # Make sure we can open the file
1762 1762 try:
1763 1763 with open(fname) as thefile:
1764 1764 pass
1765 1765 except:
1766 1766 warn('Could not open file <%s> for safe execution.' % fname)
1767 1767 return
1768 1768
1769 1769 # Find things also in current directory. This is needed to mimic the
1770 1770 # behavior of running a script from the system command line, where
1771 1771 # Python inserts the script's directory into sys.path
1772 1772 dname = os.path.dirname(fname)
1773 1773
1774 1774 with prepended_to_syspath(dname):
1775 1775 try:
1776 1776 with open(fname) as thefile:
1777 1777 script = thefile.read()
1778 1778 # self.runlines currently captures all exceptions
1779 1779 # raise in user code. It would be nice if there were
1780 1780 # versions of runlines, execfile that did raise, so
1781 1781 # we could catch the errors.
1782 1782 self.runlines(script, clean=True)
1783 1783 except:
1784 1784 self.showtraceback()
1785 1785 warn('Unknown failure executing file: <%s>' % fname)
1786 1786
1787 1787 def runlines(self, lines, clean=False):
1788 1788 """Run a string of one or more lines of source.
1789 1789
1790 1790 This method is capable of running a string containing multiple source
1791 1791 lines, as if they had been entered at the IPython prompt. Since it
1792 1792 exposes IPython's processing machinery, the given strings can contain
1793 1793 magic calls (%magic), special shell access (!cmd), etc.
1794 1794 """
1795 1795
1796 1796 if isinstance(lines, (list, tuple)):
1797 1797 lines = '\n'.join(lines)
1798 1798
1799 1799 if clean:
1800 1800 lines = self._cleanup_ipy_script(lines)
1801 1801
1802 1802 # We must start with a clean buffer, in case this is run from an
1803 1803 # interactive IPython session (via a magic, for example).
1804 1804 self.resetbuffer()
1805 1805 lines = lines.splitlines()
1806 1806 more = 0
1807 1807
1808 1808 with nested(self.builtin_trap, self.display_trap):
1809 1809 for line in lines:
1810 1810 # skip blank lines so we don't mess up the prompt counter, but do
1811 1811 # NOT skip even a blank line if we are in a code block (more is
1812 1812 # true)
1813 1813
1814 1814 if line or more:
1815 1815 # push to raw history, so hist line numbers stay in sync
1816 1816 self.input_hist_raw.append("# " + line + "\n")
1817 1817 prefiltered = self.prefilter_manager.prefilter_lines(line,more)
1818 1818 more = self.push_line(prefiltered)
1819 1819 # IPython's runsource returns None if there was an error
1820 1820 # compiling the code. This allows us to stop processing right
1821 1821 # away, so the user gets the error message at the right place.
1822 1822 if more is None:
1823 1823 break
1824 1824 else:
1825 1825 self.input_hist_raw.append("\n")
1826 1826 # final newline in case the input didn't have it, so that the code
1827 1827 # actually does get executed
1828 1828 if more:
1829 1829 self.push_line('\n')
1830 1830
1831 1831 def runsource(self, source, filename='<input>', symbol='single'):
1832 1832 """Compile and run some source in the interpreter.
1833 1833
1834 1834 Arguments are as for compile_command().
1835 1835
1836 1836 One several things can happen:
1837 1837
1838 1838 1) The input is incorrect; compile_command() raised an
1839 1839 exception (SyntaxError or OverflowError). A syntax traceback
1840 1840 will be printed by calling the showsyntaxerror() method.
1841 1841
1842 1842 2) The input is incomplete, and more input is required;
1843 1843 compile_command() returned None. Nothing happens.
1844 1844
1845 1845 3) The input is complete; compile_command() returned a code
1846 1846 object. The code is executed by calling self.runcode() (which
1847 1847 also handles run-time exceptions, except for SystemExit).
1848 1848
1849 1849 The return value is:
1850 1850
1851 1851 - True in case 2
1852 1852
1853 1853 - False in the other cases, unless an exception is raised, where
1854 1854 None is returned instead. This can be used by external callers to
1855 1855 know whether to continue feeding input or not.
1856 1856
1857 1857 The return value can be used to decide whether to use sys.ps1 or
1858 1858 sys.ps2 to prompt the next line."""
1859 1859
1860 1860 # if the source code has leading blanks, add 'if 1:\n' to it
1861 1861 # this allows execution of indented pasted code. It is tempting
1862 1862 # to add '\n' at the end of source to run commands like ' a=1'
1863 1863 # directly, but this fails for more complicated scenarios
1864 1864 source=source.encode(self.stdin_encoding)
1865 1865 if source[:1] in [' ', '\t']:
1866 1866 source = 'if 1:\n%s' % source
1867 1867
1868 1868 try:
1869 1869 code = self.compile(source,filename,symbol)
1870 1870 except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
1871 1871 # Case 1
1872 1872 self.showsyntaxerror(filename)
1873 1873 return None
1874 1874
1875 1875 if code is None:
1876 1876 # Case 2
1877 1877 return True
1878 1878
1879 1879 # Case 3
1880 1880 # We store the code object so that threaded shells and
1881 1881 # custom exception handlers can access all this info if needed.
1882 1882 # The source corresponding to this can be obtained from the
1883 1883 # buffer attribute as '\n'.join(self.buffer).
1884 1884 self.code_to_run = code
1885 1885 # now actually execute the code object
1886 1886 if self.runcode(code) == 0:
1887 1887 return False
1888 1888 else:
1889 1889 return None
1890 1890
1891 1891 def runcode(self,code_obj):
1892 1892 """Execute a code object.
1893 1893
1894 1894 When an exception occurs, self.showtraceback() is called to display a
1895 1895 traceback.
1896 1896
1897 1897 Return value: a flag indicating whether the code to be run completed
1898 1898 successfully:
1899 1899
1900 1900 - 0: successful execution.
1901 1901 - 1: an error occurred.
1902 1902 """
1903 1903
1904 # Clear the payload before executing new code.
1905 self.payload_manager.clear_payload()
1906
1907 1904 # Set our own excepthook in case the user code tries to call it
1908 1905 # directly, so that the IPython crash handler doesn't get triggered
1909 1906 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
1910 1907
1911 1908 # we save the original sys.excepthook in the instance, in case config
1912 1909 # code (such as magics) needs access to it.
1913 1910 self.sys_excepthook = old_excepthook
1914 1911 outflag = 1 # happens in more places, so it's easier as default
1915 1912 try:
1916 1913 try:
1917 1914 self.hooks.pre_runcode_hook()
1918 1915 exec code_obj in self.user_global_ns, self.user_ns
1919 1916 finally:
1920 1917 # Reset our crash handler in place
1921 1918 sys.excepthook = old_excepthook
1922 1919 except SystemExit:
1923 1920 self.resetbuffer()
1924 1921 self.showtraceback(exception_only=True)
1925 1922 warn("To exit: use any of 'exit', 'quit', %Exit or Ctrl-D.", level=1)
1926 1923 except self.custom_exceptions:
1927 1924 etype,value,tb = sys.exc_info()
1928 1925 self.CustomTB(etype,value,tb)
1929 1926 except:
1930 1927 self.showtraceback()
1931 1928 else:
1932 1929 outflag = 0
1933 1930 if softspace(sys.stdout, 0):
1934 1931 print
1935 1932 # Flush out code object which has been run (and source)
1936 1933 self.code_to_run = None
1937 1934 return outflag
1938 1935
1939 1936 def push_line(self, line):
1940 1937 """Push a line to the interpreter.
1941 1938
1942 1939 The line should not have a trailing newline; it may have
1943 1940 internal newlines. The line is appended to a buffer and the
1944 1941 interpreter's runsource() method is called with the
1945 1942 concatenated contents of the buffer as source. If this
1946 1943 indicates that the command was executed or invalid, the buffer
1947 1944 is reset; otherwise, the command is incomplete, and the buffer
1948 1945 is left as it was after the line was appended. The return
1949 1946 value is 1 if more input is required, 0 if the line was dealt
1950 1947 with in some way (this is the same as runsource()).
1951 1948 """
1952 1949
1953 1950 # autoindent management should be done here, and not in the
1954 1951 # interactive loop, since that one is only seen by keyboard input. We
1955 1952 # need this done correctly even for code run via runlines (which uses
1956 1953 # push).
1957 1954
1958 1955 #print 'push line: <%s>' % line # dbg
1959 1956 for subline in line.splitlines():
1960 1957 self._autoindent_update(subline)
1961 1958 self.buffer.append(line)
1962 1959 more = self.runsource('\n'.join(self.buffer), self.filename)
1963 1960 if not more:
1964 1961 self.resetbuffer()
1965 1962 return more
1966 1963
1967 1964 def resetbuffer(self):
1968 1965 """Reset the input buffer."""
1969 1966 self.buffer[:] = []
1970 1967
1971 1968 def _is_secondary_block_start(self, s):
1972 1969 if not s.endswith(':'):
1973 1970 return False
1974 1971 if (s.startswith('elif') or
1975 1972 s.startswith('else') or
1976 1973 s.startswith('except') or
1977 1974 s.startswith('finally')):
1978 1975 return True
1979 1976
1980 1977 def _cleanup_ipy_script(self, script):
1981 1978 """Make a script safe for self.runlines()
1982 1979
1983 1980 Currently, IPython is lines based, with blocks being detected by
1984 1981 empty lines. This is a problem for block based scripts that may
1985 1982 not have empty lines after blocks. This script adds those empty
1986 1983 lines to make scripts safe for running in the current line based
1987 1984 IPython.
1988 1985 """
1989 1986 res = []
1990 1987 lines = script.splitlines()
1991 1988 level = 0
1992 1989
1993 1990 for l in lines:
1994 1991 lstripped = l.lstrip()
1995 1992 stripped = l.strip()
1996 1993 if not stripped:
1997 1994 continue
1998 1995 newlevel = len(l) - len(lstripped)
1999 1996 if level > 0 and newlevel == 0 and \
2000 1997 not self._is_secondary_block_start(stripped):
2001 1998 # add empty line
2002 1999 res.append('')
2003 2000 res.append(l)
2004 2001 level = newlevel
2005 2002
2006 2003 return '\n'.join(res) + '\n'
2007 2004
2008 2005 def _autoindent_update(self,line):
2009 2006 """Keep track of the indent level."""
2010 2007
2011 2008 #debugx('line')
2012 2009 #debugx('self.indent_current_nsp')
2013 2010 if self.autoindent:
2014 2011 if line:
2015 2012 inisp = num_ini_spaces(line)
2016 2013 if inisp < self.indent_current_nsp:
2017 2014 self.indent_current_nsp = inisp
2018 2015
2019 2016 if line[-1] == ':':
2020 2017 self.indent_current_nsp += 4
2021 2018 elif dedent_re.match(line):
2022 2019 self.indent_current_nsp -= 4
2023 2020 else:
2024 2021 self.indent_current_nsp = 0
2025 2022
2026 2023 #-------------------------------------------------------------------------
2027 2024 # Things related to GUI support and pylab
2028 2025 #-------------------------------------------------------------------------
2029 2026
2030 2027 def enable_pylab(self, gui=None):
2031 2028 raise NotImplementedError('Implement enable_pylab in a subclass')
2032 2029
2033 2030 #-------------------------------------------------------------------------
2034 2031 # Utilities
2035 2032 #-------------------------------------------------------------------------
2036 2033
2037 2034 def getoutput(self, cmd):
2038 2035 return getoutput(self.var_expand(cmd,depth=2),
2039 2036 header=self.system_header,
2040 2037 verbose=self.system_verbose)
2041 2038
2042 2039 def getoutputerror(self, cmd):
2043 2040 return getoutputerror(self.var_expand(cmd,depth=2),
2044 2041 header=self.system_header,
2045 2042 verbose=self.system_verbose)
2046 2043
2047 2044 def var_expand(self,cmd,depth=0):
2048 2045 """Expand python variables in a string.
2049 2046
2050 2047 The depth argument indicates how many frames above the caller should
2051 2048 be walked to look for the local namespace where to expand variables.
2052 2049
2053 2050 The global namespace for expansion is always the user's interactive
2054 2051 namespace.
2055 2052 """
2056 2053
2057 2054 return str(ItplNS(cmd,
2058 2055 self.user_ns, # globals
2059 2056 # Skip our own frame in searching for locals:
2060 2057 sys._getframe(depth+1).f_locals # locals
2061 2058 ))
2062 2059
2063 2060 def mktempfile(self,data=None):
2064 2061 """Make a new tempfile and return its filename.
2065 2062
2066 2063 This makes a call to tempfile.mktemp, but it registers the created
2067 2064 filename internally so ipython cleans it up at exit time.
2068 2065
2069 2066 Optional inputs:
2070 2067
2071 2068 - data(None): if data is given, it gets written out to the temp file
2072 2069 immediately, and the file is closed again."""
2073 2070
2074 2071 filename = tempfile.mktemp('.py','ipython_edit_')
2075 2072 self.tempfiles.append(filename)
2076 2073
2077 2074 if data:
2078 2075 tmp_file = open(filename,'w')
2079 2076 tmp_file.write(data)
2080 2077 tmp_file.close()
2081 2078 return filename
2082 2079
2083 2080 # TODO: This should be removed when Term is refactored.
2084 2081 def write(self,data):
2085 2082 """Write a string to the default output"""
2086 2083 IPython.utils.io.Term.cout.write(data)
2087 2084
2088 2085 # TODO: This should be removed when Term is refactored.
2089 2086 def write_err(self,data):
2090 2087 """Write a string to the default error output"""
2091 2088 IPython.utils.io.Term.cerr.write(data)
2092 2089
2093 2090 def ask_yes_no(self,prompt,default=True):
2094 2091 if self.quiet:
2095 2092 return True
2096 2093 return ask_yes_no(prompt,default)
2097 2094
2098 2095 #-------------------------------------------------------------------------
2099 2096 # Things related to IPython exiting
2100 2097 #-------------------------------------------------------------------------
2101 2098
2102 2099 def atexit_operations(self):
2103 2100 """This will be executed at the time of exit.
2104 2101
2105 2102 Saving of persistent data should be performed here.
2106 2103 """
2107 2104 self.savehist()
2108 2105
2109 2106 # Cleanup all tempfiles left around
2110 2107 for tfile in self.tempfiles:
2111 2108 try:
2112 2109 os.unlink(tfile)
2113 2110 except OSError:
2114 2111 pass
2115 2112
2116 2113 # Clear all user namespaces to release all references cleanly.
2117 2114 self.reset()
2118 2115
2119 2116 # Run user hooks
2120 2117 self.hooks.shutdown_hook()
2121 2118
2122 2119 def cleanup(self):
2123 2120 self.restore_sys_module_state()
2124 2121
2125 2122
2126 2123 class InteractiveShellABC(object):
2127 2124 """An abstract base class for InteractiveShell."""
2128 2125 __metaclass__ = abc.ABCMeta
2129 2126
2130 2127 InteractiveShellABC.register(InteractiveShell)
1 NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff
@@ -1,609 +1,609 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Tools for inspecting Python objects.
3 3
4 4 Uses syntax highlighting for presenting the various information elements.
5 5
6 6 Similar in spirit to the inspect module, but all calls take a name argument to
7 7 reference the name under which an object is being read.
8 8 """
9 9
10 10 #*****************************************************************************
11 11 # Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
12 12 #
13 13 # Distributed under the terms of the BSD License. The full license is in
14 14 # the file COPYING, distributed as part of this software.
15 15 #*****************************************************************************
16 16
17 17 __all__ = ['Inspector','InspectColors']
18 18
19 19 # stdlib modules
20 20 import __builtin__
21 21 import StringIO
22 22 import inspect
23 23 import linecache
24 24 import os
25 25 import string
26 26 import sys
27 27 import types
28 28
29 29 # IPython's own
30 from IPython.core.page import page
30 from IPython.core import page
31 31 from IPython.external.Itpl import itpl
32 32 from IPython.utils import PyColorize
33 33 import IPython.utils.io
34 34 from IPython.utils.text import indent
35 35 from IPython.utils.wildcard import list_namespace
36 36 from IPython.utils.coloransi import *
37 37
38 38 #****************************************************************************
39 39 # HACK!!! This is a crude fix for bugs in python 2.3's inspect module. We
40 40 # simply monkeypatch inspect with code copied from python 2.4.
41 41 if sys.version_info[:2] == (2,3):
42 42 from inspect import ismodule, getabsfile, modulesbyfile
43 43 def getmodule(object):
44 44 """Return the module an object was defined in, or None if not found."""
45 45 if ismodule(object):
46 46 return object
47 47 if hasattr(object, '__module__'):
48 48 return sys.modules.get(object.__module__)
49 49 try:
50 50 file = getabsfile(object)
51 51 except TypeError:
52 52 return None
53 53 if file in modulesbyfile:
54 54 return sys.modules.get(modulesbyfile[file])
55 55 for module in sys.modules.values():
56 56 if hasattr(module, '__file__'):
57 57 modulesbyfile[
58 58 os.path.realpath(
59 59 getabsfile(module))] = module.__name__
60 60 if file in modulesbyfile:
61 61 return sys.modules.get(modulesbyfile[file])
62 62 main = sys.modules['__main__']
63 63 if not hasattr(object, '__name__'):
64 64 return None
65 65 if hasattr(main, object.__name__):
66 66 mainobject = getattr(main, object.__name__)
67 67 if mainobject is object:
68 68 return main
69 69 builtin = sys.modules['__builtin__']
70 70 if hasattr(builtin, object.__name__):
71 71 builtinobject = getattr(builtin, object.__name__)
72 72 if builtinobject is object:
73 73 return builtin
74 74
75 75 inspect.getmodule = getmodule
76 76
77 77 #****************************************************************************
78 78 # Builtin color schemes
79 79
80 80 Colors = TermColors # just a shorthand
81 81
82 82 # Build a few color schemes
83 83 NoColor = ColorScheme(
84 84 'NoColor',{
85 85 'header' : Colors.NoColor,
86 86 'normal' : Colors.NoColor # color off (usu. Colors.Normal)
87 87 } )
88 88
89 89 LinuxColors = ColorScheme(
90 90 'Linux',{
91 91 'header' : Colors.LightRed,
92 92 'normal' : Colors.Normal # color off (usu. Colors.Normal)
93 93 } )
94 94
95 95 LightBGColors = ColorScheme(
96 96 'LightBG',{
97 97 'header' : Colors.Red,
98 98 'normal' : Colors.Normal # color off (usu. Colors.Normal)
99 99 } )
100 100
101 101 # Build table of color schemes (needed by the parser)
102 102 InspectColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
103 103 'Linux')
104 104
105 105 #****************************************************************************
106 106 # Auxiliary functions
107 107 def getdoc(obj):
108 108 """Stable wrapper around inspect.getdoc.
109 109
110 110 This can't crash because of attribute problems.
111 111
112 112 It also attempts to call a getdoc() method on the given object. This
113 113 allows objects which provide their docstrings via non-standard mechanisms
114 114 (like Pyro proxies) to still be inspected by ipython's ? system."""
115 115
116 116 ds = None # default return value
117 117 try:
118 118 ds = inspect.getdoc(obj)
119 119 except:
120 120 # Harden against an inspect failure, which can occur with
121 121 # SWIG-wrapped extensions.
122 122 pass
123 123 # Allow objects to offer customized documentation via a getdoc method:
124 124 try:
125 125 ds2 = obj.getdoc()
126 126 except:
127 127 pass
128 128 else:
129 129 # if we get extra info, we add it to the normal docstring.
130 130 if ds is None:
131 131 ds = ds2
132 132 else:
133 133 ds = '%s\n%s' % (ds,ds2)
134 134 return ds
135 135
136 136
137 137 def getsource(obj,is_binary=False):
138 138 """Wrapper around inspect.getsource.
139 139
140 140 This can be modified by other projects to provide customized source
141 141 extraction.
142 142
143 143 Inputs:
144 144
145 145 - obj: an object whose source code we will attempt to extract.
146 146
147 147 Optional inputs:
148 148
149 149 - is_binary: whether the object is known to come from a binary source.
150 150 This implementation will skip returning any output for binary objects, but
151 151 custom extractors may know how to meaningfully process them."""
152 152
153 153 if is_binary:
154 154 return None
155 155 else:
156 156 try:
157 157 src = inspect.getsource(obj)
158 158 except TypeError:
159 159 if hasattr(obj,'__class__'):
160 160 src = inspect.getsource(obj.__class__)
161 161 return src
162 162
163 163 def getargspec(obj):
164 164 """Get the names and default values of a function's arguments.
165 165
166 166 A tuple of four things is returned: (args, varargs, varkw, defaults).
167 167 'args' is a list of the argument names (it may contain nested lists).
168 168 'varargs' and 'varkw' are the names of the * and ** arguments or None.
169 169 'defaults' is an n-tuple of the default values of the last n arguments.
170 170
171 171 Modified version of inspect.getargspec from the Python Standard
172 172 Library."""
173 173
174 174 if inspect.isfunction(obj):
175 175 func_obj = obj
176 176 elif inspect.ismethod(obj):
177 177 func_obj = obj.im_func
178 178 else:
179 179 raise TypeError, 'arg is not a Python function'
180 180 args, varargs, varkw = inspect.getargs(func_obj.func_code)
181 181 return args, varargs, varkw, func_obj.func_defaults
182 182
183 183 #****************************************************************************
184 184 # Class definitions
185 185
186 186 class myStringIO(StringIO.StringIO):
187 187 """Adds a writeln method to normal StringIO."""
188 188 def writeln(self,*arg,**kw):
189 189 """Does a write() and then a write('\n')"""
190 190 self.write(*arg,**kw)
191 191 self.write('\n')
192 192
193 193
194 194 class Inspector:
195 195 def __init__(self,color_table,code_color_table,scheme,
196 196 str_detail_level=0):
197 197 self.color_table = color_table
198 198 self.parser = PyColorize.Parser(code_color_table,out='str')
199 199 self.format = self.parser.format
200 200 self.str_detail_level = str_detail_level
201 201 self.set_active_scheme(scheme)
202 202
203 203 def __getdef(self,obj,oname=''):
204 204 """Return the definition header for any callable object.
205 205
206 206 If any exception is generated, None is returned instead and the
207 207 exception is suppressed."""
208 208
209 209 try:
210 210 return oname + inspect.formatargspec(*getargspec(obj))
211 211 except:
212 212 return None
213 213
214 214 def __head(self,h):
215 215 """Return a header string with proper colors."""
216 216 return '%s%s%s' % (self.color_table.active_colors.header,h,
217 217 self.color_table.active_colors.normal)
218 218
219 219 def set_active_scheme(self,scheme):
220 220 self.color_table.set_active_scheme(scheme)
221 221 self.parser.color_table.set_active_scheme(scheme)
222 222
223 223 def noinfo(self,msg,oname):
224 224 """Generic message when no information is found."""
225 225 print 'No %s found' % msg,
226 226 if oname:
227 227 print 'for %s' % oname
228 228 else:
229 229 print
230 230
231 231 def pdef(self,obj,oname=''):
232 232 """Print the definition header for any callable object.
233 233
234 234 If the object is a class, print the constructor information."""
235 235
236 236 if not callable(obj):
237 237 print 'Object is not callable.'
238 238 return
239 239
240 240 header = ''
241 241
242 242 if inspect.isclass(obj):
243 243 header = self.__head('Class constructor information:\n')
244 244 obj = obj.__init__
245 245 elif type(obj) is types.InstanceType:
246 246 obj = obj.__call__
247 247
248 248 output = self.__getdef(obj,oname)
249 249 if output is None:
250 250 self.noinfo('definition header',oname)
251 251 else:
252 252 print >>IPython.utils.io.Term.cout, header,self.format(output),
253 253
254 254 def pdoc(self,obj,oname='',formatter = None):
255 255 """Print the docstring for any object.
256 256
257 257 Optional:
258 258 -formatter: a function to run the docstring through for specially
259 259 formatted docstrings."""
260 260
261 261 head = self.__head # so that itpl can find it even if private
262 262 ds = getdoc(obj)
263 263 if formatter:
264 264 ds = formatter(ds)
265 265 if inspect.isclass(obj):
266 266 init_ds = getdoc(obj.__init__)
267 267 output = itpl('$head("Class Docstring:")\n'
268 268 '$indent(ds)\n'
269 269 '$head("Constructor Docstring"):\n'
270 270 '$indent(init_ds)')
271 271 elif (type(obj) is types.InstanceType or isinstance(obj,object)) \
272 272 and hasattr(obj,'__call__'):
273 273 call_ds = getdoc(obj.__call__)
274 274 if call_ds:
275 275 output = itpl('$head("Class Docstring:")\n$indent(ds)\n'
276 276 '$head("Calling Docstring:")\n$indent(call_ds)')
277 277 else:
278 278 output = ds
279 279 else:
280 280 output = ds
281 281 if output is None:
282 282 self.noinfo('documentation',oname)
283 283 return
284 page(output)
284 page.page(output)
285 285
286 286 def psource(self,obj,oname=''):
287 287 """Print the source code for an object."""
288 288
289 289 # Flush the source cache because inspect can return out-of-date source
290 290 linecache.checkcache()
291 291 try:
292 292 src = getsource(obj)
293 293 except:
294 294 self.noinfo('source',oname)
295 295 else:
296 page(self.format(src))
296 page.page(self.format(src))
297 297
298 298 def pfile(self,obj,oname=''):
299 299 """Show the whole file where an object was defined."""
300 300
301 301 try:
302 302 try:
303 303 lineno = inspect.getsourcelines(obj)[1]
304 304 except TypeError:
305 305 # For instances, try the class object like getsource() does
306 306 if hasattr(obj,'__class__'):
307 307 lineno = inspect.getsourcelines(obj.__class__)[1]
308 308 # Adjust the inspected object so getabsfile() below works
309 309 obj = obj.__class__
310 310 except:
311 311 self.noinfo('file',oname)
312 312 return
313 313
314 314 # We only reach this point if object was successfully queried
315 315
316 316 # run contents of file through pager starting at line
317 317 # where the object is defined
318 318 ofile = inspect.getabsfile(obj)
319 319
320 320 if (ofile.endswith('.so') or ofile.endswith('.dll')):
321 321 print 'File %r is binary, not printing.' % ofile
322 322 elif not os.path.isfile(ofile):
323 323 print 'File %r does not exist, not printing.' % ofile
324 324 else:
325 325 # Print only text files, not extension binaries. Note that
326 326 # getsourcelines returns lineno with 1-offset and page() uses
327 327 # 0-offset, so we must adjust.
328 page(self.format(open(ofile).read()),lineno-1)
328 page.page(self.format(open(ofile).read()),lineno-1)
329 329
330 330 def pinfo(self,obj,oname='',formatter=None,info=None,detail_level=0):
331 331 """Show detailed information about an object.
332 332
333 333 Optional arguments:
334 334
335 335 - oname: name of the variable pointing to the object.
336 336
337 337 - formatter: special formatter for docstrings (see pdoc)
338 338
339 339 - info: a structure with some information fields which may have been
340 340 precomputed already.
341 341
342 342 - detail_level: if set to 1, more information is given.
343 343 """
344 344
345 345 obj_type = type(obj)
346 346
347 347 header = self.__head
348 348 if info is None:
349 349 ismagic = 0
350 350 isalias = 0
351 351 ospace = ''
352 352 else:
353 353 ismagic = info.ismagic
354 354 isalias = info.isalias
355 355 ospace = info.namespace
356 356 # Get docstring, special-casing aliases:
357 357 if isalias:
358 358 if not callable(obj):
359 359 try:
360 360 ds = "Alias to the system command:\n %s" % obj[1]
361 361 except:
362 362 ds = "Alias: " + str(obj)
363 363 else:
364 364 ds = "Alias to " + str(obj)
365 365 if obj.__doc__:
366 366 ds += "\nDocstring:\n" + obj.__doc__
367 367 else:
368 368 ds = getdoc(obj)
369 369 if ds is None:
370 370 ds = '<no docstring>'
371 371 if formatter is not None:
372 372 ds = formatter(ds)
373 373
374 374 # store output in a list which gets joined with \n at the end.
375 375 out = myStringIO()
376 376
377 377 string_max = 200 # max size of strings to show (snipped if longer)
378 378 shalf = int((string_max -5)/2)
379 379
380 380 if ismagic:
381 381 obj_type_name = 'Magic function'
382 382 elif isalias:
383 383 obj_type_name = 'System alias'
384 384 else:
385 385 obj_type_name = obj_type.__name__
386 386 out.writeln(header('Type:\t\t')+obj_type_name)
387 387
388 388 try:
389 389 bclass = obj.__class__
390 390 out.writeln(header('Base Class:\t')+str(bclass))
391 391 except: pass
392 392
393 393 # String form, but snip if too long in ? form (full in ??)
394 394 if detail_level >= self.str_detail_level:
395 395 try:
396 396 ostr = str(obj)
397 397 str_head = 'String Form:'
398 398 if not detail_level and len(ostr)>string_max:
399 399 ostr = ostr[:shalf] + ' <...> ' + ostr[-shalf:]
400 400 ostr = ("\n" + " " * len(str_head.expandtabs())).\
401 401 join(map(string.strip,ostr.split("\n")))
402 402 if ostr.find('\n') > -1:
403 403 # Print multi-line strings starting at the next line.
404 404 str_sep = '\n'
405 405 else:
406 406 str_sep = '\t'
407 407 out.writeln("%s%s%s" % (header(str_head),str_sep,ostr))
408 408 except:
409 409 pass
410 410
411 411 if ospace:
412 412 out.writeln(header('Namespace:\t')+ospace)
413 413
414 414 # Length (for strings and lists)
415 415 try:
416 416 length = str(len(obj))
417 417 out.writeln(header('Length:\t\t')+length)
418 418 except: pass
419 419
420 420 # Filename where object was defined
421 421 binary_file = False
422 422 try:
423 423 try:
424 424 fname = inspect.getabsfile(obj)
425 425 except TypeError:
426 426 # For an instance, the file that matters is where its class was
427 427 # declared.
428 428 if hasattr(obj,'__class__'):
429 429 fname = inspect.getabsfile(obj.__class__)
430 430 if fname.endswith('<string>'):
431 431 fname = 'Dynamically generated function. No source code available.'
432 432 if (fname.endswith('.so') or fname.endswith('.dll')):
433 433 binary_file = True
434 434 out.writeln(header('File:\t\t')+fname)
435 435 except:
436 436 # if anything goes wrong, we don't want to show source, so it's as
437 437 # if the file was binary
438 438 binary_file = True
439 439
440 440 # reconstruct the function definition and print it:
441 441 defln = self.__getdef(obj,oname)
442 442 if defln:
443 443 out.write(header('Definition:\t')+self.format(defln))
444 444
445 445 # Docstrings only in detail 0 mode, since source contains them (we
446 446 # avoid repetitions). If source fails, we add them back, see below.
447 447 if ds and detail_level == 0:
448 448 out.writeln(header('Docstring:\n') + indent(ds))
449 449
450 450 # Original source code for any callable
451 451 if detail_level:
452 452 # Flush the source cache because inspect can return out-of-date
453 453 # source
454 454 linecache.checkcache()
455 455 source_success = False
456 456 try:
457 457 try:
458 458 src = getsource(obj,binary_file)
459 459 except TypeError:
460 460 if hasattr(obj,'__class__'):
461 461 src = getsource(obj.__class__,binary_file)
462 462 if src is not None:
463 463 source = self.format(src)
464 464 out.write(header('Source:\n')+source.rstrip())
465 465 source_success = True
466 466 except Exception, msg:
467 467 pass
468 468
469 469 if ds and not source_success:
470 470 out.writeln(header('Docstring [source file open failed]:\n')
471 471 + indent(ds))
472 472
473 473 # Constructor docstring for classes
474 474 if inspect.isclass(obj):
475 475 # reconstruct the function definition and print it:
476 476 try:
477 477 obj_init = obj.__init__
478 478 except AttributeError:
479 479 init_def = init_ds = None
480 480 else:
481 481 init_def = self.__getdef(obj_init,oname)
482 482 init_ds = getdoc(obj_init)
483 483 # Skip Python's auto-generated docstrings
484 484 if init_ds and \
485 485 init_ds.startswith('x.__init__(...) initializes'):
486 486 init_ds = None
487 487
488 488 if init_def or init_ds:
489 489 out.writeln(header('\nConstructor information:'))
490 490 if init_def:
491 491 out.write(header('Definition:\t')+ self.format(init_def))
492 492 if init_ds:
493 493 out.writeln(header('Docstring:\n') + indent(init_ds))
494 494 # and class docstring for instances:
495 495 elif obj_type is types.InstanceType or \
496 496 isinstance(obj,object):
497 497
498 498 # First, check whether the instance docstring is identical to the
499 499 # class one, and print it separately if they don't coincide. In
500 500 # most cases they will, but it's nice to print all the info for
501 501 # objects which use instance-customized docstrings.
502 502 if ds:
503 503 try:
504 504 cls = getattr(obj,'__class__')
505 505 except:
506 506 class_ds = None
507 507 else:
508 508 class_ds = getdoc(cls)
509 509 # Skip Python's auto-generated docstrings
510 510 if class_ds and \
511 511 (class_ds.startswith('function(code, globals[,') or \
512 512 class_ds.startswith('instancemethod(function, instance,') or \
513 513 class_ds.startswith('module(name[,') ):
514 514 class_ds = None
515 515 if class_ds and ds != class_ds:
516 516 out.writeln(header('Class Docstring:\n') +
517 517 indent(class_ds))
518 518
519 519 # Next, try to show constructor docstrings
520 520 try:
521 521 init_ds = getdoc(obj.__init__)
522 522 # Skip Python's auto-generated docstrings
523 523 if init_ds and \
524 524 init_ds.startswith('x.__init__(...) initializes'):
525 525 init_ds = None
526 526 except AttributeError:
527 527 init_ds = None
528 528 if init_ds:
529 529 out.writeln(header('Constructor Docstring:\n') +
530 530 indent(init_ds))
531 531
532 532 # Call form docstring for callable instances
533 533 if hasattr(obj,'__call__'):
534 534 #out.writeln(header('Callable:\t')+'Yes')
535 535 call_def = self.__getdef(obj.__call__,oname)
536 536 #if call_def is None:
537 537 # out.writeln(header('Call def:\t')+
538 538 # 'Calling definition not available.')
539 539 if call_def is not None:
540 540 out.writeln(header('Call def:\t')+self.format(call_def))
541 541 call_ds = getdoc(obj.__call__)
542 542 # Skip Python's auto-generated docstrings
543 543 if call_ds and call_ds.startswith('x.__call__(...) <==> x(...)'):
544 544 call_ds = None
545 545 if call_ds:
546 546 out.writeln(header('Call docstring:\n') + indent(call_ds))
547 547
548 548 # Finally send to printer/pager
549 549 output = out.getvalue()
550 550 if output:
551 page(output)
551 page.page(output)
552 552 # end pinfo
553 553
554 554 def psearch(self,pattern,ns_table,ns_search=[],
555 555 ignore_case=False,show_all=False):
556 556 """Search namespaces with wildcards for objects.
557 557
558 558 Arguments:
559 559
560 560 - pattern: string containing shell-like wildcards to use in namespace
561 561 searches and optionally a type specification to narrow the search to
562 562 objects of that type.
563 563
564 564 - ns_table: dict of name->namespaces for search.
565 565
566 566 Optional arguments:
567 567
568 568 - ns_search: list of namespace names to include in search.
569 569
570 570 - ignore_case(False): make the search case-insensitive.
571 571
572 572 - show_all(False): show all names, including those starting with
573 573 underscores.
574 574 """
575 575 #print 'ps pattern:<%r>' % pattern # dbg
576 576
577 577 # defaults
578 578 type_pattern = 'all'
579 579 filter = ''
580 580
581 581 cmds = pattern.split()
582 582 len_cmds = len(cmds)
583 583 if len_cmds == 1:
584 584 # Only filter pattern given
585 585 filter = cmds[0]
586 586 elif len_cmds == 2:
587 587 # Both filter and type specified
588 588 filter,type_pattern = cmds
589 589 else:
590 590 raise ValueError('invalid argument string for psearch: <%s>' %
591 591 pattern)
592 592
593 593 # filter search namespaces
594 594 for name in ns_search:
595 595 if name not in ns_table:
596 596 raise ValueError('invalid namespace <%s>. Valid names: %s' %
597 597 (name,ns_table.keys()))
598 598
599 599 #print 'type_pattern:',type_pattern # dbg
600 600 search_result = []
601 601 for ns_name in ns_search:
602 602 ns = ns_table[ns_name]
603 603 tmp_res = list(list_namespace(ns,type_pattern,filter,
604 604 ignore_case=ignore_case,
605 605 show_all=show_all))
606 606 search_result.extend(tmp_res)
607 607 search_result.sort()
608 608
609 page('\n'.join(search_result))
609 page.page('\n'.join(search_result))
@@ -1,1022 +1,1022 b''
1 1 #!/usr/bin/env python
2 2 # encoding: utf-8
3 3 """
4 4 Prefiltering components.
5 5
6 6 Prefilters transform user input before it is exec'd by Python. These
7 7 transforms are used to implement additional syntax such as !ls and %magic.
8 8
9 9 Authors:
10 10
11 11 * Brian Granger
12 12 * Fernando Perez
13 13 * Dan Milstein
14 14 * Ville Vainio
15 15 """
16 16
17 17 #-----------------------------------------------------------------------------
18 18 # Copyright (C) 2008-2009 The IPython Development Team
19 19 #
20 20 # Distributed under the terms of the BSD License. The full license is in
21 21 # the file COPYING, distributed as part of this software.
22 22 #-----------------------------------------------------------------------------
23 23
24 24 #-----------------------------------------------------------------------------
25 25 # Imports
26 26 #-----------------------------------------------------------------------------
27 27
28 28 import __builtin__
29 29 import codeop
30 30 import re
31 31
32 32 from IPython.core.alias import AliasManager
33 33 from IPython.core.autocall import IPyAutocall
34 34 from IPython.config.configurable import Configurable
35 35 from IPython.core.splitinput import split_user_input
36 from IPython.core.page import page
36 from IPython.core import page
37 37
38 38 from IPython.utils.traitlets import List, Int, Any, Str, CBool, Bool, Instance
39 39 import IPython.utils.io
40 40 from IPython.utils.text import make_quoted_expr
41 41 from IPython.utils.autoattr import auto_attr
42 42
43 43 #-----------------------------------------------------------------------------
44 44 # Global utilities, errors and constants
45 45 #-----------------------------------------------------------------------------
46 46
47 47 # Warning, these cannot be changed unless various regular expressions
48 48 # are updated in a number of places. Not great, but at least we told you.
49 49 ESC_SHELL = '!'
50 50 ESC_SH_CAP = '!!'
51 51 ESC_HELP = '?'
52 52 ESC_MAGIC = '%'
53 53 ESC_QUOTE = ','
54 54 ESC_QUOTE2 = ';'
55 55 ESC_PAREN = '/'
56 56
57 57
58 58 class PrefilterError(Exception):
59 59 pass
60 60
61 61
62 62 # RegExp to identify potential function names
63 63 re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
64 64
65 65 # RegExp to exclude strings with this start from autocalling. In
66 66 # particular, all binary operators should be excluded, so that if foo is
67 67 # callable, foo OP bar doesn't become foo(OP bar), which is invalid. The
68 68 # characters '!=()' don't need to be checked for, as the checkPythonChars
69 69 # routine explicitely does so, to catch direct calls and rebindings of
70 70 # existing names.
71 71
72 72 # Warning: the '-' HAS TO BE AT THE END of the first group, otherwise
73 73 # it affects the rest of the group in square brackets.
74 74 re_exclude_auto = re.compile(r'^[,&^\|\*/\+-]'
75 75 r'|^is |^not |^in |^and |^or ')
76 76
77 77 # try to catch also methods for stuff in lists/tuples/dicts: off
78 78 # (experimental). For this to work, the line_split regexp would need
79 79 # to be modified so it wouldn't break things at '['. That line is
80 80 # nasty enough that I shouldn't change it until I can test it _well_.
81 81 #self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
82 82
83 83
84 84 # Handler Check Utilities
85 85 def is_shadowed(identifier, ip):
86 86 """Is the given identifier defined in one of the namespaces which shadow
87 87 the alias and magic namespaces? Note that an identifier is different
88 88 than ifun, because it can not contain a '.' character."""
89 89 # This is much safer than calling ofind, which can change state
90 90 return (identifier in ip.user_ns \
91 91 or identifier in ip.internal_ns \
92 92 or identifier in ip.ns_table['builtin'])
93 93
94 94
95 95 #-----------------------------------------------------------------------------
96 96 # The LineInfo class used throughout
97 97 #-----------------------------------------------------------------------------
98 98
99 99
100 100 class LineInfo(object):
101 101 """A single line of input and associated info.
102 102
103 103 Includes the following as properties:
104 104
105 105 line
106 106 The original, raw line
107 107
108 108 continue_prompt
109 109 Is this line a continuation in a sequence of multiline input?
110 110
111 111 pre
112 112 The initial esc character or whitespace.
113 113
114 114 pre_char
115 115 The escape character(s) in pre or the empty string if there isn't one.
116 116 Note that '!!' is a possible value for pre_char. Otherwise it will
117 117 always be a single character.
118 118
119 119 pre_whitespace
120 120 The leading whitespace from pre if it exists. If there is a pre_char,
121 121 this is just ''.
122 122
123 123 ifun
124 124 The 'function part', which is basically the maximal initial sequence
125 125 of valid python identifiers and the '.' character. This is what is
126 126 checked for alias and magic transformations, used for auto-calling,
127 127 etc.
128 128
129 129 the_rest
130 130 Everything else on the line.
131 131 """
132 132 def __init__(self, line, continue_prompt):
133 133 self.line = line
134 134 self.continue_prompt = continue_prompt
135 135 self.pre, self.ifun, self.the_rest = split_user_input(line)
136 136
137 137 self.pre_char = self.pre.strip()
138 138 if self.pre_char:
139 139 self.pre_whitespace = '' # No whitespace allowd before esc chars
140 140 else:
141 141 self.pre_whitespace = self.pre
142 142
143 143 self._oinfo = None
144 144
145 145 def ofind(self, ip):
146 146 """Do a full, attribute-walking lookup of the ifun in the various
147 147 namespaces for the given IPython InteractiveShell instance.
148 148
149 149 Return a dict with keys: found,obj,ospace,ismagic
150 150
151 151 Note: can cause state changes because of calling getattr, but should
152 152 only be run if autocall is on and if the line hasn't matched any
153 153 other, less dangerous handlers.
154 154
155 155 Does cache the results of the call, so can be called multiple times
156 156 without worrying about *further* damaging state.
157 157 """
158 158 if not self._oinfo:
159 159 # ip.shell._ofind is actually on the Magic class!
160 160 self._oinfo = ip.shell._ofind(self.ifun)
161 161 return self._oinfo
162 162
163 163 def __str__(self):
164 164 return "Lineinfo [%s|%s|%s]" %(self.pre, self.ifun, self.the_rest)
165 165
166 166
167 167 #-----------------------------------------------------------------------------
168 168 # Main Prefilter manager
169 169 #-----------------------------------------------------------------------------
170 170
171 171
172 172 class PrefilterManager(Configurable):
173 173 """Main prefilter component.
174 174
175 175 The IPython prefilter is run on all user input before it is run. The
176 176 prefilter consumes lines of input and produces transformed lines of
177 177 input.
178 178
179 179 The iplementation consists of two phases:
180 180
181 181 1. Transformers
182 182 2. Checkers and handlers
183 183
184 184 Over time, we plan on deprecating the checkers and handlers and doing
185 185 everything in the transformers.
186 186
187 187 The transformers are instances of :class:`PrefilterTransformer` and have
188 188 a single method :meth:`transform` that takes a line and returns a
189 189 transformed line. The transformation can be accomplished using any
190 190 tool, but our current ones use regular expressions for speed. We also
191 191 ship :mod:`pyparsing` in :mod:`IPython.external` for use in transformers.
192 192
193 193 After all the transformers have been run, the line is fed to the checkers,
194 194 which are instances of :class:`PrefilterChecker`. The line is passed to
195 195 the :meth:`check` method, which either returns `None` or a
196 196 :class:`PrefilterHandler` instance. If `None` is returned, the other
197 197 checkers are tried. If an :class:`PrefilterHandler` instance is returned,
198 198 the line is passed to the :meth:`handle` method of the returned
199 199 handler and no further checkers are tried.
200 200
201 201 Both transformers and checkers have a `priority` attribute, that determines
202 202 the order in which they are called. Smaller priorities are tried first.
203 203
204 204 Both transformers and checkers also have `enabled` attribute, which is
205 205 a boolean that determines if the instance is used.
206 206
207 207 Users or developers can change the priority or enabled attribute of
208 208 transformers or checkers, but they must call the :meth:`sort_checkers`
209 209 or :meth:`sort_transformers` method after changing the priority.
210 210 """
211 211
212 212 multi_line_specials = CBool(True, config=True)
213 213 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
214 214
215 215 def __init__(self, shell=None, config=None):
216 216 super(PrefilterManager, self).__init__(shell=shell, config=config)
217 217 self.shell = shell
218 218 self.init_transformers()
219 219 self.init_handlers()
220 220 self.init_checkers()
221 221
222 222 #-------------------------------------------------------------------------
223 223 # API for managing transformers
224 224 #-------------------------------------------------------------------------
225 225
226 226 def init_transformers(self):
227 227 """Create the default transformers."""
228 228 self._transformers = []
229 229 for transformer_cls in _default_transformers:
230 230 transformer_cls(
231 231 shell=self.shell, prefilter_manager=self, config=self.config
232 232 )
233 233
234 234 def sort_transformers(self):
235 235 """Sort the transformers by priority.
236 236
237 237 This must be called after the priority of a transformer is changed.
238 238 The :meth:`register_transformer` method calls this automatically.
239 239 """
240 240 self._transformers.sort(cmp=lambda x,y: x.priority-y.priority)
241 241
242 242 @property
243 243 def transformers(self):
244 244 """Return a list of checkers, sorted by priority."""
245 245 return self._transformers
246 246
247 247 def register_transformer(self, transformer):
248 248 """Register a transformer instance."""
249 249 if transformer not in self._transformers:
250 250 self._transformers.append(transformer)
251 251 self.sort_transformers()
252 252
253 253 def unregister_transformer(self, transformer):
254 254 """Unregister a transformer instance."""
255 255 if transformer in self._transformers:
256 256 self._transformers.remove(transformer)
257 257
258 258 #-------------------------------------------------------------------------
259 259 # API for managing checkers
260 260 #-------------------------------------------------------------------------
261 261
262 262 def init_checkers(self):
263 263 """Create the default checkers."""
264 264 self._checkers = []
265 265 for checker in _default_checkers:
266 266 checker(
267 267 shell=self.shell, prefilter_manager=self, config=self.config
268 268 )
269 269
270 270 def sort_checkers(self):
271 271 """Sort the checkers by priority.
272 272
273 273 This must be called after the priority of a checker is changed.
274 274 The :meth:`register_checker` method calls this automatically.
275 275 """
276 276 self._checkers.sort(cmp=lambda x,y: x.priority-y.priority)
277 277
278 278 @property
279 279 def checkers(self):
280 280 """Return a list of checkers, sorted by priority."""
281 281 return self._checkers
282 282
283 283 def register_checker(self, checker):
284 284 """Register a checker instance."""
285 285 if checker not in self._checkers:
286 286 self._checkers.append(checker)
287 287 self.sort_checkers()
288 288
289 289 def unregister_checker(self, checker):
290 290 """Unregister a checker instance."""
291 291 if checker in self._checkers:
292 292 self._checkers.remove(checker)
293 293
294 294 #-------------------------------------------------------------------------
295 295 # API for managing checkers
296 296 #-------------------------------------------------------------------------
297 297
298 298 def init_handlers(self):
299 299 """Create the default handlers."""
300 300 self._handlers = {}
301 301 self._esc_handlers = {}
302 302 for handler in _default_handlers:
303 303 handler(
304 304 shell=self.shell, prefilter_manager=self, config=self.config
305 305 )
306 306
307 307 @property
308 308 def handlers(self):
309 309 """Return a dict of all the handlers."""
310 310 return self._handlers
311 311
312 312 def register_handler(self, name, handler, esc_strings):
313 313 """Register a handler instance by name with esc_strings."""
314 314 self._handlers[name] = handler
315 315 for esc_str in esc_strings:
316 316 self._esc_handlers[esc_str] = handler
317 317
318 318 def unregister_handler(self, name, handler, esc_strings):
319 319 """Unregister a handler instance by name with esc_strings."""
320 320 try:
321 321 del self._handlers[name]
322 322 except KeyError:
323 323 pass
324 324 for esc_str in esc_strings:
325 325 h = self._esc_handlers.get(esc_str)
326 326 if h is handler:
327 327 del self._esc_handlers[esc_str]
328 328
329 329 def get_handler_by_name(self, name):
330 330 """Get a handler by its name."""
331 331 return self._handlers.get(name)
332 332
333 333 def get_handler_by_esc(self, esc_str):
334 334 """Get a handler by its escape string."""
335 335 return self._esc_handlers.get(esc_str)
336 336
337 337 #-------------------------------------------------------------------------
338 338 # Main prefiltering API
339 339 #-------------------------------------------------------------------------
340 340
341 341 def prefilter_line_info(self, line_info):
342 342 """Prefilter a line that has been converted to a LineInfo object.
343 343
344 344 This implements the checker/handler part of the prefilter pipe.
345 345 """
346 346 # print "prefilter_line_info: ", line_info
347 347 handler = self.find_handler(line_info)
348 348 return handler.handle(line_info)
349 349
350 350 def find_handler(self, line_info):
351 351 """Find a handler for the line_info by trying checkers."""
352 352 for checker in self.checkers:
353 353 if checker.enabled:
354 354 handler = checker.check(line_info)
355 355 if handler:
356 356 return handler
357 357 return self.get_handler_by_name('normal')
358 358
359 359 def transform_line(self, line, continue_prompt):
360 360 """Calls the enabled transformers in order of increasing priority."""
361 361 for transformer in self.transformers:
362 362 if transformer.enabled:
363 363 line = transformer.transform(line, continue_prompt)
364 364 return line
365 365
366 366 def prefilter_line(self, line, continue_prompt=False):
367 367 """Prefilter a single input line as text.
368 368
369 369 This method prefilters a single line of text by calling the
370 370 transformers and then the checkers/handlers.
371 371 """
372 372
373 373 # print "prefilter_line: ", line, continue_prompt
374 374 # All handlers *must* return a value, even if it's blank ('').
375 375
376 376 # Lines are NOT logged here. Handlers should process the line as
377 377 # needed, update the cache AND log it (so that the input cache array
378 378 # stays synced).
379 379
380 380 # save the line away in case we crash, so the post-mortem handler can
381 381 # record it
382 382 self.shell._last_input_line = line
383 383
384 384 if not line:
385 385 # Return immediately on purely empty lines, so that if the user
386 386 # previously typed some whitespace that started a continuation
387 387 # prompt, he can break out of that loop with just an empty line.
388 388 # This is how the default python prompt works.
389 389
390 390 # Only return if the accumulated input buffer was just whitespace!
391 391 if ''.join(self.shell.buffer).isspace():
392 392 self.shell.buffer[:] = []
393 393 return ''
394 394
395 395 # At this point, we invoke our transformers.
396 396 if not continue_prompt or (continue_prompt and self.multi_line_specials):
397 397 line = self.transform_line(line, continue_prompt)
398 398
399 399 # Now we compute line_info for the checkers and handlers
400 400 line_info = LineInfo(line, continue_prompt)
401 401
402 402 # the input history needs to track even empty lines
403 403 stripped = line.strip()
404 404
405 405 normal_handler = self.get_handler_by_name('normal')
406 406 if not stripped:
407 407 if not continue_prompt:
408 408 self.shell.displayhook.prompt_count -= 1
409 409
410 410 return normal_handler.handle(line_info)
411 411
412 412 # special handlers are only allowed for single line statements
413 413 if continue_prompt and not self.multi_line_specials:
414 414 return normal_handler.handle(line_info)
415 415
416 416 prefiltered = self.prefilter_line_info(line_info)
417 417 # print "prefiltered line: %r" % prefiltered
418 418 return prefiltered
419 419
420 420 def prefilter_lines(self, lines, continue_prompt=False):
421 421 """Prefilter multiple input lines of text.
422 422
423 423 This is the main entry point for prefiltering multiple lines of
424 424 input. This simply calls :meth:`prefilter_line` for each line of
425 425 input.
426 426
427 427 This covers cases where there are multiple lines in the user entry,
428 428 which is the case when the user goes back to a multiline history
429 429 entry and presses enter.
430 430 """
431 431 llines = lines.rstrip('\n').split('\n')
432 432 # We can get multiple lines in one shot, where multiline input 'blends'
433 433 # into one line, in cases like recalling from the readline history
434 434 # buffer. We need to make sure that in such cases, we correctly
435 435 # communicate downstream which line is first and which are continuation
436 436 # ones.
437 437 if len(llines) > 1:
438 438 out = '\n'.join([self.prefilter_line(line, lnum>0)
439 439 for lnum, line in enumerate(llines) ])
440 440 else:
441 441 out = self.prefilter_line(llines[0], continue_prompt)
442 442
443 443 return out
444 444
445 445 #-----------------------------------------------------------------------------
446 446 # Prefilter transformers
447 447 #-----------------------------------------------------------------------------
448 448
449 449
450 450 class PrefilterTransformer(Configurable):
451 451 """Transform a line of user input."""
452 452
453 453 priority = Int(100, config=True)
454 454 # Transformers don't currently use shell or prefilter_manager, but as we
455 455 # move away from checkers and handlers, they will need them.
456 456 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
457 457 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
458 458 enabled = Bool(True, config=True)
459 459
460 460 def __init__(self, shell=None, prefilter_manager=None, config=None):
461 461 super(PrefilterTransformer, self).__init__(
462 462 shell=shell, prefilter_manager=prefilter_manager, config=config
463 463 )
464 464 self.prefilter_manager.register_transformer(self)
465 465
466 466 def transform(self, line, continue_prompt):
467 467 """Transform a line, returning the new one."""
468 468 return None
469 469
470 470 def __repr__(self):
471 471 return "<%s(priority=%r, enabled=%r)>" % (
472 472 self.__class__.__name__, self.priority, self.enabled)
473 473
474 474
475 475 _assign_system_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
476 476 r'\s*=\s*!(?P<cmd>.*)')
477 477
478 478
479 479 class AssignSystemTransformer(PrefilterTransformer):
480 480 """Handle the `files = !ls` syntax."""
481 481
482 482 priority = Int(100, config=True)
483 483
484 484 def transform(self, line, continue_prompt):
485 485 m = _assign_system_re.match(line)
486 486 if m is not None:
487 487 cmd = m.group('cmd')
488 488 lhs = m.group('lhs')
489 489 expr = make_quoted_expr("sc -l =%s" % cmd)
490 490 new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
491 491 return new_line
492 492 return line
493 493
494 494
495 495 _assign_magic_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
496 496 r'\s*=\s*%(?P<cmd>.*)')
497 497
498 498 class AssignMagicTransformer(PrefilterTransformer):
499 499 """Handle the `a = %who` syntax."""
500 500
501 501 priority = Int(200, config=True)
502 502
503 503 def transform(self, line, continue_prompt):
504 504 m = _assign_magic_re.match(line)
505 505 if m is not None:
506 506 cmd = m.group('cmd')
507 507 lhs = m.group('lhs')
508 508 expr = make_quoted_expr(cmd)
509 509 new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
510 510 return new_line
511 511 return line
512 512
513 513
514 514 _classic_prompt_re = re.compile(r'(^[ \t]*>>> |^[ \t]*\.\.\. )')
515 515
516 516 class PyPromptTransformer(PrefilterTransformer):
517 517 """Handle inputs that start with '>>> ' syntax."""
518 518
519 519 priority = Int(50, config=True)
520 520
521 521 def transform(self, line, continue_prompt):
522 522
523 523 if not line or line.isspace() or line.strip() == '...':
524 524 # This allows us to recognize multiple input prompts separated by
525 525 # blank lines and pasted in a single chunk, very common when
526 526 # pasting doctests or long tutorial passages.
527 527 return ''
528 528 m = _classic_prompt_re.match(line)
529 529 if m:
530 530 return line[len(m.group(0)):]
531 531 else:
532 532 return line
533 533
534 534
535 535 _ipy_prompt_re = re.compile(r'(^[ \t]*In \[\d+\]: |^[ \t]*\ \ \ \.\.\.+: )')
536 536
537 537 class IPyPromptTransformer(PrefilterTransformer):
538 538 """Handle inputs that start classic IPython prompt syntax."""
539 539
540 540 priority = Int(50, config=True)
541 541
542 542 def transform(self, line, continue_prompt):
543 543
544 544 if not line or line.isspace() or line.strip() == '...':
545 545 # This allows us to recognize multiple input prompts separated by
546 546 # blank lines and pasted in a single chunk, very common when
547 547 # pasting doctests or long tutorial passages.
548 548 return ''
549 549 m = _ipy_prompt_re.match(line)
550 550 if m:
551 551 return line[len(m.group(0)):]
552 552 else:
553 553 return line
554 554
555 555 #-----------------------------------------------------------------------------
556 556 # Prefilter checkers
557 557 #-----------------------------------------------------------------------------
558 558
559 559
560 560 class PrefilterChecker(Configurable):
561 561 """Inspect an input line and return a handler for that line."""
562 562
563 563 priority = Int(100, config=True)
564 564 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
565 565 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
566 566 enabled = Bool(True, config=True)
567 567
568 568 def __init__(self, shell=None, prefilter_manager=None, config=None):
569 569 super(PrefilterChecker, self).__init__(
570 570 shell=shell, prefilter_manager=prefilter_manager, config=config
571 571 )
572 572 self.prefilter_manager.register_checker(self)
573 573
574 574 def check(self, line_info):
575 575 """Inspect line_info and return a handler instance or None."""
576 576 return None
577 577
578 578 def __repr__(self):
579 579 return "<%s(priority=%r, enabled=%r)>" % (
580 580 self.__class__.__name__, self.priority, self.enabled)
581 581
582 582
583 583 class EmacsChecker(PrefilterChecker):
584 584
585 585 priority = Int(100, config=True)
586 586 enabled = Bool(False, config=True)
587 587
588 588 def check(self, line_info):
589 589 "Emacs ipython-mode tags certain input lines."
590 590 if line_info.line.endswith('# PYTHON-MODE'):
591 591 return self.prefilter_manager.get_handler_by_name('emacs')
592 592 else:
593 593 return None
594 594
595 595
596 596 class ShellEscapeChecker(PrefilterChecker):
597 597
598 598 priority = Int(200, config=True)
599 599
600 600 def check(self, line_info):
601 601 if line_info.line.lstrip().startswith(ESC_SHELL):
602 602 return self.prefilter_manager.get_handler_by_name('shell')
603 603
604 604
605 605 class IPyAutocallChecker(PrefilterChecker):
606 606
607 607 priority = Int(300, config=True)
608 608
609 609 def check(self, line_info):
610 610 "Instances of IPyAutocall in user_ns get autocalled immediately"
611 611 obj = self.shell.user_ns.get(line_info.ifun, None)
612 612 if isinstance(obj, IPyAutocall):
613 613 obj.set_ip(self.shell)
614 614 return self.prefilter_manager.get_handler_by_name('auto')
615 615 else:
616 616 return None
617 617
618 618
619 619 class MultiLineMagicChecker(PrefilterChecker):
620 620
621 621 priority = Int(400, config=True)
622 622
623 623 def check(self, line_info):
624 624 "Allow ! and !! in multi-line statements if multi_line_specials is on"
625 625 # Note that this one of the only places we check the first character of
626 626 # ifun and *not* the pre_char. Also note that the below test matches
627 627 # both ! and !!.
628 628 if line_info.continue_prompt \
629 629 and self.prefilter_manager.multi_line_specials:
630 630 if line_info.ifun.startswith(ESC_MAGIC):
631 631 return self.prefilter_manager.get_handler_by_name('magic')
632 632 else:
633 633 return None
634 634
635 635
636 636 class EscCharsChecker(PrefilterChecker):
637 637
638 638 priority = Int(500, config=True)
639 639
640 640 def check(self, line_info):
641 641 """Check for escape character and return either a handler to handle it,
642 642 or None if there is no escape char."""
643 643 if line_info.line[-1] == ESC_HELP \
644 644 and line_info.pre_char != ESC_SHELL \
645 645 and line_info.pre_char != ESC_SH_CAP:
646 646 # the ? can be at the end, but *not* for either kind of shell escape,
647 647 # because a ? can be a vaild final char in a shell cmd
648 648 return self.prefilter_manager.get_handler_by_name('help')
649 649 else:
650 650 # This returns None like it should if no handler exists
651 651 return self.prefilter_manager.get_handler_by_esc(line_info.pre_char)
652 652
653 653
654 654 class AssignmentChecker(PrefilterChecker):
655 655
656 656 priority = Int(600, config=True)
657 657
658 658 def check(self, line_info):
659 659 """Check to see if user is assigning to a var for the first time, in
660 660 which case we want to avoid any sort of automagic / autocall games.
661 661
662 662 This allows users to assign to either alias or magic names true python
663 663 variables (the magic/alias systems always take second seat to true
664 664 python code). E.g. ls='hi', or ls,that=1,2"""
665 665 if line_info.the_rest:
666 666 if line_info.the_rest[0] in '=,':
667 667 return self.prefilter_manager.get_handler_by_name('normal')
668 668 else:
669 669 return None
670 670
671 671
672 672 class AutoMagicChecker(PrefilterChecker):
673 673
674 674 priority = Int(700, config=True)
675 675
676 676 def check(self, line_info):
677 677 """If the ifun is magic, and automagic is on, run it. Note: normal,
678 678 non-auto magic would already have been triggered via '%' in
679 679 check_esc_chars. This just checks for automagic. Also, before
680 680 triggering the magic handler, make sure that there is nothing in the
681 681 user namespace which could shadow it."""
682 682 if not self.shell.automagic or not hasattr(self.shell,'magic_'+line_info.ifun):
683 683 return None
684 684
685 685 # We have a likely magic method. Make sure we should actually call it.
686 686 if line_info.continue_prompt and not self.prefilter_manager.multi_line_specials:
687 687 return None
688 688
689 689 head = line_info.ifun.split('.',1)[0]
690 690 if is_shadowed(head, self.shell):
691 691 return None
692 692
693 693 return self.prefilter_manager.get_handler_by_name('magic')
694 694
695 695
696 696 class AliasChecker(PrefilterChecker):
697 697
698 698 priority = Int(800, config=True)
699 699
700 700 def check(self, line_info):
701 701 "Check if the initital identifier on the line is an alias."
702 702 # Note: aliases can not contain '.'
703 703 head = line_info.ifun.split('.',1)[0]
704 704 if line_info.ifun not in self.shell.alias_manager \
705 705 or head not in self.shell.alias_manager \
706 706 or is_shadowed(head, self.shell):
707 707 return None
708 708
709 709 return self.prefilter_manager.get_handler_by_name('alias')
710 710
711 711
712 712 class PythonOpsChecker(PrefilterChecker):
713 713
714 714 priority = Int(900, config=True)
715 715
716 716 def check(self, line_info):
717 717 """If the 'rest' of the line begins with a function call or pretty much
718 718 any python operator, we should simply execute the line (regardless of
719 719 whether or not there's a possible autocall expansion). This avoids
720 720 spurious (and very confusing) geattr() accesses."""
721 721 if line_info.the_rest and line_info.the_rest[0] in '!=()<>,+*/%^&|':
722 722 return self.prefilter_manager.get_handler_by_name('normal')
723 723 else:
724 724 return None
725 725
726 726
727 727 class AutocallChecker(PrefilterChecker):
728 728
729 729 priority = Int(1000, config=True)
730 730
731 731 def check(self, line_info):
732 732 "Check if the initial word/function is callable and autocall is on."
733 733 if not self.shell.autocall:
734 734 return None
735 735
736 736 oinfo = line_info.ofind(self.shell) # This can mutate state via getattr
737 737 if not oinfo['found']:
738 738 return None
739 739
740 740 if callable(oinfo['obj']) \
741 741 and (not re_exclude_auto.match(line_info.the_rest)) \
742 742 and re_fun_name.match(line_info.ifun):
743 743 return self.prefilter_manager.get_handler_by_name('auto')
744 744 else:
745 745 return None
746 746
747 747
748 748 #-----------------------------------------------------------------------------
749 749 # Prefilter handlers
750 750 #-----------------------------------------------------------------------------
751 751
752 752
753 753 class PrefilterHandler(Configurable):
754 754
755 755 handler_name = Str('normal')
756 756 esc_strings = List([])
757 757 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
758 758 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
759 759
760 760 def __init__(self, shell=None, prefilter_manager=None, config=None):
761 761 super(PrefilterHandler, self).__init__(
762 762 shell=shell, prefilter_manager=prefilter_manager, config=config
763 763 )
764 764 self.prefilter_manager.register_handler(
765 765 self.handler_name,
766 766 self,
767 767 self.esc_strings
768 768 )
769 769
770 770 def handle(self, line_info):
771 771 # print "normal: ", line_info
772 772 """Handle normal input lines. Use as a template for handlers."""
773 773
774 774 # With autoindent on, we need some way to exit the input loop, and I
775 775 # don't want to force the user to have to backspace all the way to
776 776 # clear the line. The rule will be in this case, that either two
777 777 # lines of pure whitespace in a row, or a line of pure whitespace but
778 778 # of a size different to the indent level, will exit the input loop.
779 779 line = line_info.line
780 780 continue_prompt = line_info.continue_prompt
781 781
782 782 if (continue_prompt and
783 783 self.shell.autoindent and
784 784 line.isspace() and
785 785
786 786 (0 < abs(len(line) - self.shell.indent_current_nsp) <= 2
787 787 or
788 788 not self.shell.buffer
789 789 or
790 790 (self.shell.buffer[-1]).isspace()
791 791 )
792 792 ):
793 793 line = ''
794 794
795 795 self.shell.log(line, line, continue_prompt)
796 796 return line
797 797
798 798 def __str__(self):
799 799 return "<%s(name=%s)>" % (self.__class__.__name__, self.handler_name)
800 800
801 801
802 802 class AliasHandler(PrefilterHandler):
803 803
804 804 handler_name = Str('alias')
805 805
806 806 def handle(self, line_info):
807 807 """Handle alias input lines. """
808 808 transformed = self.shell.alias_manager.expand_aliases(line_info.ifun,line_info.the_rest)
809 809 # pre is needed, because it carries the leading whitespace. Otherwise
810 810 # aliases won't work in indented sections.
811 811 line_out = '%sget_ipython().system(%s)' % (line_info.pre_whitespace,
812 812 make_quoted_expr(transformed))
813 813
814 814 self.shell.log(line_info.line, line_out, line_info.continue_prompt)
815 815 return line_out
816 816
817 817
818 818 class ShellEscapeHandler(PrefilterHandler):
819 819
820 820 handler_name = Str('shell')
821 821 esc_strings = List([ESC_SHELL, ESC_SH_CAP])
822 822
823 823 def handle(self, line_info):
824 824 """Execute the line in a shell, empty return value"""
825 825 magic_handler = self.prefilter_manager.get_handler_by_name('magic')
826 826
827 827 line = line_info.line
828 828 if line.lstrip().startswith(ESC_SH_CAP):
829 829 # rewrite LineInfo's line, ifun and the_rest to properly hold the
830 830 # call to %sx and the actual command to be executed, so
831 831 # handle_magic can work correctly. Note that this works even if
832 832 # the line is indented, so it handles multi_line_specials
833 833 # properly.
834 834 new_rest = line.lstrip()[2:]
835 835 line_info.line = '%ssx %s' % (ESC_MAGIC, new_rest)
836 836 line_info.ifun = 'sx'
837 837 line_info.the_rest = new_rest
838 838 return magic_handler.handle(line_info)
839 839 else:
840 840 cmd = line.lstrip().lstrip(ESC_SHELL)
841 841 line_out = '%sget_ipython().system(%s)' % (line_info.pre_whitespace,
842 842 make_quoted_expr(cmd))
843 843 # update cache/log and return
844 844 self.shell.log(line, line_out, line_info.continue_prompt)
845 845 return line_out
846 846
847 847
848 848 class MagicHandler(PrefilterHandler):
849 849
850 850 handler_name = Str('magic')
851 851 esc_strings = List([ESC_MAGIC])
852 852
853 853 def handle(self, line_info):
854 854 """Execute magic functions."""
855 855 ifun = line_info.ifun
856 856 the_rest = line_info.the_rest
857 857 cmd = '%sget_ipython().magic(%s)' % (line_info.pre_whitespace,
858 858 make_quoted_expr(ifun + " " + the_rest))
859 859 self.shell.log(line_info.line, cmd, line_info.continue_prompt)
860 860 return cmd
861 861
862 862
863 863 class AutoHandler(PrefilterHandler):
864 864
865 865 handler_name = Str('auto')
866 866 esc_strings = List([ESC_PAREN, ESC_QUOTE, ESC_QUOTE2])
867 867
868 868 def handle(self, line_info):
869 869 """Handle lines which can be auto-executed, quoting if requested."""
870 870 line = line_info.line
871 871 ifun = line_info.ifun
872 872 the_rest = line_info.the_rest
873 873 pre = line_info.pre
874 874 continue_prompt = line_info.continue_prompt
875 875 obj = line_info.ofind(self)['obj']
876 876 #print 'pre <%s> ifun <%s> rest <%s>' % (pre,ifun,the_rest) # dbg
877 877
878 878 # This should only be active for single-line input!
879 879 if continue_prompt:
880 880 self.shell.log(line,line,continue_prompt)
881 881 return line
882 882
883 883 force_auto = isinstance(obj, IPyAutocall)
884 884 auto_rewrite = True
885 885
886 886 if pre == ESC_QUOTE:
887 887 # Auto-quote splitting on whitespace
888 888 newcmd = '%s("%s")' % (ifun,'", "'.join(the_rest.split()) )
889 889 elif pre == ESC_QUOTE2:
890 890 # Auto-quote whole string
891 891 newcmd = '%s("%s")' % (ifun,the_rest)
892 892 elif pre == ESC_PAREN:
893 893 newcmd = '%s(%s)' % (ifun,",".join(the_rest.split()))
894 894 else:
895 895 # Auto-paren.
896 896 # We only apply it to argument-less calls if the autocall
897 897 # parameter is set to 2. We only need to check that autocall is <
898 898 # 2, since this function isn't called unless it's at least 1.
899 899 if not the_rest and (self.shell.autocall < 2) and not force_auto:
900 900 newcmd = '%s %s' % (ifun,the_rest)
901 901 auto_rewrite = False
902 902 else:
903 903 if not force_auto and the_rest.startswith('['):
904 904 if hasattr(obj,'__getitem__'):
905 905 # Don't autocall in this case: item access for an object
906 906 # which is BOTH callable and implements __getitem__.
907 907 newcmd = '%s %s' % (ifun,the_rest)
908 908 auto_rewrite = False
909 909 else:
910 910 # if the object doesn't support [] access, go ahead and
911 911 # autocall
912 912 newcmd = '%s(%s)' % (ifun.rstrip(),the_rest)
913 913 elif the_rest.endswith(';'):
914 914 newcmd = '%s(%s);' % (ifun.rstrip(),the_rest[:-1])
915 915 else:
916 916 newcmd = '%s(%s)' % (ifun.rstrip(), the_rest)
917 917
918 918 if auto_rewrite:
919 919 rw = self.shell.displayhook.prompt1.auto_rewrite() + newcmd
920 920
921 921 try:
922 922 # plain ascii works better w/ pyreadline, on some machines, so
923 923 # we use it and only print uncolored rewrite if we have unicode
924 924 rw = str(rw)
925 925 print >>IPython.utils.io.Term.cout, rw
926 926 except UnicodeEncodeError:
927 927 print "-------------->" + newcmd
928 928
929 929 # log what is now valid Python, not the actual user input (without the
930 930 # final newline)
931 931 self.shell.log(line,newcmd,continue_prompt)
932 932 return newcmd
933 933
934 934
935 935 class HelpHandler(PrefilterHandler):
936 936
937 937 handler_name = Str('help')
938 938 esc_strings = List([ESC_HELP])
939 939
940 940 def handle(self, line_info):
941 941 """Try to get some help for the object.
942 942
943 943 obj? or ?obj -> basic information.
944 944 obj?? or ??obj -> more details.
945 945 """
946 946 normal_handler = self.prefilter_manager.get_handler_by_name('normal')
947 947 line = line_info.line
948 948 # We need to make sure that we don't process lines which would be
949 949 # otherwise valid python, such as "x=1 # what?"
950 950 try:
951 951 codeop.compile_command(line)
952 952 except SyntaxError:
953 953 # We should only handle as help stuff which is NOT valid syntax
954 954 if line[0]==ESC_HELP:
955 955 line = line[1:]
956 956 elif line[-1]==ESC_HELP:
957 957 line = line[:-1]
958 958 self.shell.log(line, '#?'+line, line_info.continue_prompt)
959 959 if line:
960 960 #print 'line:<%r>' % line # dbg
961 961 self.shell.magic_pinfo(line)
962 962 else:
963 page(self.shell.usage, screen_lines=self.shell.usable_screen_length)
963 page.page(self.shell.usage, screen_lines=self.shell.usable_screen_length)
964 964 return '' # Empty string is needed here!
965 965 except:
966 966 raise
967 967 # Pass any other exceptions through to the normal handler
968 968 return normal_handler.handle(line_info)
969 969 else:
970 970 # If the code compiles ok, we should handle it normally
971 971 return normal_handler.handle(line_info)
972 972
973 973
974 974 class EmacsHandler(PrefilterHandler):
975 975
976 976 handler_name = Str('emacs')
977 977 esc_strings = List([])
978 978
979 979 def handle(self, line_info):
980 980 """Handle input lines marked by python-mode."""
981 981
982 982 # Currently, nothing is done. Later more functionality can be added
983 983 # here if needed.
984 984
985 985 # The input cache shouldn't be updated
986 986 return line_info.line
987 987
988 988
989 989 #-----------------------------------------------------------------------------
990 990 # Defaults
991 991 #-----------------------------------------------------------------------------
992 992
993 993
994 994 _default_transformers = [
995 995 AssignSystemTransformer,
996 996 AssignMagicTransformer,
997 997 PyPromptTransformer,
998 998 IPyPromptTransformer,
999 999 ]
1000 1000
1001 1001 _default_checkers = [
1002 1002 EmacsChecker,
1003 1003 ShellEscapeChecker,
1004 1004 IPyAutocallChecker,
1005 1005 MultiLineMagicChecker,
1006 1006 EscCharsChecker,
1007 1007 AssignmentChecker,
1008 1008 AutoMagicChecker,
1009 1009 AliasChecker,
1010 1010 PythonOpsChecker,
1011 1011 AutocallChecker
1012 1012 ]
1013 1013
1014 1014 _default_handlers = [
1015 1015 PrefilterHandler,
1016 1016 AliasHandler,
1017 1017 ShellEscapeHandler,
1018 1018 MagicHandler,
1019 1019 AutoHandler,
1020 1020 HelpHandler,
1021 1021 EmacsHandler
1022 1022 ]
@@ -1,148 +1,148 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Interactive functions and magic functions for Gnuplot usage.
3 3
4 4 This requires the Gnuplot.py module for interfacing python with Gnuplot, which
5 5 can be downloaded from:
6 6
7 7 http://gnuplot-py.sourceforge.net/
8 8
9 9 See gphelp() below for details on the services offered by this module.
10 10
11 11 Inspired by a suggestion/request from Arnd Baecker.
12 12 """
13 13
14 14 __all__ = ['Gnuplot','gp','gp_new','plot','plot2','splot','replot',
15 15 'hardcopy','gpdata','gpfile','gpstring','gpfunc','gpgrid',
16 16 'gphelp']
17 17
18 18 import IPython.GnuplotRuntime as GRun
19 19 from IPython.utils.genutils import warn
20 from IPython.core.page import page
20 from IPython.core import page
21 21
22 22 # Set global names for interactive use
23 23 Gnuplot = GRun.Gnuplot
24 24 gp_new = GRun.gp_new
25 25 gp = GRun.gp
26 26 plot = gp.plot
27 27 plot2 = gp.plot2
28 28 splot = gp.splot
29 29 replot = gp.replot
30 30 hardcopy = gp.hardcopy
31 31
32 32 # Accessors for the main plot object constructors:
33 33 gpdata = Gnuplot.Data
34 34 gpfile = Gnuplot.File
35 35 gpstring = Gnuplot.String
36 36 gpfunc = Gnuplot.Func
37 37 gpgrid = Gnuplot.GridData
38 38
39 39 def gphelp():
40 40 """Print information about the Gnuplot facilities in IPython."""
41 41
42 42 page("""
43 43 IPython provides an interface to access the Gnuplot scientific plotting
44 44 system, in an environment similar to that of Mathematica or Matlab.
45 45
46 46 New top-level global objects
47 47 ----------------------------
48 48
49 49 Please see their respective docstrings for further details.
50 50
51 51 - gp: a running Gnuplot instance. You can access its methods as
52 52 gp.<method>. gp(`a string`) will execute the given string as if it had been
53 53 typed in an interactive gnuplot window.
54 54
55 55 - plot, splot, replot and hardcopy: aliases to the methods of the same name in
56 56 the global running Gnuplot instance gp. These allow you to simply type:
57 57
58 58 In [1]: plot(x,sin(x),title='Sin(x)') # assuming x is a Numeric array
59 59
60 60 and obtain a plot of sin(x) vs x with the title 'Sin(x)'.
61 61
62 62 - gp_new: a function which returns a new Gnuplot instance. This can be used to
63 63 have multiple Gnuplot instances running in your session to compare different
64 64 plots, each in a separate window.
65 65
66 66 - Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
67 67 the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
68 68 functions with improved versions (Gnuplot2 comes with IPython).
69 69
70 70 - gpdata, gpfile, gpstring, gpfunc, gpgrid: aliases to Gnuplot.Data,
71 71 Gnuplot.File, Gnuplot.String, Gnuplot.Func and Gnuplot.GridData
72 72 respectively. These functions create objects which can then be passed to the
73 73 plotting commands. See the Gnuplot.py documentation for details.
74 74
75 75 Keep in mind that all commands passed to a Gnuplot instance are executed in
76 76 the Gnuplot namespace, where no Python variables exist. For example, for
77 77 plotting sin(x) vs x as above, typing
78 78
79 79 In [2]: gp('plot x,sin(x)')
80 80
81 81 would not work. Instead, you would get the plot of BOTH the functions 'x' and
82 82 'sin(x)', since Gnuplot doesn't know about the 'x' Python array. The plot()
83 83 method lives in python and does know about these variables.
84 84
85 85
86 86 New magic functions
87 87 -------------------
88 88
89 89 %gpc: pass one command to Gnuplot and execute it or open a Gnuplot shell where
90 90 each line of input is executed.
91 91
92 92 %gp_set_default: reset the value of IPython's global Gnuplot instance.""")
93 93
94 94 # Code below is all for IPython use
95 95 # Define the magic functions for communicating with the above gnuplot instance.
96 96 def magic_gpc(self,parameter_s=''):
97 97 """Execute a gnuplot command or open a gnuplot shell.
98 98
99 99 Usage (omit the % if automagic is on). There are two ways to use it:
100 100
101 101 1) %gpc 'command' -> passes 'command' directly to the gnuplot instance.
102 102
103 103 2) %gpc -> will open up a prompt (gnuplot>>>) which takes input like the
104 104 standard gnuplot interactive prompt. If you need to type a multi-line
105 105 command, use \\ at the end of each intermediate line.
106 106
107 107 Upon exiting of the gnuplot sub-shell, you return to your IPython
108 108 session (the gnuplot sub-shell can be invoked as many times as needed).
109 109 """
110 110
111 111 if parameter_s.strip():
112 112 self.shell.gnuplot(parameter_s)
113 113 else:
114 114 self.shell.gnuplot.interact()
115 115
116 116 def magic_gp_set_default(self,parameter_s=''):
117 117 """Set the default gnuplot instance accessed by the %gp magic function.
118 118
119 119 %gp_set_default name
120 120
121 121 Call with the name of the new instance at the command line. If you want to
122 122 set this instance in your own code (using an embedded IPython, for
123 123 example), simply set the variable __IPYTHON__.gnuplot to your own gnuplot
124 124 instance object."""
125 125
126 126 gname = parameter_s.strip()
127 127 G = eval(gname,self.shell.user_ns)
128 128 self.shell.gnuplot = G
129 129 self.shell.user_ns.update({'plot':G.plot,'splot':G.splot,'plot2':G.plot2,
130 130 'replot':G.replot,'hardcopy':G.hardcopy})
131 131
132 132 try:
133 133 __IPYTHON__
134 134 except NameError:
135 135 pass
136 136 else:
137 137 # make the global Gnuplot instance known to IPython
138 138 __IPYTHON__.gnuplot = GRun.gp
139 139 __IPYTHON__.gnuplot.shell_first_time = 1
140 140
141 141 print """*** Type `gphelp` for help on the Gnuplot integration features."""
142 142
143 143 # Add the new magic functions to the class dict
144 144 from IPython.core.iplib import InteractiveShell
145 145 InteractiveShell.magic_gpc = magic_gpc
146 146 InteractiveShell.magic_gp_set_default = magic_gp_set_default
147 147
148 148 #********************** End of file <GnuplotInteractive.py> *******************
@@ -1,147 +1,151 b''
1 1 import os
2 2
3 3 # System library imports
4 4 from PyQt4 import QtCore, QtGui
5 5
6 6 # Local imports
7 7 from IPython.frontend.qt.svg import save_svg, svg_to_clipboard, svg_to_image
8 8 from ipython_widget import IPythonWidget
9 9
10 10
11 11 class RichIPythonWidget(IPythonWidget):
12 12 """ An IPythonWidget that supports rich text, including lists, images, and
13 13 tables. Note that raw performance will be reduced compared to the plain
14 14 text version.
15 15 """
16 16
17 17 # Protected class variables.
18 18 _svg_text_format_property = 1
19 19
20 20 #---------------------------------------------------------------------------
21 21 # 'object' interface
22 22 #---------------------------------------------------------------------------
23 23
24 24 def __init__(self, *args, **kw):
25 25 """ Create a RichIPythonWidget.
26 26 """
27 27 kw['kind'] = 'rich'
28 28 super(RichIPythonWidget, self).__init__(*args, **kw)
29 29
30 30 #---------------------------------------------------------------------------
31 31 # 'ConsoleWidget' protected interface
32 32 #---------------------------------------------------------------------------
33 33
34 34 def _show_context_menu(self, pos):
35 35 """ Reimplemented to show a custom context menu for images.
36 36 """
37 37 format = self._control.cursorForPosition(pos).charFormat()
38 38 name = format.stringProperty(QtGui.QTextFormat.ImageName)
39 39 if name.isEmpty():
40 40 super(RichIPythonWidget, self)._show_context_menu(pos)
41 41 else:
42 42 menu = QtGui.QMenu()
43 43
44 44 menu.addAction('Copy Image', lambda: self._copy_image(name))
45 45 menu.addAction('Save Image As...', lambda: self._save_image(name))
46 46 menu.addSeparator()
47 47
48 48 svg = format.stringProperty(self._svg_text_format_property)
49 49 if not svg.isEmpty():
50 50 menu.addSeparator()
51 51 menu.addAction('Copy SVG', lambda: svg_to_clipboard(svg))
52 52 menu.addAction('Save SVG As...',
53 53 lambda: save_svg(svg, self._control))
54 54
55 55 menu.exec_(self._control.mapToGlobal(pos))
56 56
57 57 #---------------------------------------------------------------------------
58 58 # 'FrontendWidget' protected interface
59 59 #---------------------------------------------------------------------------
60 60
61 61 def _process_execute_ok(self, msg):
62 62 """ Reimplemented to handle matplotlib plot payloads.
63 63 """
64 64 payload = msg['content']['payload']
65 65 for item in payload:
66 66 if item['source'] == 'IPython.zmq.pylab.backend_payload.add_plot_payload':
67 67 if item['format'] == 'svg':
68 68 svg = item['data']
69 69 try:
70 70 image = svg_to_image(svg)
71 71 except ValueError:
72 72 self._append_plain_text('Received invalid plot data.')
73 73 else:
74 74 format = self._add_image(image)
75 75 format.setProperty(self._svg_text_format_property, svg)
76 76 cursor = self._get_end_cursor()
77 77 cursor.insertBlock()
78 78 cursor.insertImage(format)
79 79 cursor.insertBlock()
80 80 else:
81 81 # Add other plot formats here!
82 82 pass
83 83 elif item['source'] == 'IPython.zmq.zmqshell.ZMQInteractiveShell.edit_magic':
84 84 # TODO: I have implmented the logic for TextMate on the Mac.
85 85 # But, we need to allow payload handlers on the non-rich
86 86 # text IPython widget as well. Furthermore, we should probably
87 87 # move these handlers to separate methods. But, we need to
88 88 # be very careful to process the payload list in order. Thus,
89 89 # we will probably need a _handle_payload method of the
90 90 # base class that dispatches to the separate handler methods
91 91 # for each payload source. If a particular subclass doesn't
92 92 # have a handler for a payload source, it should at least
93 93 # print a nice message.
94 94 filename = item['filename']
95 95 line_number = item['line_number']
96 96 if line_number is None:
97 97 cmd = 'mate %s' % filename
98 98 else:
99 99 cmd = 'mate -l %s %s' % (line_number, filename)
100 100 os.system(cmd)
101 elif item['source'] == 'IPython.zmq.page.page':
102 # TODO: This is probably a good place to start, but Evan can
103 # add better paging capabilities.
104 self._append_plain_text(item['data'])
101 105 else:
102 106 # Add other payload types here!
103 107 pass
104 108 else:
105 109 super(RichIPythonWidget, self)._process_execute_ok(msg)
106 110
107 111 #---------------------------------------------------------------------------
108 112 # 'RichIPythonWidget' protected interface
109 113 #---------------------------------------------------------------------------
110 114
111 115 def _add_image(self, image):
112 116 """ Adds the specified QImage to the document and returns a
113 117 QTextImageFormat that references it.
114 118 """
115 119 document = self._control.document()
116 120 name = QtCore.QString.number(image.cacheKey())
117 121 document.addResource(QtGui.QTextDocument.ImageResource,
118 122 QtCore.QUrl(name), image)
119 123 format = QtGui.QTextImageFormat()
120 124 format.setName(name)
121 125 return format
122 126
123 127 def _copy_image(self, name):
124 128 """ Copies the ImageResource with 'name' to the clipboard.
125 129 """
126 130 image = self._get_image(name)
127 131 QtGui.QApplication.clipboard().setImage(image)
128 132
129 133 def _get_image(self, name):
130 134 """ Returns the QImage stored as the ImageResource with 'name'.
131 135 """
132 136 document = self._control.document()
133 137 variant = document.resource(QtGui.QTextDocument.ImageResource,
134 138 QtCore.QUrl(name))
135 139 return variant.toPyObject()
136 140
137 141 def _save_image(self, name, format='PNG'):
138 142 """ Shows a save dialog for the ImageResource with 'name'.
139 143 """
140 144 dialog = QtGui.QFileDialog(self._control, 'Save Image')
141 145 dialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
142 146 dialog.setDefaultSuffix(format.lower())
143 147 dialog.setNameFilter('%s file (*.%s)' % (format, format.lower()))
144 148 if dialog.exec_():
145 149 filename = dialog.selectedFiles()[0]
146 150 image = self._get_image(name)
147 151 image.save(filename, format)
@@ -1,354 +1,359 b''
1 1 import inspect
2 2 import re
3 3 import sys
4 4 from subprocess import Popen, PIPE
5 5
6 6 from IPython.core.interactiveshell import (
7 7 InteractiveShell, InteractiveShellABC
8 8 )
9 9 from IPython.core.displayhook import DisplayHook
10 10 from IPython.core.macro import Macro
11 11 from IPython.utils.path import get_py_filename
12 12 from IPython.utils.text import StringTypes
13 13 from IPython.utils.traitlets import Instance, Type, Dict
14 14 from IPython.utils.warn import warn
15 15 from IPython.zmq.session import extract_header
16 from IPython.core.payloadpage import install_payload_page
17
18
19 # Install the payload version of page.
20 install_payload_page()
16 21
17 22
18 23 class ZMQDisplayHook(DisplayHook):
19 24
20 25 session = Instance('IPython.zmq.session.Session')
21 26 pub_socket = Instance('zmq.Socket')
22 27 parent_header = Dict({})
23 28
24 29 def set_parent(self, parent):
25 30 """Set the parent for outbound messages."""
26 31 self.parent_header = extract_header(parent)
27 32
28 33 def start_displayhook(self):
29 34 self.msg = self.session.msg(u'pyout', {}, parent=self.parent_header)
30 35
31 36 def write_output_prompt(self):
32 37 """Write the output prompt."""
33 38 if self.do_full_cache:
34 39 self.msg['content']['output_sep'] = self.output_sep
35 40 self.msg['content']['prompt_string'] = str(self.prompt_out)
36 41 self.msg['content']['prompt_number'] = self.prompt_count
37 42 self.msg['content']['output_sep2'] = self.output_sep2
38 43
39 44 def write_result_repr(self, result_repr):
40 45 self.msg['content']['data'] = result_repr
41 46
42 47 def finish_displayhook(self):
43 48 """Finish up all displayhook activities."""
44 49 self.pub_socket.send_json(self.msg)
45 50 self.msg = None
46 51
47 52
48 53 class ZMQInteractiveShell(InteractiveShell):
49 54 """A subclass of InteractiveShell for ZMQ."""
50 55
51 56 displayhook_class = Type(ZMQDisplayHook)
52 57
53 58 def system(self, cmd):
54 59 cmd = self.var_expand(cmd, depth=2)
55 60 sys.stdout.flush()
56 61 sys.stderr.flush()
57 62 p = Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE)
58 63 for line in p.stdout.read().split('\n'):
59 64 if len(line) > 0:
60 65 print line
61 66 for line in p.stderr.read().split('\n'):
62 67 if len(line) > 0:
63 68 print line
64 69 p.wait()
65 70
66 71 def init_io(self):
67 72 # This will just use sys.stdout and sys.stderr. If you want to
68 73 # override sys.stdout and sys.stderr themselves, you need to do that
69 74 # *before* instantiating this class, because Term holds onto
70 75 # references to the underlying streams.
71 76 import IPython.utils.io
72 77 Term = IPython.utils.io.IOTerm()
73 78 IPython.utils.io.Term = Term
74 79
75 80 def magic_edit(self,parameter_s='',last_call=['','']):
76 81 """Bring up an editor and execute the resulting code.
77 82
78 83 Usage:
79 84 %edit [options] [args]
80 85
81 86 %edit runs IPython's editor hook. The default version of this hook is
82 87 set to call the __IPYTHON__.rc.editor command. This is read from your
83 88 environment variable $EDITOR. If this isn't found, it will default to
84 89 vi under Linux/Unix and to notepad under Windows. See the end of this
85 90 docstring for how to change the editor hook.
86 91
87 92 You can also set the value of this editor via the command line option
88 93 '-editor' or in your ipythonrc file. This is useful if you wish to use
89 94 specifically for IPython an editor different from your typical default
90 95 (and for Windows users who typically don't set environment variables).
91 96
92 97 This command allows you to conveniently edit multi-line code right in
93 98 your IPython session.
94 99
95 100 If called without arguments, %edit opens up an empty editor with a
96 101 temporary file and will execute the contents of this file when you
97 102 close it (don't forget to save it!).
98 103
99 104
100 105 Options:
101 106
102 107 -n <number>: open the editor at a specified line number. By default,
103 108 the IPython editor hook uses the unix syntax 'editor +N filename', but
104 109 you can configure this by providing your own modified hook if your
105 110 favorite editor supports line-number specifications with a different
106 111 syntax.
107 112
108 113 -p: this will call the editor with the same data as the previous time
109 114 it was used, regardless of how long ago (in your current session) it
110 115 was.
111 116
112 117 -r: use 'raw' input. This option only applies to input taken from the
113 118 user's history. By default, the 'processed' history is used, so that
114 119 magics are loaded in their transformed version to valid Python. If
115 120 this option is given, the raw input as typed as the command line is
116 121 used instead. When you exit the editor, it will be executed by
117 122 IPython's own processor.
118 123
119 124 -x: do not execute the edited code immediately upon exit. This is
120 125 mainly useful if you are editing programs which need to be called with
121 126 command line arguments, which you can then do using %run.
122 127
123 128
124 129 Arguments:
125 130
126 131 If arguments are given, the following possibilites exist:
127 132
128 133 - The arguments are numbers or pairs of colon-separated numbers (like
129 134 1 4:8 9). These are interpreted as lines of previous input to be
130 135 loaded into the editor. The syntax is the same of the %macro command.
131 136
132 137 - If the argument doesn't start with a number, it is evaluated as a
133 138 variable and its contents loaded into the editor. You can thus edit
134 139 any string which contains python code (including the result of
135 140 previous edits).
136 141
137 142 - If the argument is the name of an object (other than a string),
138 143 IPython will try to locate the file where it was defined and open the
139 144 editor at the point where it is defined. You can use `%edit function`
140 145 to load an editor exactly at the point where 'function' is defined,
141 146 edit it and have the file be executed automatically.
142 147
143 148 If the object is a macro (see %macro for details), this opens up your
144 149 specified editor with a temporary file containing the macro's data.
145 150 Upon exit, the macro is reloaded with the contents of the file.
146 151
147 152 Note: opening at an exact line is only supported under Unix, and some
148 153 editors (like kedit and gedit up to Gnome 2.8) do not understand the
149 154 '+NUMBER' parameter necessary for this feature. Good editors like
150 155 (X)Emacs, vi, jed, pico and joe all do.
151 156
152 157 - If the argument is not found as a variable, IPython will look for a
153 158 file with that name (adding .py if necessary) and load it into the
154 159 editor. It will execute its contents with execfile() when you exit,
155 160 loading any code in the file into your interactive namespace.
156 161
157 162 After executing your code, %edit will return as output the code you
158 163 typed in the editor (except when it was an existing file). This way
159 164 you can reload the code in further invocations of %edit as a variable,
160 165 via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
161 166 the output.
162 167
163 168 Note that %edit is also available through the alias %ed.
164 169
165 170 This is an example of creating a simple function inside the editor and
166 171 then modifying it. First, start up the editor:
167 172
168 173 In [1]: ed
169 174 Editing... done. Executing edited code...
170 175 Out[1]: 'def foo():n print "foo() was defined in an editing session"n'
171 176
172 177 We can then call the function foo():
173 178
174 179 In [2]: foo()
175 180 foo() was defined in an editing session
176 181
177 182 Now we edit foo. IPython automatically loads the editor with the
178 183 (temporary) file where foo() was previously defined:
179 184
180 185 In [3]: ed foo
181 186 Editing... done. Executing edited code...
182 187
183 188 And if we call foo() again we get the modified version:
184 189
185 190 In [4]: foo()
186 191 foo() has now been changed!
187 192
188 193 Here is an example of how to edit a code snippet successive
189 194 times. First we call the editor:
190 195
191 196 In [5]: ed
192 197 Editing... done. Executing edited code...
193 198 hello
194 199 Out[5]: "print 'hello'n"
195 200
196 201 Now we call it again with the previous output (stored in _):
197 202
198 203 In [6]: ed _
199 204 Editing... done. Executing edited code...
200 205 hello world
201 206 Out[6]: "print 'hello world'n"
202 207
203 208 Now we call it with the output #8 (stored in _8, also as Out[8]):
204 209
205 210 In [7]: ed _8
206 211 Editing... done. Executing edited code...
207 212 hello again
208 213 Out[7]: "print 'hello again'n"
209 214
210 215
211 216 Changing the default editor hook:
212 217
213 218 If you wish to write your own editor hook, you can put it in a
214 219 configuration file which you load at startup time. The default hook
215 220 is defined in the IPython.core.hooks module, and you can use that as a
216 221 starting example for further modifications. That file also has
217 222 general instructions on how to set a new hook for use once you've
218 223 defined it."""
219 224
220 225 # FIXME: This function has become a convoluted mess. It needs a
221 226 # ground-up rewrite with clean, simple logic.
222 227
223 228 def make_filename(arg):
224 229 "Make a filename from the given args"
225 230 try:
226 231 filename = get_py_filename(arg)
227 232 except IOError:
228 233 if args.endswith('.py'):
229 234 filename = arg
230 235 else:
231 236 filename = None
232 237 return filename
233 238
234 239 # custom exceptions
235 240 class DataIsObject(Exception): pass
236 241
237 242 opts,args = self.parse_options(parameter_s,'prn:')
238 243 # Set a few locals from the options for convenience:
239 244 opts_p = opts.has_key('p')
240 245 opts_r = opts.has_key('r')
241 246
242 247 # Default line number value
243 248 lineno = opts.get('n',None)
244 249
245 250 if opts_p:
246 251 args = '_%s' % last_call[0]
247 252 if not self.shell.user_ns.has_key(args):
248 253 args = last_call[1]
249 254
250 255 # use last_call to remember the state of the previous call, but don't
251 256 # let it be clobbered by successive '-p' calls.
252 257 try:
253 258 last_call[0] = self.shell.displayhook.prompt_count
254 259 if not opts_p:
255 260 last_call[1] = parameter_s
256 261 except:
257 262 pass
258 263
259 264 # by default this is done with temp files, except when the given
260 265 # arg is a filename
261 266 use_temp = 1
262 267
263 268 if re.match(r'\d',args):
264 269 # Mode where user specifies ranges of lines, like in %macro.
265 270 # This means that you can't edit files whose names begin with
266 271 # numbers this way. Tough.
267 272 ranges = args.split()
268 273 data = ''.join(self.extract_input_slices(ranges,opts_r))
269 274 elif args.endswith('.py'):
270 275 filename = make_filename(args)
271 276 data = ''
272 277 use_temp = 0
273 278 elif args:
274 279 try:
275 280 # Load the parameter given as a variable. If not a string,
276 281 # process it as an object instead (below)
277 282
278 283 #print '*** args',args,'type',type(args) # dbg
279 284 data = eval(args,self.shell.user_ns)
280 285 if not type(data) in StringTypes:
281 286 raise DataIsObject
282 287
283 288 except (NameError,SyntaxError):
284 289 # given argument is not a variable, try as a filename
285 290 filename = make_filename(args)
286 291 if filename is None:
287 292 warn("Argument given (%s) can't be found as a variable "
288 293 "or as a filename." % args)
289 294 return
290 295
291 296 data = ''
292 297 use_temp = 0
293 298 except DataIsObject:
294 299
295 300 # macros have a special edit function
296 301 if isinstance(data,Macro):
297 302 self._edit_macro(args,data)
298 303 return
299 304
300 305 # For objects, try to edit the file where they are defined
301 306 try:
302 307 filename = inspect.getabsfile(data)
303 308 if 'fakemodule' in filename.lower() and inspect.isclass(data):
304 309 # class created by %edit? Try to find source
305 310 # by looking for method definitions instead, the
306 311 # __module__ in those classes is FakeModule.
307 312 attrs = [getattr(data, aname) for aname in dir(data)]
308 313 for attr in attrs:
309 314 if not inspect.ismethod(attr):
310 315 continue
311 316 filename = inspect.getabsfile(attr)
312 317 if filename and 'fakemodule' not in filename.lower():
313 318 # change the attribute to be the edit target instead
314 319 data = attr
315 320 break
316 321
317 322 datafile = 1
318 323 except TypeError:
319 324 filename = make_filename(args)
320 325 datafile = 1
321 326 warn('Could not find file where `%s` is defined.\n'
322 327 'Opening a file named `%s`' % (args,filename))
323 328 # Now, make sure we can actually read the source (if it was in
324 329 # a temp file it's gone by now).
325 330 if datafile:
326 331 try:
327 332 if lineno is None:
328 333 lineno = inspect.getsourcelines(data)[1]
329 334 except IOError:
330 335 filename = make_filename(args)
331 336 if filename is None:
332 337 warn('The file `%s` where `%s` was defined cannot '
333 338 'be read.' % (filename,data))
334 339 return
335 340 use_temp = 0
336 341 else:
337 342 data = ''
338 343
339 344 if use_temp:
340 345 filename = self.shell.mktempfile(data)
341 346 print 'IPython will make a temporary file named:',filename
342 347
343 348 payload = {
344 349 'source' : 'IPython.zmq.zmqshell.ZMQInteractiveShell.edit_magic',
345 350 'filename' : filename,
346 351 'line_number' : lineno
347 352 }
348 353 self.payload_manager.write_payload(payload)
349 354
350 355
351 356 InteractiveShellABC.register(ZMQInteractiveShell)
352 357
353 358
354 359
General Comments 0
You need to be logged in to leave comments. Login now