##// END OF EJS Templates
Adding test for safe_execfile call with non-ascii path
Jörgen Stenarson -
Show More
@@ -1,2675 +1,2683 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-2011 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__ as builtin_mod
21 21 import __future__
22 22 import abc
23 23 import ast
24 24 import atexit
25 25 import codeop
26 26 import inspect
27 27 import os
28 28 import re
29 29 import sys
30 30 import tempfile
31 31 import types
32 32 try:
33 33 from contextlib import nested
34 34 except:
35 35 from IPython.utils.nested_context import nested
36 36
37 37 from IPython.config.configurable import SingletonConfigurable
38 38 from IPython.core import debugger, oinspect
39 39 from IPython.core import history as ipcorehist
40 40 from IPython.core import page
41 41 from IPython.core import prefilter
42 42 from IPython.core import shadowns
43 43 from IPython.core import ultratb
44 44 from IPython.core.alias import AliasManager, AliasError
45 45 from IPython.core.autocall import ExitAutocall
46 46 from IPython.core.builtin_trap import BuiltinTrap
47 47 from IPython.core.compilerop import CachingCompiler
48 48 from IPython.core.display_trap import DisplayTrap
49 49 from IPython.core.displayhook import DisplayHook
50 50 from IPython.core.displaypub import DisplayPublisher
51 51 from IPython.core.error import TryNext, UsageError
52 52 from IPython.core.extensions import ExtensionManager
53 53 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
54 54 from IPython.core.formatters import DisplayFormatter
55 55 from IPython.core.history import HistoryManager
56 56 from IPython.core.inputsplitter import IPythonInputSplitter
57 57 from IPython.core.logger import Logger
58 58 from IPython.core.macro import Macro
59 59 from IPython.core.magic import Magic
60 60 from IPython.core.payload import PayloadManager
61 61 from IPython.core.plugin import PluginManager
62 62 from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
63 63 from IPython.core.profiledir import ProfileDir
64 64 from IPython.external.Itpl import ItplNS
65 65 from IPython.utils import PyColorize
66 66 from IPython.utils import io
67 67 from IPython.utils import py3compat
68 68 from IPython.utils.doctestreload import doctest_reload
69 69 from IPython.utils.io import ask_yes_no, rprint
70 70 from IPython.utils.ipstruct import Struct
71 71 from IPython.utils.path import get_home_dir, get_ipython_dir, HomeDirError
72 72 from IPython.utils.pickleshare import PickleShareDB
73 73 from IPython.utils.process import system, getoutput
74 74 from IPython.utils.strdispatch import StrDispatch
75 75 from IPython.utils.syspathcontext import prepended_to_syspath
76 76 from IPython.utils.text import num_ini_spaces, format_screen, LSString, SList
77 77 from IPython.utils.traitlets import (Int, CBool, CaselessStrEnum, Enum,
78 78 List, Unicode, Instance, Type)
79 79 from IPython.utils.warn import warn, error, fatal
80 80 import IPython.core.hooks
81 81
82 82 #-----------------------------------------------------------------------------
83 83 # Globals
84 84 #-----------------------------------------------------------------------------
85 85
86 86 # compiled regexps for autoindent management
87 87 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
88 88
89 89 #-----------------------------------------------------------------------------
90 90 # Utilities
91 91 #-----------------------------------------------------------------------------
92 92
93 93 def softspace(file, newvalue):
94 94 """Copied from code.py, to remove the dependency"""
95 95
96 96 oldvalue = 0
97 97 try:
98 98 oldvalue = file.softspace
99 99 except AttributeError:
100 100 pass
101 101 try:
102 102 file.softspace = newvalue
103 103 except (AttributeError, TypeError):
104 104 # "attribute-less object" or "read-only attributes"
105 105 pass
106 106 return oldvalue
107 107
108 108
109 109 def no_op(*a, **kw): pass
110 110
111 111 class NoOpContext(object):
112 112 def __enter__(self): pass
113 113 def __exit__(self, type, value, traceback): pass
114 114 no_op_context = NoOpContext()
115 115
116 116 class SpaceInInput(Exception): pass
117 117
118 118 class Bunch: pass
119 119
120 120
121 121 def get_default_colors():
122 122 if sys.platform=='darwin':
123 123 return "LightBG"
124 124 elif os.name=='nt':
125 125 return 'Linux'
126 126 else:
127 127 return 'Linux'
128 128
129 129
130 130 class SeparateUnicode(Unicode):
131 131 """A Unicode subclass to validate separate_in, separate_out, etc.
132 132
133 133 This is a Unicode based trait that converts '0'->'' and '\\n'->'\n'.
134 134 """
135 135
136 136 def validate(self, obj, value):
137 137 if value == '0': value = ''
138 138 value = value.replace('\\n','\n')
139 139 return super(SeparateUnicode, self).validate(obj, value)
140 140
141 141
142 142 class ReadlineNoRecord(object):
143 143 """Context manager to execute some code, then reload readline history
144 144 so that interactive input to the code doesn't appear when pressing up."""
145 145 def __init__(self, shell):
146 146 self.shell = shell
147 147 self._nested_level = 0
148 148
149 149 def __enter__(self):
150 150 if self._nested_level == 0:
151 151 try:
152 152 self.orig_length = self.current_length()
153 153 self.readline_tail = self.get_readline_tail()
154 154 except (AttributeError, IndexError): # Can fail with pyreadline
155 155 self.orig_length, self.readline_tail = 999999, []
156 156 self._nested_level += 1
157 157
158 158 def __exit__(self, type, value, traceback):
159 159 self._nested_level -= 1
160 160 if self._nested_level == 0:
161 161 # Try clipping the end if it's got longer
162 162 try:
163 163 e = self.current_length() - self.orig_length
164 164 if e > 0:
165 165 for _ in range(e):
166 166 self.shell.readline.remove_history_item(self.orig_length)
167 167
168 168 # If it still doesn't match, just reload readline history.
169 169 if self.current_length() != self.orig_length \
170 170 or self.get_readline_tail() != self.readline_tail:
171 171 self.shell.refill_readline_hist()
172 172 except (AttributeError, IndexError):
173 173 pass
174 174 # Returning False will cause exceptions to propagate
175 175 return False
176 176
177 177 def current_length(self):
178 178 return self.shell.readline.get_current_history_length()
179 179
180 180 def get_readline_tail(self, n=10):
181 181 """Get the last n items in readline history."""
182 182 end = self.shell.readline.get_current_history_length() + 1
183 183 start = max(end-n, 1)
184 184 ghi = self.shell.readline.get_history_item
185 185 return [ghi(x) for x in range(start, end)]
186 186
187 187
188 188 _autocall_help = """
189 189 Make IPython automatically call any callable object even if
190 190 you didn't type explicit parentheses. For example, 'str 43' becomes 'str(43)'
191 191 automatically. The value can be '0' to disable the feature, '1' for 'smart'
192 192 autocall, where it is not applied if there are no more arguments on the line,
193 193 and '2' for 'full' autocall, where all callable objects are automatically
194 194 called (even if no arguments are present). The default is '1'.
195 195 """
196 196
197 197 #-----------------------------------------------------------------------------
198 198 # Main IPython class
199 199 #-----------------------------------------------------------------------------
200 200
201 201 class InteractiveShell(SingletonConfigurable, Magic):
202 202 """An enhanced, interactive shell for Python."""
203 203
204 204 _instance = None
205 205
206 206 autocall = Enum((0,1,2), default_value=1, config=True, help=
207 207 """
208 208 Make IPython automatically call any callable object even if you didn't
209 209 type explicit parentheses. For example, 'str 43' becomes 'str(43)'
210 210 automatically. The value can be '0' to disable the feature, '1' for
211 211 'smart' autocall, where it is not applied if there are no more
212 212 arguments on the line, and '2' for 'full' autocall, where all callable
213 213 objects are automatically called (even if no arguments are present).
214 214 The default is '1'.
215 215 """
216 216 )
217 217 # TODO: remove all autoindent logic and put into frontends.
218 218 # We can't do this yet because even runlines uses the autoindent.
219 219 autoindent = CBool(True, config=True, help=
220 220 """
221 221 Autoindent IPython code entered interactively.
222 222 """
223 223 )
224 224 automagic = CBool(True, config=True, help=
225 225 """
226 226 Enable magic commands to be called without the leading %.
227 227 """
228 228 )
229 229 cache_size = Int(1000, config=True, help=
230 230 """
231 231 Set the size of the output cache. The default is 1000, you can
232 232 change it permanently in your config file. Setting it to 0 completely
233 233 disables the caching system, and the minimum value accepted is 20 (if
234 234 you provide a value less than 20, it is reset to 0 and a warning is
235 235 issued). This limit is defined because otherwise you'll spend more
236 236 time re-flushing a too small cache than working
237 237 """
238 238 )
239 239 color_info = CBool(True, config=True, help=
240 240 """
241 241 Use colors for displaying information about objects. Because this
242 242 information is passed through a pager (like 'less'), and some pagers
243 243 get confused with color codes, this capability can be turned off.
244 244 """
245 245 )
246 246 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
247 247 default_value=get_default_colors(), config=True,
248 248 help="Set the color scheme (NoColor, Linux, or LightBG)."
249 249 )
250 250 colors_force = CBool(False, help=
251 251 """
252 252 Force use of ANSI color codes, regardless of OS and readline
253 253 availability.
254 254 """
255 255 # FIXME: This is essentially a hack to allow ZMQShell to show colors
256 256 # without readline on Win32. When the ZMQ formatting system is
257 257 # refactored, this should be removed.
258 258 )
259 259 debug = CBool(False, config=True)
260 260 deep_reload = CBool(False, config=True, help=
261 261 """
262 262 Enable deep (recursive) reloading by default. IPython can use the
263 263 deep_reload module which reloads changes in modules recursively (it
264 264 replaces the reload() function, so you don't need to change anything to
265 265 use it). deep_reload() forces a full reload of modules whose code may
266 266 have changed, which the default reload() function does not. When
267 267 deep_reload is off, IPython will use the normal reload(), but
268 268 deep_reload will still be available as dreload().
269 269 """
270 270 )
271 271 display_formatter = Instance(DisplayFormatter)
272 272 displayhook_class = Type(DisplayHook)
273 273 display_pub_class = Type(DisplayPublisher)
274 274
275 275 exit_now = CBool(False)
276 276 exiter = Instance(ExitAutocall)
277 277 def _exiter_default(self):
278 278 return ExitAutocall(self)
279 279 # Monotonically increasing execution counter
280 280 execution_count = Int(1)
281 281 filename = Unicode("<ipython console>")
282 282 ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
283 283
284 284 # Input splitter, to split entire cells of input into either individual
285 285 # interactive statements or whole blocks.
286 286 input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
287 287 (), {})
288 288 logstart = CBool(False, config=True, help=
289 289 """
290 290 Start logging to the default log file.
291 291 """
292 292 )
293 293 logfile = Unicode('', config=True, help=
294 294 """
295 295 The name of the logfile to use.
296 296 """
297 297 )
298 298 logappend = Unicode('', config=True, help=
299 299 """
300 300 Start logging to the given file in append mode.
301 301 """
302 302 )
303 303 object_info_string_level = Enum((0,1,2), default_value=0,
304 304 config=True)
305 305 pdb = CBool(False, config=True, help=
306 306 """
307 307 Automatically call the pdb debugger after every exception.
308 308 """
309 309 )
310 310 multiline_history = CBool(True, config=True,
311 311 help="Store multiple line spanning cells as a single entry in history."
312 312 )
313 313
314 314 prompt_in1 = Unicode('In [\\#]: ', config=True)
315 315 prompt_in2 = Unicode(' .\\D.: ', config=True)
316 316 prompt_out = Unicode('Out[\\#]: ', config=True)
317 317 prompts_pad_left = CBool(True, config=True)
318 318 quiet = CBool(False, config=True)
319 319
320 320 history_length = Int(10000, config=True)
321 321
322 322 # The readline stuff will eventually be moved to the terminal subclass
323 323 # but for now, we can't do that as readline is welded in everywhere.
324 324 readline_use = CBool(True, config=True)
325 325 readline_merge_completions = CBool(True, config=True)
326 326 readline_omit__names = Enum((0,1,2), default_value=2, config=True)
327 327 readline_remove_delims = Unicode('-/~', config=True)
328 328 # don't use \M- bindings by default, because they
329 329 # conflict with 8-bit encodings. See gh-58,gh-88
330 330 readline_parse_and_bind = List([
331 331 'tab: complete',
332 332 '"\C-l": clear-screen',
333 333 'set show-all-if-ambiguous on',
334 334 '"\C-o": tab-insert',
335 335 '"\C-r": reverse-search-history',
336 336 '"\C-s": forward-search-history',
337 337 '"\C-p": history-search-backward',
338 338 '"\C-n": history-search-forward',
339 339 '"\e[A": history-search-backward',
340 340 '"\e[B": history-search-forward',
341 341 '"\C-k": kill-line',
342 342 '"\C-u": unix-line-discard',
343 343 ], allow_none=False, config=True)
344 344
345 345 # TODO: this part of prompt management should be moved to the frontends.
346 346 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
347 347 separate_in = SeparateUnicode('\n', config=True)
348 348 separate_out = SeparateUnicode('', config=True)
349 349 separate_out2 = SeparateUnicode('', config=True)
350 350 wildcards_case_sensitive = CBool(True, config=True)
351 351 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
352 352 default_value='Context', config=True)
353 353
354 354 # Subcomponents of InteractiveShell
355 355 alias_manager = Instance('IPython.core.alias.AliasManager')
356 356 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
357 357 builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
358 358 display_trap = Instance('IPython.core.display_trap.DisplayTrap')
359 359 extension_manager = Instance('IPython.core.extensions.ExtensionManager')
360 360 plugin_manager = Instance('IPython.core.plugin.PluginManager')
361 361 payload_manager = Instance('IPython.core.payload.PayloadManager')
362 362 history_manager = Instance('IPython.core.history.HistoryManager')
363 363
364 364 profile_dir = Instance('IPython.core.application.ProfileDir')
365 365 @property
366 366 def profile(self):
367 367 if self.profile_dir is not None:
368 368 name = os.path.basename(self.profile_dir.location)
369 369 return name.replace('profile_','')
370 370
371 371
372 372 # Private interface
373 373 _post_execute = Instance(dict)
374 374
375 375 def __init__(self, config=None, ipython_dir=None, profile_dir=None,
376 376 user_ns=None, user_global_ns=None,
377 377 custom_exceptions=((), None)):
378 378
379 379 # This is where traits with a config_key argument are updated
380 380 # from the values on config.
381 381 super(InteractiveShell, self).__init__(config=config)
382 382
383 383 # These are relatively independent and stateless
384 384 self.init_ipython_dir(ipython_dir)
385 385 self.init_profile_dir(profile_dir)
386 386 self.init_instance_attrs()
387 387 self.init_environment()
388 388
389 389 # Create namespaces (user_ns, user_global_ns, etc.)
390 390 self.init_create_namespaces(user_ns, user_global_ns)
391 391 # This has to be done after init_create_namespaces because it uses
392 392 # something in self.user_ns, but before init_sys_modules, which
393 393 # is the first thing to modify sys.
394 394 # TODO: When we override sys.stdout and sys.stderr before this class
395 395 # is created, we are saving the overridden ones here. Not sure if this
396 396 # is what we want to do.
397 397 self.save_sys_module_state()
398 398 self.init_sys_modules()
399 399
400 400 # While we're trying to have each part of the code directly access what
401 401 # it needs without keeping redundant references to objects, we have too
402 402 # much legacy code that expects ip.db to exist.
403 403 self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
404 404
405 405 self.init_history()
406 406 self.init_encoding()
407 407 self.init_prefilter()
408 408
409 409 Magic.__init__(self, self)
410 410
411 411 self.init_syntax_highlighting()
412 412 self.init_hooks()
413 413 self.init_pushd_popd_magic()
414 414 # self.init_traceback_handlers use to be here, but we moved it below
415 415 # because it and init_io have to come after init_readline.
416 416 self.init_user_ns()
417 417 self.init_logger()
418 418 self.init_alias()
419 419 self.init_builtins()
420 420
421 421 # pre_config_initialization
422 422
423 423 # The next section should contain everything that was in ipmaker.
424 424 self.init_logstart()
425 425
426 426 # The following was in post_config_initialization
427 427 self.init_inspector()
428 428 # init_readline() must come before init_io(), because init_io uses
429 429 # readline related things.
430 430 self.init_readline()
431 431 # We save this here in case user code replaces raw_input, but it needs
432 432 # to be after init_readline(), because PyPy's readline works by replacing
433 433 # raw_input.
434 434 if py3compat.PY3:
435 435 self.raw_input_original = input
436 436 else:
437 437 self.raw_input_original = raw_input
438 438 # init_completer must come after init_readline, because it needs to
439 439 # know whether readline is present or not system-wide to configure the
440 440 # completers, since the completion machinery can now operate
441 441 # independently of readline (e.g. over the network)
442 442 self.init_completer()
443 443 # TODO: init_io() needs to happen before init_traceback handlers
444 444 # because the traceback handlers hardcode the stdout/stderr streams.
445 445 # This logic in in debugger.Pdb and should eventually be changed.
446 446 self.init_io()
447 447 self.init_traceback_handlers(custom_exceptions)
448 448 self.init_prompts()
449 449 self.init_display_formatter()
450 450 self.init_display_pub()
451 451 self.init_displayhook()
452 452 self.init_reload_doctest()
453 453 self.init_magics()
454 454 self.init_pdb()
455 455 self.init_extension_manager()
456 456 self.init_plugin_manager()
457 457 self.init_payload()
458 458 self.hooks.late_startup_hook()
459 459 atexit.register(self.atexit_operations)
460 460
461 461 def get_ipython(self):
462 462 """Return the currently running IPython instance."""
463 463 return self
464 464
465 465 #-------------------------------------------------------------------------
466 466 # Trait changed handlers
467 467 #-------------------------------------------------------------------------
468 468
469 469 def _ipython_dir_changed(self, name, new):
470 470 if not os.path.isdir(new):
471 471 os.makedirs(new, mode = 0777)
472 472
473 473 def set_autoindent(self,value=None):
474 474 """Set the autoindent flag, checking for readline support.
475 475
476 476 If called with no arguments, it acts as a toggle."""
477 477
478 478 if value != 0 and not self.has_readline:
479 479 if os.name == 'posix':
480 480 warn("The auto-indent feature requires the readline library")
481 481 self.autoindent = 0
482 482 return
483 483 if value is None:
484 484 self.autoindent = not self.autoindent
485 485 else:
486 486 self.autoindent = value
487 487
488 488 #-------------------------------------------------------------------------
489 489 # init_* methods called by __init__
490 490 #-------------------------------------------------------------------------
491 491
492 492 def init_ipython_dir(self, ipython_dir):
493 493 if ipython_dir is not None:
494 494 self.ipython_dir = ipython_dir
495 495 return
496 496
497 497 self.ipython_dir = get_ipython_dir()
498 498
499 499 def init_profile_dir(self, profile_dir):
500 500 if profile_dir is not None:
501 501 self.profile_dir = profile_dir
502 502 return
503 503 self.profile_dir =\
504 504 ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')
505 505
506 506 def init_instance_attrs(self):
507 507 self.more = False
508 508
509 509 # command compiler
510 510 self.compile = CachingCompiler()
511 511
512 512 # Make an empty namespace, which extension writers can rely on both
513 513 # existing and NEVER being used by ipython itself. This gives them a
514 514 # convenient location for storing additional information and state
515 515 # their extensions may require, without fear of collisions with other
516 516 # ipython names that may develop later.
517 517 self.meta = Struct()
518 518
519 519 # Temporary files used for various purposes. Deleted at exit.
520 520 self.tempfiles = []
521 521
522 522 # Keep track of readline usage (later set by init_readline)
523 523 self.has_readline = False
524 524
525 525 # keep track of where we started running (mainly for crash post-mortem)
526 526 # This is not being used anywhere currently.
527 527 self.starting_dir = os.getcwdu()
528 528
529 529 # Indentation management
530 530 self.indent_current_nsp = 0
531 531
532 532 # Dict to track post-execution functions that have been registered
533 533 self._post_execute = {}
534 534
535 535 def init_environment(self):
536 536 """Any changes we need to make to the user's environment."""
537 537 pass
538 538
539 539 def init_encoding(self):
540 540 # Get system encoding at startup time. Certain terminals (like Emacs
541 541 # under Win32 have it set to None, and we need to have a known valid
542 542 # encoding to use in the raw_input() method
543 543 try:
544 544 self.stdin_encoding = sys.stdin.encoding or 'ascii'
545 545 except AttributeError:
546 546 self.stdin_encoding = 'ascii'
547 547
548 548 def init_syntax_highlighting(self):
549 549 # Python source parser/formatter for syntax highlighting
550 550 pyformat = PyColorize.Parser().format
551 551 self.pycolorize = lambda src: pyformat(src,'str',self.colors)
552 552
553 553 def init_pushd_popd_magic(self):
554 554 # for pushd/popd management
555 555 try:
556 556 self.home_dir = get_home_dir()
557 557 except HomeDirError, msg:
558 558 fatal(msg)
559 559
560 560 self.dir_stack = []
561 561
562 562 def init_logger(self):
563 563 self.logger = Logger(self.home_dir, logfname='ipython_log.py',
564 564 logmode='rotate')
565 565
566 566 def init_logstart(self):
567 567 """Initialize logging in case it was requested at the command line.
568 568 """
569 569 if self.logappend:
570 570 self.magic_logstart(self.logappend + ' append')
571 571 elif self.logfile:
572 572 self.magic_logstart(self.logfile)
573 573 elif self.logstart:
574 574 self.magic_logstart()
575 575
576 576 def init_builtins(self):
577 577 self.builtin_trap = BuiltinTrap(shell=self)
578 578
579 579 def init_inspector(self):
580 580 # Object inspector
581 581 self.inspector = oinspect.Inspector(oinspect.InspectColors,
582 582 PyColorize.ANSICodeColors,
583 583 'NoColor',
584 584 self.object_info_string_level)
585 585
586 586 def init_io(self):
587 587 # This will just use sys.stdout and sys.stderr. If you want to
588 588 # override sys.stdout and sys.stderr themselves, you need to do that
589 589 # *before* instantiating this class, because io holds onto
590 590 # references to the underlying streams.
591 591 if sys.platform == 'win32' and self.has_readline:
592 592 io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
593 593 else:
594 594 io.stdout = io.IOStream(sys.stdout)
595 595 io.stderr = io.IOStream(sys.stderr)
596 596
597 597 def init_prompts(self):
598 598 # TODO: This is a pass for now because the prompts are managed inside
599 599 # the DisplayHook. Once there is a separate prompt manager, this
600 600 # will initialize that object and all prompt related information.
601 601 pass
602 602
603 603 def init_display_formatter(self):
604 604 self.display_formatter = DisplayFormatter(config=self.config)
605 605
606 606 def init_display_pub(self):
607 607 self.display_pub = self.display_pub_class(config=self.config)
608 608
609 609 def init_displayhook(self):
610 610 # Initialize displayhook, set in/out prompts and printing system
611 611 self.displayhook = self.displayhook_class(
612 612 config=self.config,
613 613 shell=self,
614 614 cache_size=self.cache_size,
615 615 input_sep = self.separate_in,
616 616 output_sep = self.separate_out,
617 617 output_sep2 = self.separate_out2,
618 618 ps1 = self.prompt_in1,
619 619 ps2 = self.prompt_in2,
620 620 ps_out = self.prompt_out,
621 621 pad_left = self.prompts_pad_left
622 622 )
623 623 # This is a context manager that installs/revmoes the displayhook at
624 624 # the appropriate time.
625 625 self.display_trap = DisplayTrap(hook=self.displayhook)
626 626
627 627 def init_reload_doctest(self):
628 628 # Do a proper resetting of doctest, including the necessary displayhook
629 629 # monkeypatching
630 630 try:
631 631 doctest_reload()
632 632 except ImportError:
633 633 warn("doctest module does not exist.")
634 634
635 635 #-------------------------------------------------------------------------
636 636 # Things related to injections into the sys module
637 637 #-------------------------------------------------------------------------
638 638
639 639 def save_sys_module_state(self):
640 640 """Save the state of hooks in the sys module.
641 641
642 642 This has to be called after self.user_ns is created.
643 643 """
644 644 self._orig_sys_module_state = {}
645 645 self._orig_sys_module_state['stdin'] = sys.stdin
646 646 self._orig_sys_module_state['stdout'] = sys.stdout
647 647 self._orig_sys_module_state['stderr'] = sys.stderr
648 648 self._orig_sys_module_state['excepthook'] = sys.excepthook
649 649 try:
650 650 self._orig_sys_modules_main_name = self.user_ns['__name__']
651 651 except KeyError:
652 652 pass
653 653
654 654 def restore_sys_module_state(self):
655 655 """Restore the state of the sys module."""
656 656 try:
657 657 for k, v in self._orig_sys_module_state.iteritems():
658 658 setattr(sys, k, v)
659 659 except AttributeError:
660 660 pass
661 661 # Reset what what done in self.init_sys_modules
662 662 try:
663 663 sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
664 664 except (AttributeError, KeyError):
665 665 pass
666 666
667 667 #-------------------------------------------------------------------------
668 668 # Things related to hooks
669 669 #-------------------------------------------------------------------------
670 670
671 671 def init_hooks(self):
672 672 # hooks holds pointers used for user-side customizations
673 673 self.hooks = Struct()
674 674
675 675 self.strdispatchers = {}
676 676
677 677 # Set all default hooks, defined in the IPython.hooks module.
678 678 hooks = IPython.core.hooks
679 679 for hook_name in hooks.__all__:
680 680 # default hooks have priority 100, i.e. low; user hooks should have
681 681 # 0-100 priority
682 682 self.set_hook(hook_name,getattr(hooks,hook_name), 100)
683 683
684 684 def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
685 685 """set_hook(name,hook) -> sets an internal IPython hook.
686 686
687 687 IPython exposes some of its internal API as user-modifiable hooks. By
688 688 adding your function to one of these hooks, you can modify IPython's
689 689 behavior to call at runtime your own routines."""
690 690
691 691 # At some point in the future, this should validate the hook before it
692 692 # accepts it. Probably at least check that the hook takes the number
693 693 # of args it's supposed to.
694 694
695 695 f = types.MethodType(hook,self)
696 696
697 697 # check if the hook is for strdispatcher first
698 698 if str_key is not None:
699 699 sdp = self.strdispatchers.get(name, StrDispatch())
700 700 sdp.add_s(str_key, f, priority )
701 701 self.strdispatchers[name] = sdp
702 702 return
703 703 if re_key is not None:
704 704 sdp = self.strdispatchers.get(name, StrDispatch())
705 705 sdp.add_re(re.compile(re_key), f, priority )
706 706 self.strdispatchers[name] = sdp
707 707 return
708 708
709 709 dp = getattr(self.hooks, name, None)
710 710 if name not in IPython.core.hooks.__all__:
711 711 print "Warning! Hook '%s' is not one of %s" % \
712 712 (name, IPython.core.hooks.__all__ )
713 713 if not dp:
714 714 dp = IPython.core.hooks.CommandChainDispatcher()
715 715
716 716 try:
717 717 dp.add(f,priority)
718 718 except AttributeError:
719 719 # it was not commandchain, plain old func - replace
720 720 dp = f
721 721
722 722 setattr(self.hooks,name, dp)
723 723
724 724 def register_post_execute(self, func):
725 725 """Register a function for calling after code execution.
726 726 """
727 727 if not callable(func):
728 728 raise ValueError('argument %s must be callable' % func)
729 729 self._post_execute[func] = True
730 730
731 731 #-------------------------------------------------------------------------
732 732 # Things related to the "main" module
733 733 #-------------------------------------------------------------------------
734 734
735 735 def new_main_mod(self,ns=None):
736 736 """Return a new 'main' module object for user code execution.
737 737 """
738 738 main_mod = self._user_main_module
739 739 init_fakemod_dict(main_mod,ns)
740 740 return main_mod
741 741
742 742 def cache_main_mod(self,ns,fname):
743 743 """Cache a main module's namespace.
744 744
745 745 When scripts are executed via %run, we must keep a reference to the
746 746 namespace of their __main__ module (a FakeModule instance) around so
747 747 that Python doesn't clear it, rendering objects defined therein
748 748 useless.
749 749
750 750 This method keeps said reference in a private dict, keyed by the
751 751 absolute path of the module object (which corresponds to the script
752 752 path). This way, for multiple executions of the same script we only
753 753 keep one copy of the namespace (the last one), thus preventing memory
754 754 leaks from old references while allowing the objects from the last
755 755 execution to be accessible.
756 756
757 757 Note: we can not allow the actual FakeModule instances to be deleted,
758 758 because of how Python tears down modules (it hard-sets all their
759 759 references to None without regard for reference counts). This method
760 760 must therefore make a *copy* of the given namespace, to allow the
761 761 original module's __dict__ to be cleared and reused.
762 762
763 763
764 764 Parameters
765 765 ----------
766 766 ns : a namespace (a dict, typically)
767 767
768 768 fname : str
769 769 Filename associated with the namespace.
770 770
771 771 Examples
772 772 --------
773 773
774 774 In [10]: import IPython
775 775
776 776 In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
777 777
778 778 In [12]: IPython.__file__ in _ip._main_ns_cache
779 779 Out[12]: True
780 780 """
781 781 self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
782 782
783 783 def clear_main_mod_cache(self):
784 784 """Clear the cache of main modules.
785 785
786 786 Mainly for use by utilities like %reset.
787 787
788 788 Examples
789 789 --------
790 790
791 791 In [15]: import IPython
792 792
793 793 In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
794 794
795 795 In [17]: len(_ip._main_ns_cache) > 0
796 796 Out[17]: True
797 797
798 798 In [18]: _ip.clear_main_mod_cache()
799 799
800 800 In [19]: len(_ip._main_ns_cache) == 0
801 801 Out[19]: True
802 802 """
803 803 self._main_ns_cache.clear()
804 804
805 805 #-------------------------------------------------------------------------
806 806 # Things related to debugging
807 807 #-------------------------------------------------------------------------
808 808
809 809 def init_pdb(self):
810 810 # Set calling of pdb on exceptions
811 811 # self.call_pdb is a property
812 812 self.call_pdb = self.pdb
813 813
814 814 def _get_call_pdb(self):
815 815 return self._call_pdb
816 816
817 817 def _set_call_pdb(self,val):
818 818
819 819 if val not in (0,1,False,True):
820 820 raise ValueError,'new call_pdb value must be boolean'
821 821
822 822 # store value in instance
823 823 self._call_pdb = val
824 824
825 825 # notify the actual exception handlers
826 826 self.InteractiveTB.call_pdb = val
827 827
828 828 call_pdb = property(_get_call_pdb,_set_call_pdb,None,
829 829 'Control auto-activation of pdb at exceptions')
830 830
831 831 def debugger(self,force=False):
832 832 """Call the pydb/pdb debugger.
833 833
834 834 Keywords:
835 835
836 836 - force(False): by default, this routine checks the instance call_pdb
837 837 flag and does not actually invoke the debugger if the flag is false.
838 838 The 'force' option forces the debugger to activate even if the flag
839 839 is false.
840 840 """
841 841
842 842 if not (force or self.call_pdb):
843 843 return
844 844
845 845 if not hasattr(sys,'last_traceback'):
846 846 error('No traceback has been produced, nothing to debug.')
847 847 return
848 848
849 849 # use pydb if available
850 850 if debugger.has_pydb:
851 851 from pydb import pm
852 852 else:
853 853 # fallback to our internal debugger
854 854 pm = lambda : self.InteractiveTB.debugger(force=True)
855 855
856 856 with self.readline_no_record:
857 857 pm()
858 858
859 859 #-------------------------------------------------------------------------
860 860 # Things related to IPython's various namespaces
861 861 #-------------------------------------------------------------------------
862 862
863 863 def init_create_namespaces(self, user_ns=None, user_global_ns=None):
864 864 # Create the namespace where the user will operate. user_ns is
865 865 # normally the only one used, and it is passed to the exec calls as
866 866 # the locals argument. But we do carry a user_global_ns namespace
867 867 # given as the exec 'globals' argument, This is useful in embedding
868 868 # situations where the ipython shell opens in a context where the
869 869 # distinction between locals and globals is meaningful. For
870 870 # non-embedded contexts, it is just the same object as the user_ns dict.
871 871
872 872 # FIXME. For some strange reason, __builtins__ is showing up at user
873 873 # level as a dict instead of a module. This is a manual fix, but I
874 874 # should really track down where the problem is coming from. Alex
875 875 # Schmolck reported this problem first.
876 876
877 877 # A useful post by Alex Martelli on this topic:
878 878 # Re: inconsistent value from __builtins__
879 879 # Von: Alex Martelli <aleaxit@yahoo.com>
880 880 # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
881 881 # Gruppen: comp.lang.python
882 882
883 883 # Michael Hohn <hohn@hooknose.lbl.gov> wrote:
884 884 # > >>> print type(builtin_check.get_global_binding('__builtins__'))
885 885 # > <type 'dict'>
886 886 # > >>> print type(__builtins__)
887 887 # > <type 'module'>
888 888 # > Is this difference in return value intentional?
889 889
890 890 # Well, it's documented that '__builtins__' can be either a dictionary
891 891 # or a module, and it's been that way for a long time. Whether it's
892 892 # intentional (or sensible), I don't know. In any case, the idea is
893 893 # that if you need to access the built-in namespace directly, you
894 894 # should start with "import __builtin__" (note, no 's') which will
895 895 # definitely give you a module. Yeah, it's somewhat confusing:-(.
896 896
897 897 # These routines return properly built dicts as needed by the rest of
898 898 # the code, and can also be used by extension writers to generate
899 899 # properly initialized namespaces.
900 900 user_ns, user_global_ns = self.make_user_namespaces(user_ns,
901 901 user_global_ns)
902 902
903 903 # Assign namespaces
904 904 # This is the namespace where all normal user variables live
905 905 self.user_ns = user_ns
906 906 self.user_global_ns = user_global_ns
907 907
908 908 # An auxiliary namespace that checks what parts of the user_ns were
909 909 # loaded at startup, so we can list later only variables defined in
910 910 # actual interactive use. Since it is always a subset of user_ns, it
911 911 # doesn't need to be separately tracked in the ns_table.
912 912 self.user_ns_hidden = {}
913 913
914 914 # A namespace to keep track of internal data structures to prevent
915 915 # them from cluttering user-visible stuff. Will be updated later
916 916 self.internal_ns = {}
917 917
918 918 # Now that FakeModule produces a real module, we've run into a nasty
919 919 # problem: after script execution (via %run), the module where the user
920 920 # code ran is deleted. Now that this object is a true module (needed
921 921 # so docetst and other tools work correctly), the Python module
922 922 # teardown mechanism runs over it, and sets to None every variable
923 923 # present in that module. Top-level references to objects from the
924 924 # script survive, because the user_ns is updated with them. However,
925 925 # calling functions defined in the script that use other things from
926 926 # the script will fail, because the function's closure had references
927 927 # to the original objects, which are now all None. So we must protect
928 928 # these modules from deletion by keeping a cache.
929 929 #
930 930 # To avoid keeping stale modules around (we only need the one from the
931 931 # last run), we use a dict keyed with the full path to the script, so
932 932 # only the last version of the module is held in the cache. Note,
933 933 # however, that we must cache the module *namespace contents* (their
934 934 # __dict__). Because if we try to cache the actual modules, old ones
935 935 # (uncached) could be destroyed while still holding references (such as
936 936 # those held by GUI objects that tend to be long-lived)>
937 937 #
938 938 # The %reset command will flush this cache. See the cache_main_mod()
939 939 # and clear_main_mod_cache() methods for details on use.
940 940
941 941 # This is the cache used for 'main' namespaces
942 942 self._main_ns_cache = {}
943 943 # And this is the single instance of FakeModule whose __dict__ we keep
944 944 # copying and clearing for reuse on each %run
945 945 self._user_main_module = FakeModule()
946 946
947 947 # A table holding all the namespaces IPython deals with, so that
948 948 # introspection facilities can search easily.
949 949 self.ns_table = {'user':user_ns,
950 950 'user_global':user_global_ns,
951 951 'internal':self.internal_ns,
952 952 'builtin':builtin_mod.__dict__
953 953 }
954 954
955 955 # Similarly, track all namespaces where references can be held and that
956 956 # we can safely clear (so it can NOT include builtin). This one can be
957 957 # a simple list. Note that the main execution namespaces, user_ns and
958 958 # user_global_ns, can NOT be listed here, as clearing them blindly
959 959 # causes errors in object __del__ methods. Instead, the reset() method
960 960 # clears them manually and carefully.
961 961 self.ns_refs_table = [ self.user_ns_hidden,
962 962 self.internal_ns, self._main_ns_cache ]
963 963
964 964 def make_user_namespaces(self, user_ns=None, user_global_ns=None):
965 965 """Return a valid local and global user interactive namespaces.
966 966
967 967 This builds a dict with the minimal information needed to operate as a
968 968 valid IPython user namespace, which you can pass to the various
969 969 embedding classes in ipython. The default implementation returns the
970 970 same dict for both the locals and the globals to allow functions to
971 971 refer to variables in the namespace. Customized implementations can
972 972 return different dicts. The locals dictionary can actually be anything
973 973 following the basic mapping protocol of a dict, but the globals dict
974 974 must be a true dict, not even a subclass. It is recommended that any
975 975 custom object for the locals namespace synchronize with the globals
976 976 dict somehow.
977 977
978 978 Raises TypeError if the provided globals namespace is not a true dict.
979 979
980 980 Parameters
981 981 ----------
982 982 user_ns : dict-like, optional
983 983 The current user namespace. The items in this namespace should
984 984 be included in the output. If None, an appropriate blank
985 985 namespace should be created.
986 986 user_global_ns : dict, optional
987 987 The current user global namespace. The items in this namespace
988 988 should be included in the output. If None, an appropriate
989 989 blank namespace should be created.
990 990
991 991 Returns
992 992 -------
993 993 A pair of dictionary-like object to be used as the local namespace
994 994 of the interpreter and a dict to be used as the global namespace.
995 995 """
996 996
997 997
998 998 # We must ensure that __builtin__ (without the final 's') is always
999 999 # available and pointing to the __builtin__ *module*. For more details:
1000 1000 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1001 1001
1002 1002 if user_ns is None:
1003 1003 # Set __name__ to __main__ to better match the behavior of the
1004 1004 # normal interpreter.
1005 1005 user_ns = {'__name__' :'__main__',
1006 1006 py3compat.builtin_mod_name: builtin_mod,
1007 1007 '__builtins__' : builtin_mod,
1008 1008 }
1009 1009 else:
1010 1010 user_ns.setdefault('__name__','__main__')
1011 1011 user_ns.setdefault(py3compat.builtin_mod_name,builtin_mod)
1012 1012 user_ns.setdefault('__builtins__',builtin_mod)
1013 1013
1014 1014 if user_global_ns is None:
1015 1015 user_global_ns = user_ns
1016 1016 if type(user_global_ns) is not dict:
1017 1017 raise TypeError("user_global_ns must be a true dict; got %r"
1018 1018 % type(user_global_ns))
1019 1019
1020 1020 return user_ns, user_global_ns
1021 1021
1022 1022 def init_sys_modules(self):
1023 1023 # We need to insert into sys.modules something that looks like a
1024 1024 # module but which accesses the IPython namespace, for shelve and
1025 1025 # pickle to work interactively. Normally they rely on getting
1026 1026 # everything out of __main__, but for embedding purposes each IPython
1027 1027 # instance has its own private namespace, so we can't go shoving
1028 1028 # everything into __main__.
1029 1029
1030 1030 # note, however, that we should only do this for non-embedded
1031 1031 # ipythons, which really mimic the __main__.__dict__ with their own
1032 1032 # namespace. Embedded instances, on the other hand, should not do
1033 1033 # this because they need to manage the user local/global namespaces
1034 1034 # only, but they live within a 'normal' __main__ (meaning, they
1035 1035 # shouldn't overtake the execution environment of the script they're
1036 1036 # embedded in).
1037 1037
1038 1038 # This is overridden in the InteractiveShellEmbed subclass to a no-op.
1039 1039
1040 1040 try:
1041 1041 main_name = self.user_ns['__name__']
1042 1042 except KeyError:
1043 1043 raise KeyError('user_ns dictionary MUST have a "__name__" key')
1044 1044 else:
1045 1045 sys.modules[main_name] = FakeModule(self.user_ns)
1046 1046
1047 1047 def init_user_ns(self):
1048 1048 """Initialize all user-visible namespaces to their minimum defaults.
1049 1049
1050 1050 Certain history lists are also initialized here, as they effectively
1051 1051 act as user namespaces.
1052 1052
1053 1053 Notes
1054 1054 -----
1055 1055 All data structures here are only filled in, they are NOT reset by this
1056 1056 method. If they were not empty before, data will simply be added to
1057 1057 therm.
1058 1058 """
1059 1059 # This function works in two parts: first we put a few things in
1060 1060 # user_ns, and we sync that contents into user_ns_hidden so that these
1061 1061 # initial variables aren't shown by %who. After the sync, we add the
1062 1062 # rest of what we *do* want the user to see with %who even on a new
1063 1063 # session (probably nothing, so theye really only see their own stuff)
1064 1064
1065 1065 # The user dict must *always* have a __builtin__ reference to the
1066 1066 # Python standard __builtin__ namespace, which must be imported.
1067 1067 # This is so that certain operations in prompt evaluation can be
1068 1068 # reliably executed with builtins. Note that we can NOT use
1069 1069 # __builtins__ (note the 's'), because that can either be a dict or a
1070 1070 # module, and can even mutate at runtime, depending on the context
1071 1071 # (Python makes no guarantees on it). In contrast, __builtin__ is
1072 1072 # always a module object, though it must be explicitly imported.
1073 1073
1074 1074 # For more details:
1075 1075 # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
1076 1076 ns = dict(__builtin__ = builtin_mod)
1077 1077
1078 1078 # Put 'help' in the user namespace
1079 1079 try:
1080 1080 from site import _Helper
1081 1081 ns['help'] = _Helper()
1082 1082 except ImportError:
1083 1083 warn('help() not available - check site.py')
1084 1084
1085 1085 # make global variables for user access to the histories
1086 1086 ns['_ih'] = self.history_manager.input_hist_parsed
1087 1087 ns['_oh'] = self.history_manager.output_hist
1088 1088 ns['_dh'] = self.history_manager.dir_hist
1089 1089
1090 1090 ns['_sh'] = shadowns
1091 1091
1092 1092 # user aliases to input and output histories. These shouldn't show up
1093 1093 # in %who, as they can have very large reprs.
1094 1094 ns['In'] = self.history_manager.input_hist_parsed
1095 1095 ns['Out'] = self.history_manager.output_hist
1096 1096
1097 1097 # Store myself as the public api!!!
1098 1098 ns['get_ipython'] = self.get_ipython
1099 1099
1100 1100 ns['exit'] = self.exiter
1101 1101 ns['quit'] = self.exiter
1102 1102
1103 1103 # Sync what we've added so far to user_ns_hidden so these aren't seen
1104 1104 # by %who
1105 1105 self.user_ns_hidden.update(ns)
1106 1106
1107 1107 # Anything put into ns now would show up in %who. Think twice before
1108 1108 # putting anything here, as we really want %who to show the user their
1109 1109 # stuff, not our variables.
1110 1110
1111 1111 # Finally, update the real user's namespace
1112 1112 self.user_ns.update(ns)
1113 1113
1114 1114 def reset(self, new_session=True):
1115 1115 """Clear all internal namespaces, and attempt to release references to
1116 1116 user objects.
1117 1117
1118 1118 If new_session is True, a new history session will be opened.
1119 1119 """
1120 1120 # Clear histories
1121 1121 self.history_manager.reset(new_session)
1122 1122 # Reset counter used to index all histories
1123 1123 if new_session:
1124 1124 self.execution_count = 1
1125 1125
1126 1126 # Flush cached output items
1127 1127 if self.displayhook.do_full_cache:
1128 1128 self.displayhook.flush()
1129 1129
1130 1130 # Restore the user namespaces to minimal usability
1131 1131 for ns in self.ns_refs_table:
1132 1132 ns.clear()
1133 1133
1134 1134 # The main execution namespaces must be cleared very carefully,
1135 1135 # skipping the deletion of the builtin-related keys, because doing so
1136 1136 # would cause errors in many object's __del__ methods.
1137 1137 for ns in [self.user_ns, self.user_global_ns]:
1138 1138 drop_keys = set(ns.keys())
1139 1139 drop_keys.discard('__builtin__')
1140 1140 drop_keys.discard('__builtins__')
1141 1141 for k in drop_keys:
1142 1142 del ns[k]
1143 1143
1144 1144 # Restore the user namespaces to minimal usability
1145 1145 self.init_user_ns()
1146 1146
1147 1147 # Restore the default and user aliases
1148 1148 self.alias_manager.clear_aliases()
1149 1149 self.alias_manager.init_aliases()
1150 1150
1151 1151 # Flush the private list of module references kept for script
1152 1152 # execution protection
1153 1153 self.clear_main_mod_cache()
1154 1154
1155 1155 # Clear out the namespace from the last %run
1156 1156 self.new_main_mod()
1157 1157
1158 1158 def del_var(self, varname, by_name=False):
1159 1159 """Delete a variable from the various namespaces, so that, as
1160 1160 far as possible, we're not keeping any hidden references to it.
1161 1161
1162 1162 Parameters
1163 1163 ----------
1164 1164 varname : str
1165 1165 The name of the variable to delete.
1166 1166 by_name : bool
1167 1167 If True, delete variables with the given name in each
1168 1168 namespace. If False (default), find the variable in the user
1169 1169 namespace, and delete references to it.
1170 1170 """
1171 1171 if varname in ('__builtin__', '__builtins__'):
1172 1172 raise ValueError("Refusing to delete %s" % varname)
1173 1173 ns_refs = self.ns_refs_table + [self.user_ns,
1174 1174 self.user_global_ns, self._user_main_module.__dict__] +\
1175 1175 self._main_ns_cache.values()
1176 1176
1177 1177 if by_name: # Delete by name
1178 1178 for ns in ns_refs:
1179 1179 try:
1180 1180 del ns[varname]
1181 1181 except KeyError:
1182 1182 pass
1183 1183 else: # Delete by object
1184 1184 try:
1185 1185 obj = self.user_ns[varname]
1186 1186 except KeyError:
1187 1187 raise NameError("name '%s' is not defined" % varname)
1188 1188 # Also check in output history
1189 1189 ns_refs.append(self.history_manager.output_hist)
1190 1190 for ns in ns_refs:
1191 1191 to_delete = [n for n, o in ns.iteritems() if o is obj]
1192 1192 for name in to_delete:
1193 1193 del ns[name]
1194 1194
1195 1195 # displayhook keeps extra references, but not in a dictionary
1196 1196 for name in ('_', '__', '___'):
1197 1197 if getattr(self.displayhook, name) is obj:
1198 1198 setattr(self.displayhook, name, None)
1199 1199
1200 1200 def reset_selective(self, regex=None):
1201 1201 """Clear selective variables from internal namespaces based on a
1202 1202 specified regular expression.
1203 1203
1204 1204 Parameters
1205 1205 ----------
1206 1206 regex : string or compiled pattern, optional
1207 1207 A regular expression pattern that will be used in searching
1208 1208 variable names in the users namespaces.
1209 1209 """
1210 1210 if regex is not None:
1211 1211 try:
1212 1212 m = re.compile(regex)
1213 1213 except TypeError:
1214 1214 raise TypeError('regex must be a string or compiled pattern')
1215 1215 # Search for keys in each namespace that match the given regex
1216 1216 # If a match is found, delete the key/value pair.
1217 1217 for ns in self.ns_refs_table:
1218 1218 for var in ns:
1219 1219 if m.search(var):
1220 1220 del ns[var]
1221 1221
1222 1222 def push(self, variables, interactive=True):
1223 1223 """Inject a group of variables into the IPython user namespace.
1224 1224
1225 1225 Parameters
1226 1226 ----------
1227 1227 variables : dict, str or list/tuple of str
1228 1228 The variables to inject into the user's namespace. If a dict, a
1229 1229 simple update is done. If a str, the string is assumed to have
1230 1230 variable names separated by spaces. A list/tuple of str can also
1231 1231 be used to give the variable names. If just the variable names are
1232 1232 give (list/tuple/str) then the variable values looked up in the
1233 1233 callers frame.
1234 1234 interactive : bool
1235 1235 If True (default), the variables will be listed with the ``who``
1236 1236 magic.
1237 1237 """
1238 1238 vdict = None
1239 1239
1240 1240 # We need a dict of name/value pairs to do namespace updates.
1241 1241 if isinstance(variables, dict):
1242 1242 vdict = variables
1243 1243 elif isinstance(variables, (basestring, list, tuple)):
1244 1244 if isinstance(variables, basestring):
1245 1245 vlist = variables.split()
1246 1246 else:
1247 1247 vlist = variables
1248 1248 vdict = {}
1249 1249 cf = sys._getframe(1)
1250 1250 for name in vlist:
1251 1251 try:
1252 1252 vdict[name] = eval(name, cf.f_globals, cf.f_locals)
1253 1253 except:
1254 1254 print ('Could not get variable %s from %s' %
1255 1255 (name,cf.f_code.co_name))
1256 1256 else:
1257 1257 raise ValueError('variables must be a dict/str/list/tuple')
1258 1258
1259 1259 # Propagate variables to user namespace
1260 1260 self.user_ns.update(vdict)
1261 1261
1262 1262 # And configure interactive visibility
1263 1263 config_ns = self.user_ns_hidden
1264 1264 if interactive:
1265 1265 for name, val in vdict.iteritems():
1266 1266 config_ns.pop(name, None)
1267 1267 else:
1268 1268 for name,val in vdict.iteritems():
1269 1269 config_ns[name] = val
1270 1270
1271 1271 def drop_by_id(self, variables):
1272 1272 """Remove a dict of variables from the user namespace, if they are the
1273 1273 same as the values in the dictionary.
1274 1274
1275 1275 This is intended for use by extensions: variables that they've added can
1276 1276 be taken back out if they are unloaded, without removing any that the
1277 1277 user has overwritten.
1278 1278
1279 1279 Parameters
1280 1280 ----------
1281 1281 variables : dict
1282 1282 A dictionary mapping object names (as strings) to the objects.
1283 1283 """
1284 1284 for name, obj in variables.iteritems():
1285 1285 if name in self.user_ns and self.user_ns[name] is obj:
1286 1286 del self.user_ns[name]
1287 1287 self.user_ns_hidden.pop(name, None)
1288 1288
1289 1289 #-------------------------------------------------------------------------
1290 1290 # Things related to object introspection
1291 1291 #-------------------------------------------------------------------------
1292 1292
1293 1293 def _ofind(self, oname, namespaces=None):
1294 1294 """Find an object in the available namespaces.
1295 1295
1296 1296 self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
1297 1297
1298 1298 Has special code to detect magic functions.
1299 1299 """
1300 1300 oname = oname.strip()
1301 1301 #print '1- oname: <%r>' % oname # dbg
1302 1302 if not py3compat.isidentifier(oname.lstrip(ESC_MAGIC), dotted=True):
1303 1303 return dict(found=False)
1304 1304
1305 1305 alias_ns = None
1306 1306 if namespaces is None:
1307 1307 # Namespaces to search in:
1308 1308 # Put them in a list. The order is important so that we
1309 1309 # find things in the same order that Python finds them.
1310 1310 namespaces = [ ('Interactive', self.user_ns),
1311 1311 ('IPython internal', self.internal_ns),
1312 1312 ('Python builtin', builtin_mod.__dict__),
1313 1313 ('Alias', self.alias_manager.alias_table),
1314 1314 ]
1315 1315 alias_ns = self.alias_manager.alias_table
1316 1316
1317 1317 # initialize results to 'null'
1318 1318 found = False; obj = None; ospace = None; ds = None;
1319 1319 ismagic = False; isalias = False; parent = None
1320 1320
1321 1321 # We need to special-case 'print', which as of python2.6 registers as a
1322 1322 # function but should only be treated as one if print_function was
1323 1323 # loaded with a future import. In this case, just bail.
1324 1324 if (oname == 'print' and not py3compat.PY3 and not \
1325 1325 (self.compile.compiler_flags & __future__.CO_FUTURE_PRINT_FUNCTION)):
1326 1326 return {'found':found, 'obj':obj, 'namespace':ospace,
1327 1327 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1328 1328
1329 1329 # Look for the given name by splitting it in parts. If the head is
1330 1330 # found, then we look for all the remaining parts as members, and only
1331 1331 # declare success if we can find them all.
1332 1332 oname_parts = oname.split('.')
1333 1333 oname_head, oname_rest = oname_parts[0],oname_parts[1:]
1334 1334 for nsname,ns in namespaces:
1335 1335 try:
1336 1336 obj = ns[oname_head]
1337 1337 except KeyError:
1338 1338 continue
1339 1339 else:
1340 1340 #print 'oname_rest:', oname_rest # dbg
1341 1341 for part in oname_rest:
1342 1342 try:
1343 1343 parent = obj
1344 1344 obj = getattr(obj,part)
1345 1345 except:
1346 1346 # Blanket except b/c some badly implemented objects
1347 1347 # allow __getattr__ to raise exceptions other than
1348 1348 # AttributeError, which then crashes IPython.
1349 1349 break
1350 1350 else:
1351 1351 # If we finish the for loop (no break), we got all members
1352 1352 found = True
1353 1353 ospace = nsname
1354 1354 if ns == alias_ns:
1355 1355 isalias = True
1356 1356 break # namespace loop
1357 1357
1358 1358 # Try to see if it's magic
1359 1359 if not found:
1360 1360 if oname.startswith(ESC_MAGIC):
1361 1361 oname = oname[1:]
1362 1362 obj = getattr(self,'magic_'+oname,None)
1363 1363 if obj is not None:
1364 1364 found = True
1365 1365 ospace = 'IPython internal'
1366 1366 ismagic = True
1367 1367
1368 1368 # Last try: special-case some literals like '', [], {}, etc:
1369 1369 if not found and oname_head in ["''",'""','[]','{}','()']:
1370 1370 obj = eval(oname_head)
1371 1371 found = True
1372 1372 ospace = 'Interactive'
1373 1373
1374 1374 return {'found':found, 'obj':obj, 'namespace':ospace,
1375 1375 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
1376 1376
1377 1377 def _ofind_property(self, oname, info):
1378 1378 """Second part of object finding, to look for property details."""
1379 1379 if info.found:
1380 1380 # Get the docstring of the class property if it exists.
1381 1381 path = oname.split('.')
1382 1382 root = '.'.join(path[:-1])
1383 1383 if info.parent is not None:
1384 1384 try:
1385 1385 target = getattr(info.parent, '__class__')
1386 1386 # The object belongs to a class instance.
1387 1387 try:
1388 1388 target = getattr(target, path[-1])
1389 1389 # The class defines the object.
1390 1390 if isinstance(target, property):
1391 1391 oname = root + '.__class__.' + path[-1]
1392 1392 info = Struct(self._ofind(oname))
1393 1393 except AttributeError: pass
1394 1394 except AttributeError: pass
1395 1395
1396 1396 # We return either the new info or the unmodified input if the object
1397 1397 # hadn't been found
1398 1398 return info
1399 1399
1400 1400 def _object_find(self, oname, namespaces=None):
1401 1401 """Find an object and return a struct with info about it."""
1402 1402 inf = Struct(self._ofind(oname, namespaces))
1403 1403 return Struct(self._ofind_property(oname, inf))
1404 1404
1405 1405 def _inspect(self, meth, oname, namespaces=None, **kw):
1406 1406 """Generic interface to the inspector system.
1407 1407
1408 1408 This function is meant to be called by pdef, pdoc & friends."""
1409 1409 info = self._object_find(oname)
1410 1410 if info.found:
1411 1411 pmethod = getattr(self.inspector, meth)
1412 1412 formatter = format_screen if info.ismagic else None
1413 1413 if meth == 'pdoc':
1414 1414 pmethod(info.obj, oname, formatter)
1415 1415 elif meth == 'pinfo':
1416 1416 pmethod(info.obj, oname, formatter, info, **kw)
1417 1417 else:
1418 1418 pmethod(info.obj, oname)
1419 1419 else:
1420 1420 print 'Object `%s` not found.' % oname
1421 1421 return 'not found' # so callers can take other action
1422 1422
1423 1423 def object_inspect(self, oname):
1424 1424 with self.builtin_trap:
1425 1425 info = self._object_find(oname)
1426 1426 if info.found:
1427 1427 return self.inspector.info(info.obj, oname, info=info)
1428 1428 else:
1429 1429 return oinspect.object_info(name=oname, found=False)
1430 1430
1431 1431 #-------------------------------------------------------------------------
1432 1432 # Things related to history management
1433 1433 #-------------------------------------------------------------------------
1434 1434
1435 1435 def init_history(self):
1436 1436 """Sets up the command history, and starts regular autosaves."""
1437 1437 self.history_manager = HistoryManager(shell=self, config=self.config)
1438 1438
1439 1439 #-------------------------------------------------------------------------
1440 1440 # Things related to exception handling and tracebacks (not debugging)
1441 1441 #-------------------------------------------------------------------------
1442 1442
1443 1443 def init_traceback_handlers(self, custom_exceptions):
1444 1444 # Syntax error handler.
1445 1445 self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
1446 1446
1447 1447 # The interactive one is initialized with an offset, meaning we always
1448 1448 # want to remove the topmost item in the traceback, which is our own
1449 1449 # internal code. Valid modes: ['Plain','Context','Verbose']
1450 1450 self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
1451 1451 color_scheme='NoColor',
1452 1452 tb_offset = 1,
1453 1453 check_cache=self.compile.check_cache)
1454 1454
1455 1455 # The instance will store a pointer to the system-wide exception hook,
1456 1456 # so that runtime code (such as magics) can access it. This is because
1457 1457 # during the read-eval loop, it may get temporarily overwritten.
1458 1458 self.sys_excepthook = sys.excepthook
1459 1459
1460 1460 # and add any custom exception handlers the user may have specified
1461 1461 self.set_custom_exc(*custom_exceptions)
1462 1462
1463 1463 # Set the exception mode
1464 1464 self.InteractiveTB.set_mode(mode=self.xmode)
1465 1465
1466 1466 def set_custom_exc(self, exc_tuple, handler):
1467 1467 """set_custom_exc(exc_tuple,handler)
1468 1468
1469 1469 Set a custom exception handler, which will be called if any of the
1470 1470 exceptions in exc_tuple occur in the mainloop (specifically, in the
1471 1471 run_code() method).
1472 1472
1473 1473 Parameters
1474 1474 ----------
1475 1475
1476 1476 exc_tuple : tuple of exception classes
1477 1477 A *tuple* of exception classes, for which to call the defined
1478 1478 handler. It is very important that you use a tuple, and NOT A
1479 1479 LIST here, because of the way Python's except statement works. If
1480 1480 you only want to trap a single exception, use a singleton tuple::
1481 1481
1482 1482 exc_tuple == (MyCustomException,)
1483 1483
1484 1484 handler : callable
1485 1485 handler must have the following signature::
1486 1486
1487 1487 def my_handler(self, etype, value, tb, tb_offset=None):
1488 1488 ...
1489 1489 return structured_traceback
1490 1490
1491 1491 Your handler must return a structured traceback (a list of strings),
1492 1492 or None.
1493 1493
1494 1494 This will be made into an instance method (via types.MethodType)
1495 1495 of IPython itself, and it will be called if any of the exceptions
1496 1496 listed in the exc_tuple are caught. If the handler is None, an
1497 1497 internal basic one is used, which just prints basic info.
1498 1498
1499 1499 To protect IPython from crashes, if your handler ever raises an
1500 1500 exception or returns an invalid result, it will be immediately
1501 1501 disabled.
1502 1502
1503 1503 WARNING: by putting in your own exception handler into IPython's main
1504 1504 execution loop, you run a very good chance of nasty crashes. This
1505 1505 facility should only be used if you really know what you are doing."""
1506 1506
1507 1507 assert type(exc_tuple)==type(()) , \
1508 1508 "The custom exceptions must be given AS A TUPLE."
1509 1509
1510 1510 def dummy_handler(self,etype,value,tb,tb_offset=None):
1511 1511 print '*** Simple custom exception handler ***'
1512 1512 print 'Exception type :',etype
1513 1513 print 'Exception value:',value
1514 1514 print 'Traceback :',tb
1515 1515 #print 'Source code :','\n'.join(self.buffer)
1516 1516
1517 1517 def validate_stb(stb):
1518 1518 """validate structured traceback return type
1519 1519
1520 1520 return type of CustomTB *should* be a list of strings, but allow
1521 1521 single strings or None, which are harmless.
1522 1522
1523 1523 This function will *always* return a list of strings,
1524 1524 and will raise a TypeError if stb is inappropriate.
1525 1525 """
1526 1526 msg = "CustomTB must return list of strings, not %r" % stb
1527 1527 if stb is None:
1528 1528 return []
1529 1529 elif isinstance(stb, basestring):
1530 1530 return [stb]
1531 1531 elif not isinstance(stb, list):
1532 1532 raise TypeError(msg)
1533 1533 # it's a list
1534 1534 for line in stb:
1535 1535 # check every element
1536 1536 if not isinstance(line, basestring):
1537 1537 raise TypeError(msg)
1538 1538 return stb
1539 1539
1540 1540 if handler is None:
1541 1541 wrapped = dummy_handler
1542 1542 else:
1543 1543 def wrapped(self,etype,value,tb,tb_offset=None):
1544 1544 """wrap CustomTB handler, to protect IPython from user code
1545 1545
1546 1546 This makes it harder (but not impossible) for custom exception
1547 1547 handlers to crash IPython.
1548 1548 """
1549 1549 try:
1550 1550 stb = handler(self,etype,value,tb,tb_offset=tb_offset)
1551 1551 return validate_stb(stb)
1552 1552 except:
1553 1553 # clear custom handler immediately
1554 1554 self.set_custom_exc((), None)
1555 1555 print >> io.stderr, "Custom TB Handler failed, unregistering"
1556 1556 # show the exception in handler first
1557 1557 stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
1558 1558 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1559 1559 print >> io.stdout, "The original exception:"
1560 1560 stb = self.InteractiveTB.structured_traceback(
1561 1561 (etype,value,tb), tb_offset=tb_offset
1562 1562 )
1563 1563 return stb
1564 1564
1565 1565 self.CustomTB = types.MethodType(wrapped,self)
1566 1566 self.custom_exceptions = exc_tuple
1567 1567
1568 1568 def excepthook(self, etype, value, tb):
1569 1569 """One more defense for GUI apps that call sys.excepthook.
1570 1570
1571 1571 GUI frameworks like wxPython trap exceptions and call
1572 1572 sys.excepthook themselves. I guess this is a feature that
1573 1573 enables them to keep running after exceptions that would
1574 1574 otherwise kill their mainloop. This is a bother for IPython
1575 1575 which excepts to catch all of the program exceptions with a try:
1576 1576 except: statement.
1577 1577
1578 1578 Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
1579 1579 any app directly invokes sys.excepthook, it will look to the user like
1580 1580 IPython crashed. In order to work around this, we can disable the
1581 1581 CrashHandler and replace it with this excepthook instead, which prints a
1582 1582 regular traceback using our InteractiveTB. In this fashion, apps which
1583 1583 call sys.excepthook will generate a regular-looking exception from
1584 1584 IPython, and the CrashHandler will only be triggered by real IPython
1585 1585 crashes.
1586 1586
1587 1587 This hook should be used sparingly, only in places which are not likely
1588 1588 to be true IPython errors.
1589 1589 """
1590 1590 self.showtraceback((etype,value,tb),tb_offset=0)
1591 1591
1592 1592 def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
1593 1593 exception_only=False):
1594 1594 """Display the exception that just occurred.
1595 1595
1596 1596 If nothing is known about the exception, this is the method which
1597 1597 should be used throughout the code for presenting user tracebacks,
1598 1598 rather than directly invoking the InteractiveTB object.
1599 1599
1600 1600 A specific showsyntaxerror() also exists, but this method can take
1601 1601 care of calling it if needed, so unless you are explicitly catching a
1602 1602 SyntaxError exception, don't try to analyze the stack manually and
1603 1603 simply call this method."""
1604 1604
1605 1605 try:
1606 1606 if exc_tuple is None:
1607 1607 etype, value, tb = sys.exc_info()
1608 1608 else:
1609 1609 etype, value, tb = exc_tuple
1610 1610
1611 1611 if etype is None:
1612 1612 if hasattr(sys, 'last_type'):
1613 1613 etype, value, tb = sys.last_type, sys.last_value, \
1614 1614 sys.last_traceback
1615 1615 else:
1616 1616 self.write_err('No traceback available to show.\n')
1617 1617 return
1618 1618
1619 1619 if etype is SyntaxError:
1620 1620 # Though this won't be called by syntax errors in the input
1621 1621 # line, there may be SyntaxError cases with imported code.
1622 1622 self.showsyntaxerror(filename)
1623 1623 elif etype is UsageError:
1624 1624 self.write_err("UsageError: %s" % value)
1625 1625 else:
1626 1626 # WARNING: these variables are somewhat deprecated and not
1627 1627 # necessarily safe to use in a threaded environment, but tools
1628 1628 # like pdb depend on their existence, so let's set them. If we
1629 1629 # find problems in the field, we'll need to revisit their use.
1630 1630 sys.last_type = etype
1631 1631 sys.last_value = value
1632 1632 sys.last_traceback = tb
1633 1633 if etype in self.custom_exceptions:
1634 1634 stb = self.CustomTB(etype, value, tb, tb_offset)
1635 1635 else:
1636 1636 if exception_only:
1637 1637 stb = ['An exception has occurred, use %tb to see '
1638 1638 'the full traceback.\n']
1639 1639 stb.extend(self.InteractiveTB.get_exception_only(etype,
1640 1640 value))
1641 1641 else:
1642 1642 stb = self.InteractiveTB.structured_traceback(etype,
1643 1643 value, tb, tb_offset=tb_offset)
1644 1644
1645 1645 self._showtraceback(etype, value, stb)
1646 1646 if self.call_pdb:
1647 1647 # drop into debugger
1648 1648 self.debugger(force=True)
1649 1649 return
1650 1650
1651 1651 # Actually show the traceback
1652 1652 self._showtraceback(etype, value, stb)
1653 1653
1654 1654 except KeyboardInterrupt:
1655 1655 self.write_err("\nKeyboardInterrupt\n")
1656 1656
1657 1657 def _showtraceback(self, etype, evalue, stb):
1658 1658 """Actually show a traceback.
1659 1659
1660 1660 Subclasses may override this method to put the traceback on a different
1661 1661 place, like a side channel.
1662 1662 """
1663 1663 print >> io.stdout, self.InteractiveTB.stb2text(stb)
1664 1664
1665 1665 def showsyntaxerror(self, filename=None):
1666 1666 """Display the syntax error that just occurred.
1667 1667
1668 1668 This doesn't display a stack trace because there isn't one.
1669 1669
1670 1670 If a filename is given, it is stuffed in the exception instead
1671 1671 of what was there before (because Python's parser always uses
1672 1672 "<string>" when reading from a string).
1673 1673 """
1674 1674 etype, value, last_traceback = sys.exc_info()
1675 1675
1676 1676 # See note about these variables in showtraceback() above
1677 1677 sys.last_type = etype
1678 1678 sys.last_value = value
1679 1679 sys.last_traceback = last_traceback
1680 1680
1681 1681 if filename and etype is SyntaxError:
1682 1682 # Work hard to stuff the correct filename in the exception
1683 1683 try:
1684 1684 msg, (dummy_filename, lineno, offset, line) = value
1685 1685 except:
1686 1686 # Not the format we expect; leave it alone
1687 1687 pass
1688 1688 else:
1689 1689 # Stuff in the right filename
1690 1690 try:
1691 1691 # Assume SyntaxError is a class exception
1692 1692 value = SyntaxError(msg, (filename, lineno, offset, line))
1693 1693 except:
1694 1694 # If that failed, assume SyntaxError is a string
1695 1695 value = msg, (filename, lineno, offset, line)
1696 1696 stb = self.SyntaxTB.structured_traceback(etype, value, [])
1697 1697 self._showtraceback(etype, value, stb)
1698 1698
1699 1699 # This is overridden in TerminalInteractiveShell to show a message about
1700 1700 # the %paste magic.
1701 1701 def showindentationerror(self):
1702 1702 """Called by run_cell when there's an IndentationError in code entered
1703 1703 at the prompt.
1704 1704
1705 1705 This is overridden in TerminalInteractiveShell to show a message about
1706 1706 the %paste magic."""
1707 1707 self.showsyntaxerror()
1708 1708
1709 1709 #-------------------------------------------------------------------------
1710 1710 # Things related to readline
1711 1711 #-------------------------------------------------------------------------
1712 1712
1713 1713 def init_readline(self):
1714 1714 """Command history completion/saving/reloading."""
1715 1715
1716 1716 if self.readline_use:
1717 1717 import IPython.utils.rlineimpl as readline
1718 1718
1719 1719 self.rl_next_input = None
1720 1720 self.rl_do_indent = False
1721 1721
1722 1722 if not self.readline_use or not readline.have_readline:
1723 1723 self.has_readline = False
1724 1724 self.readline = None
1725 1725 # Set a number of methods that depend on readline to be no-op
1726 1726 self.readline_no_record = no_op_context
1727 1727 self.set_readline_completer = no_op
1728 1728 self.set_custom_completer = no_op
1729 1729 self.set_completer_frame = no_op
1730 1730 if self.readline_use:
1731 1731 warn('Readline services not available or not loaded.')
1732 1732 else:
1733 1733 self.has_readline = True
1734 1734 self.readline = readline
1735 1735 sys.modules['readline'] = readline
1736 1736
1737 1737 # Platform-specific configuration
1738 1738 if os.name == 'nt':
1739 1739 # FIXME - check with Frederick to see if we can harmonize
1740 1740 # naming conventions with pyreadline to avoid this
1741 1741 # platform-dependent check
1742 1742 self.readline_startup_hook = readline.set_pre_input_hook
1743 1743 else:
1744 1744 self.readline_startup_hook = readline.set_startup_hook
1745 1745
1746 1746 # Load user's initrc file (readline config)
1747 1747 # Or if libedit is used, load editrc.
1748 1748 inputrc_name = os.environ.get('INPUTRC')
1749 1749 if inputrc_name is None:
1750 1750 home_dir = get_home_dir()
1751 1751 if home_dir is not None:
1752 1752 inputrc_name = '.inputrc'
1753 1753 if readline.uses_libedit:
1754 1754 inputrc_name = '.editrc'
1755 1755 inputrc_name = os.path.join(home_dir, inputrc_name)
1756 1756 if os.path.isfile(inputrc_name):
1757 1757 try:
1758 1758 readline.read_init_file(inputrc_name)
1759 1759 except:
1760 1760 warn('Problems reading readline initialization file <%s>'
1761 1761 % inputrc_name)
1762 1762
1763 1763 # Configure readline according to user's prefs
1764 1764 # This is only done if GNU readline is being used. If libedit
1765 1765 # is being used (as on Leopard) the readline config is
1766 1766 # not run as the syntax for libedit is different.
1767 1767 if not readline.uses_libedit:
1768 1768 for rlcommand in self.readline_parse_and_bind:
1769 1769 #print "loading rl:",rlcommand # dbg
1770 1770 readline.parse_and_bind(rlcommand)
1771 1771
1772 1772 # Remove some chars from the delimiters list. If we encounter
1773 1773 # unicode chars, discard them.
1774 1774 delims = readline.get_completer_delims()
1775 1775 if not py3compat.PY3:
1776 1776 delims = delims.encode("ascii", "ignore")
1777 1777 for d in self.readline_remove_delims:
1778 1778 delims = delims.replace(d, "")
1779 1779 delims = delims.replace(ESC_MAGIC, '')
1780 1780 readline.set_completer_delims(delims)
1781 1781 # otherwise we end up with a monster history after a while:
1782 1782 readline.set_history_length(self.history_length)
1783 1783
1784 1784 self.refill_readline_hist()
1785 1785 self.readline_no_record = ReadlineNoRecord(self)
1786 1786
1787 1787 # Configure auto-indent for all platforms
1788 1788 self.set_autoindent(self.autoindent)
1789 1789
1790 1790 def refill_readline_hist(self):
1791 1791 # Load the last 1000 lines from history
1792 1792 self.readline.clear_history()
1793 1793 stdin_encoding = sys.stdin.encoding or "utf-8"
1794 1794 for _, _, cell in self.history_manager.get_tail(1000,
1795 1795 include_latest=True):
1796 1796 if cell.strip(): # Ignore blank lines
1797 1797 if self.multiline_history:
1798 1798 self.readline.add_history(py3compat.unicode_to_str(cell.rstrip(),
1799 1799 stdin_encoding))
1800 1800 else:
1801 1801 for line in cell.splitlines():
1802 1802 self.readline.add_history(py3compat.unicode_to_str(line,
1803 1803 stdin_encoding))
1804 1804
1805 1805 def set_next_input(self, s):
1806 1806 """ Sets the 'default' input string for the next command line.
1807 1807
1808 1808 Requires readline.
1809 1809
1810 1810 Example:
1811 1811
1812 1812 [D:\ipython]|1> _ip.set_next_input("Hello Word")
1813 1813 [D:\ipython]|2> Hello Word_ # cursor is here
1814 1814 """
1815 1815 if isinstance(s, unicode):
1816 1816 s = s.encode(self.stdin_encoding, 'replace')
1817 1817 self.rl_next_input = s
1818 1818
1819 1819 # Maybe move this to the terminal subclass?
1820 1820 def pre_readline(self):
1821 1821 """readline hook to be used at the start of each line.
1822 1822
1823 1823 Currently it handles auto-indent only."""
1824 1824
1825 1825 if self.rl_do_indent:
1826 1826 self.readline.insert_text(self._indent_current_str())
1827 1827 if self.rl_next_input is not None:
1828 1828 self.readline.insert_text(self.rl_next_input)
1829 1829 self.rl_next_input = None
1830 1830
1831 1831 def _indent_current_str(self):
1832 1832 """return the current level of indentation as a string"""
1833 1833 return self.input_splitter.indent_spaces * ' '
1834 1834
1835 1835 #-------------------------------------------------------------------------
1836 1836 # Things related to text completion
1837 1837 #-------------------------------------------------------------------------
1838 1838
1839 1839 def init_completer(self):
1840 1840 """Initialize the completion machinery.
1841 1841
1842 1842 This creates completion machinery that can be used by client code,
1843 1843 either interactively in-process (typically triggered by the readline
1844 1844 library), programatically (such as in test suites) or out-of-prcess
1845 1845 (typically over the network by remote frontends).
1846 1846 """
1847 1847 from IPython.core.completer import IPCompleter
1848 1848 from IPython.core.completerlib import (module_completer,
1849 1849 magic_run_completer, cd_completer)
1850 1850
1851 1851 self.Completer = IPCompleter(shell=self,
1852 1852 namespace=self.user_ns,
1853 1853 global_namespace=self.user_global_ns,
1854 1854 omit__names=self.readline_omit__names,
1855 1855 alias_table=self.alias_manager.alias_table,
1856 1856 use_readline=self.has_readline,
1857 1857 config=self.config,
1858 1858 )
1859 1859
1860 1860 # Add custom completers to the basic ones built into IPCompleter
1861 1861 sdisp = self.strdispatchers.get('complete_command', StrDispatch())
1862 1862 self.strdispatchers['complete_command'] = sdisp
1863 1863 self.Completer.custom_completers = sdisp
1864 1864
1865 1865 self.set_hook('complete_command', module_completer, str_key = 'import')
1866 1866 self.set_hook('complete_command', module_completer, str_key = 'from')
1867 1867 self.set_hook('complete_command', magic_run_completer, str_key = '%run')
1868 1868 self.set_hook('complete_command', cd_completer, str_key = '%cd')
1869 1869
1870 1870 # Only configure readline if we truly are using readline. IPython can
1871 1871 # do tab-completion over the network, in GUIs, etc, where readline
1872 1872 # itself may be absent
1873 1873 if self.has_readline:
1874 1874 self.set_readline_completer()
1875 1875
1876 1876 def complete(self, text, line=None, cursor_pos=None):
1877 1877 """Return the completed text and a list of completions.
1878 1878
1879 1879 Parameters
1880 1880 ----------
1881 1881
1882 1882 text : string
1883 1883 A string of text to be completed on. It can be given as empty and
1884 1884 instead a line/position pair are given. In this case, the
1885 1885 completer itself will split the line like readline does.
1886 1886
1887 1887 line : string, optional
1888 1888 The complete line that text is part of.
1889 1889
1890 1890 cursor_pos : int, optional
1891 1891 The position of the cursor on the input line.
1892 1892
1893 1893 Returns
1894 1894 -------
1895 1895 text : string
1896 1896 The actual text that was completed.
1897 1897
1898 1898 matches : list
1899 1899 A sorted list with all possible completions.
1900 1900
1901 1901 The optional arguments allow the completion to take more context into
1902 1902 account, and are part of the low-level completion API.
1903 1903
1904 1904 This is a wrapper around the completion mechanism, similar to what
1905 1905 readline does at the command line when the TAB key is hit. By
1906 1906 exposing it as a method, it can be used by other non-readline
1907 1907 environments (such as GUIs) for text completion.
1908 1908
1909 1909 Simple usage example:
1910 1910
1911 1911 In [1]: x = 'hello'
1912 1912
1913 1913 In [2]: _ip.complete('x.l')
1914 1914 Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
1915 1915 """
1916 1916
1917 1917 # Inject names into __builtin__ so we can complete on the added names.
1918 1918 with self.builtin_trap:
1919 1919 return self.Completer.complete(text, line, cursor_pos)
1920 1920
1921 1921 def set_custom_completer(self, completer, pos=0):
1922 1922 """Adds a new custom completer function.
1923 1923
1924 1924 The position argument (defaults to 0) is the index in the completers
1925 1925 list where you want the completer to be inserted."""
1926 1926
1927 1927 newcomp = types.MethodType(completer,self.Completer)
1928 1928 self.Completer.matchers.insert(pos,newcomp)
1929 1929
1930 1930 def set_readline_completer(self):
1931 1931 """Reset readline's completer to be our own."""
1932 1932 self.readline.set_completer(self.Completer.rlcomplete)
1933 1933
1934 1934 def set_completer_frame(self, frame=None):
1935 1935 """Set the frame of the completer."""
1936 1936 if frame:
1937 1937 self.Completer.namespace = frame.f_locals
1938 1938 self.Completer.global_namespace = frame.f_globals
1939 1939 else:
1940 1940 self.Completer.namespace = self.user_ns
1941 1941 self.Completer.global_namespace = self.user_global_ns
1942 1942
1943 1943 #-------------------------------------------------------------------------
1944 1944 # Things related to magics
1945 1945 #-------------------------------------------------------------------------
1946 1946
1947 1947 def init_magics(self):
1948 1948 # FIXME: Move the color initialization to the DisplayHook, which
1949 1949 # should be split into a prompt manager and displayhook. We probably
1950 1950 # even need a centralize colors management object.
1951 1951 self.magic_colors(self.colors)
1952 1952 # History was moved to a separate module
1953 1953 from . import history
1954 1954 history.init_ipython(self)
1955 1955
1956 1956 def magic(self, arg_s, next_input=None):
1957 1957 """Call a magic function by name.
1958 1958
1959 1959 Input: a string containing the name of the magic function to call and
1960 1960 any additional arguments to be passed to the magic.
1961 1961
1962 1962 magic('name -opt foo bar') is equivalent to typing at the ipython
1963 1963 prompt:
1964 1964
1965 1965 In[1]: %name -opt foo bar
1966 1966
1967 1967 To call a magic without arguments, simply use magic('name').
1968 1968
1969 1969 This provides a proper Python function to call IPython's magics in any
1970 1970 valid Python code you can type at the interpreter, including loops and
1971 1971 compound statements.
1972 1972 """
1973 1973 # Allow setting the next input - this is used if the user does `a=abs?`.
1974 1974 # We do this first so that magic functions can override it.
1975 1975 if next_input:
1976 1976 self.set_next_input(next_input)
1977 1977
1978 1978 args = arg_s.split(' ',1)
1979 1979 magic_name = args[0]
1980 1980 magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
1981 1981
1982 1982 try:
1983 1983 magic_args = args[1]
1984 1984 except IndexError:
1985 1985 magic_args = ''
1986 1986 fn = getattr(self,'magic_'+magic_name,None)
1987 1987 if fn is None:
1988 1988 error("Magic function `%s` not found." % magic_name)
1989 1989 else:
1990 1990 magic_args = self.var_expand(magic_args,1)
1991 1991 # Grab local namespace if we need it:
1992 1992 if getattr(fn, "needs_local_scope", False):
1993 1993 self._magic_locals = sys._getframe(1).f_locals
1994 1994 with self.builtin_trap:
1995 1995 result = fn(magic_args)
1996 1996 # Ensure we're not keeping object references around:
1997 1997 self._magic_locals = {}
1998 1998 return result
1999 1999
2000 2000 def define_magic(self, magicname, func):
2001 2001 """Expose own function as magic function for ipython
2002 2002
2003 2003 def foo_impl(self,parameter_s=''):
2004 2004 'My very own magic!. (Use docstrings, IPython reads them).'
2005 2005 print 'Magic function. Passed parameter is between < >:'
2006 2006 print '<%s>' % parameter_s
2007 2007 print 'The self object is:',self
2008 2008
2009 2009 self.define_magic('foo',foo_impl)
2010 2010 """
2011 2011 im = types.MethodType(func,self)
2012 2012 old = getattr(self, "magic_" + magicname, None)
2013 2013 setattr(self, "magic_" + magicname, im)
2014 2014 return old
2015 2015
2016 2016 #-------------------------------------------------------------------------
2017 2017 # Things related to macros
2018 2018 #-------------------------------------------------------------------------
2019 2019
2020 2020 def define_macro(self, name, themacro):
2021 2021 """Define a new macro
2022 2022
2023 2023 Parameters
2024 2024 ----------
2025 2025 name : str
2026 2026 The name of the macro.
2027 2027 themacro : str or Macro
2028 2028 The action to do upon invoking the macro. If a string, a new
2029 2029 Macro object is created by passing the string to it.
2030 2030 """
2031 2031
2032 2032 from IPython.core import macro
2033 2033
2034 2034 if isinstance(themacro, basestring):
2035 2035 themacro = macro.Macro(themacro)
2036 2036 if not isinstance(themacro, macro.Macro):
2037 2037 raise ValueError('A macro must be a string or a Macro instance.')
2038 2038 self.user_ns[name] = themacro
2039 2039
2040 2040 #-------------------------------------------------------------------------
2041 2041 # Things related to the running of system commands
2042 2042 #-------------------------------------------------------------------------
2043 2043
2044 2044 def system_piped(self, cmd):
2045 2045 """Call the given cmd in a subprocess, piping stdout/err
2046 2046
2047 2047 Parameters
2048 2048 ----------
2049 2049 cmd : str
2050 2050 Command to execute (can not end in '&', as background processes are
2051 2051 not supported. Should not be a command that expects input
2052 2052 other than simple text.
2053 2053 """
2054 2054 if cmd.rstrip().endswith('&'):
2055 2055 # this is *far* from a rigorous test
2056 2056 # We do not support backgrounding processes because we either use
2057 2057 # pexpect or pipes to read from. Users can always just call
2058 2058 # os.system() or use ip.system=ip.system_raw
2059 2059 # if they really want a background process.
2060 2060 raise OSError("Background processes not supported.")
2061 2061
2062 2062 # we explicitly do NOT return the subprocess status code, because
2063 2063 # a non-None value would trigger :func:`sys.displayhook` calls.
2064 2064 # Instead, we store the exit_code in user_ns.
2065 2065 self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
2066 2066
2067 2067 def system_raw(self, cmd):
2068 2068 """Call the given cmd in a subprocess using os.system
2069 2069
2070 2070 Parameters
2071 2071 ----------
2072 2072 cmd : str
2073 2073 Command to execute.
2074 2074 """
2075 2075 # We explicitly do NOT return the subprocess status code, because
2076 2076 # a non-None value would trigger :func:`sys.displayhook` calls.
2077 2077 # Instead, we store the exit_code in user_ns.
2078 2078 self.user_ns['_exit_code'] = os.system(self.var_expand(cmd, depth=2))
2079 2079
2080 2080 # use piped system by default, because it is better behaved
2081 2081 system = system_piped
2082 2082
2083 2083 def getoutput(self, cmd, split=True):
2084 2084 """Get output (possibly including stderr) from a subprocess.
2085 2085
2086 2086 Parameters
2087 2087 ----------
2088 2088 cmd : str
2089 2089 Command to execute (can not end in '&', as background processes are
2090 2090 not supported.
2091 2091 split : bool, optional
2092 2092
2093 2093 If True, split the output into an IPython SList. Otherwise, an
2094 2094 IPython LSString is returned. These are objects similar to normal
2095 2095 lists and strings, with a few convenience attributes for easier
2096 2096 manipulation of line-based output. You can use '?' on them for
2097 2097 details.
2098 2098 """
2099 2099 if cmd.rstrip().endswith('&'):
2100 2100 # this is *far* from a rigorous test
2101 2101 raise OSError("Background processes not supported.")
2102 2102 out = getoutput(self.var_expand(cmd, depth=2))
2103 2103 if split:
2104 2104 out = SList(out.splitlines())
2105 2105 else:
2106 2106 out = LSString(out)
2107 2107 return out
2108 2108
2109 2109 #-------------------------------------------------------------------------
2110 2110 # Things related to aliases
2111 2111 #-------------------------------------------------------------------------
2112 2112
2113 2113 def init_alias(self):
2114 2114 self.alias_manager = AliasManager(shell=self, config=self.config)
2115 2115 self.ns_table['alias'] = self.alias_manager.alias_table,
2116 2116
2117 2117 #-------------------------------------------------------------------------
2118 2118 # Things related to extensions and plugins
2119 2119 #-------------------------------------------------------------------------
2120 2120
2121 2121 def init_extension_manager(self):
2122 2122 self.extension_manager = ExtensionManager(shell=self, config=self.config)
2123 2123
2124 2124 def init_plugin_manager(self):
2125 2125 self.plugin_manager = PluginManager(config=self.config)
2126 2126
2127 2127 #-------------------------------------------------------------------------
2128 2128 # Things related to payloads
2129 2129 #-------------------------------------------------------------------------
2130 2130
2131 2131 def init_payload(self):
2132 2132 self.payload_manager = PayloadManager(config=self.config)
2133 2133
2134 2134 #-------------------------------------------------------------------------
2135 2135 # Things related to the prefilter
2136 2136 #-------------------------------------------------------------------------
2137 2137
2138 2138 def init_prefilter(self):
2139 2139 self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
2140 2140 # Ultimately this will be refactored in the new interpreter code, but
2141 2141 # for now, we should expose the main prefilter method (there's legacy
2142 2142 # code out there that may rely on this).
2143 2143 self.prefilter = self.prefilter_manager.prefilter_lines
2144 2144
2145 2145 def auto_rewrite_input(self, cmd):
2146 2146 """Print to the screen the rewritten form of the user's command.
2147 2147
2148 2148 This shows visual feedback by rewriting input lines that cause
2149 2149 automatic calling to kick in, like::
2150 2150
2151 2151 /f x
2152 2152
2153 2153 into::
2154 2154
2155 2155 ------> f(x)
2156 2156
2157 2157 after the user's input prompt. This helps the user understand that the
2158 2158 input line was transformed automatically by IPython.
2159 2159 """
2160 2160 rw = self.displayhook.prompt1.auto_rewrite() + cmd
2161 2161
2162 2162 try:
2163 2163 # plain ascii works better w/ pyreadline, on some machines, so
2164 2164 # we use it and only print uncolored rewrite if we have unicode
2165 2165 rw = str(rw)
2166 2166 print >> io.stdout, rw
2167 2167 except UnicodeEncodeError:
2168 2168 print "------> " + cmd
2169 2169
2170 2170 #-------------------------------------------------------------------------
2171 2171 # Things related to extracting values/expressions from kernel and user_ns
2172 2172 #-------------------------------------------------------------------------
2173 2173
2174 2174 def _simple_error(self):
2175 2175 etype, value = sys.exc_info()[:2]
2176 2176 return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
2177 2177
2178 2178 def user_variables(self, names):
2179 2179 """Get a list of variable names from the user's namespace.
2180 2180
2181 2181 Parameters
2182 2182 ----------
2183 2183 names : list of strings
2184 2184 A list of names of variables to be read from the user namespace.
2185 2185
2186 2186 Returns
2187 2187 -------
2188 2188 A dict, keyed by the input names and with the repr() of each value.
2189 2189 """
2190 2190 out = {}
2191 2191 user_ns = self.user_ns
2192 2192 for varname in names:
2193 2193 try:
2194 2194 value = repr(user_ns[varname])
2195 2195 except:
2196 2196 value = self._simple_error()
2197 2197 out[varname] = value
2198 2198 return out
2199 2199
2200 2200 def user_expressions(self, expressions):
2201 2201 """Evaluate a dict of expressions in the user's namespace.
2202 2202
2203 2203 Parameters
2204 2204 ----------
2205 2205 expressions : dict
2206 2206 A dict with string keys and string values. The expression values
2207 2207 should be valid Python expressions, each of which will be evaluated
2208 2208 in the user namespace.
2209 2209
2210 2210 Returns
2211 2211 -------
2212 2212 A dict, keyed like the input expressions dict, with the repr() of each
2213 2213 value.
2214 2214 """
2215 2215 out = {}
2216 2216 user_ns = self.user_ns
2217 2217 global_ns = self.user_global_ns
2218 2218 for key, expr in expressions.iteritems():
2219 2219 try:
2220 2220 value = repr(eval(expr, global_ns, user_ns))
2221 2221 except:
2222 2222 value = self._simple_error()
2223 2223 out[key] = value
2224 2224 return out
2225 2225
2226 2226 #-------------------------------------------------------------------------
2227 2227 # Things related to the running of code
2228 2228 #-------------------------------------------------------------------------
2229 2229
2230 2230 def ex(self, cmd):
2231 2231 """Execute a normal python statement in user namespace."""
2232 2232 with self.builtin_trap:
2233 2233 exec cmd in self.user_global_ns, self.user_ns
2234 2234
2235 2235 def ev(self, expr):
2236 2236 """Evaluate python expression expr in user namespace.
2237 2237
2238 2238 Returns the result of evaluation
2239 2239 """
2240 2240 with self.builtin_trap:
2241 2241 return eval(expr, self.user_global_ns, self.user_ns)
2242 2242
2243 2243 def safe_execfile(self, fname, *where, **kw):
2244 2244 """A safe version of the builtin execfile().
2245 2245
2246 2246 This version will never throw an exception, but instead print
2247 2247 helpful error messages to the screen. This only works on pure
2248 2248 Python files with the .py extension.
2249 2249
2250 2250 Parameters
2251 2251 ----------
2252 2252 fname : string
2253 2253 The name of the file to be executed.
2254 2254 where : tuple
2255 2255 One or two namespaces, passed to execfile() as (globals,locals).
2256 2256 If only one is given, it is passed as both.
2257 2257 exit_ignore : bool (False)
2258 2258 If True, then silence SystemExit for non-zero status (it is always
2259 2259 silenced for zero status, as it is so common).
2260 raise_exceptions : bool (False)
2261 If True raise exceptions everywhere. Meant for testing.
2262
2260 2263 """
2261 2264 kw.setdefault('exit_ignore', False)
2265 kw.setdefault('raise_exceptions', False)
2262 2266
2263 2267 fname = os.path.abspath(os.path.expanduser(fname))
2264 2268
2265 2269 # Make sure we can open the file
2266 2270 try:
2267 2271 with open(fname) as thefile:
2268 2272 pass
2269 2273 except:
2270 2274 warn('Could not open file <%s> for safe execution.' % fname)
2271 2275 return
2272 2276
2273 2277 # Find things also in current directory. This is needed to mimic the
2274 2278 # behavior of running a script from the system command line, where
2275 2279 # Python inserts the script's directory into sys.path
2276 2280 dname = os.path.dirname(fname)
2277 2281
2278 2282 with prepended_to_syspath(dname):
2279 2283 try:
2280 2284 py3compat.execfile(fname,*where)
2281 2285 except SystemExit, status:
2282 2286 # If the call was made with 0 or None exit status (sys.exit(0)
2283 2287 # or sys.exit() ), don't bother showing a traceback, as both of
2284 2288 # these are considered normal by the OS:
2285 2289 # > python -c'import sys;sys.exit(0)'; echo $?
2286 2290 # 0
2287 2291 # > python -c'import sys;sys.exit()'; echo $?
2288 2292 # 0
2289 2293 # For other exit status, we show the exception unless
2290 2294 # explicitly silenced, but only in short form.
2295 if kw['raise_exceptions']:
2296 raise
2291 2297 if status.code not in (0, None) and not kw['exit_ignore']:
2292 2298 self.showtraceback(exception_only=True)
2293 2299 except:
2300 if kw['raise_exceptions']:
2301 raise
2294 2302 self.showtraceback()
2295 2303
2296 2304 def safe_execfile_ipy(self, fname):
2297 2305 """Like safe_execfile, but for .ipy files with IPython syntax.
2298 2306
2299 2307 Parameters
2300 2308 ----------
2301 2309 fname : str
2302 2310 The name of the file to execute. The filename must have a
2303 2311 .ipy extension.
2304 2312 """
2305 2313 fname = os.path.abspath(os.path.expanduser(fname))
2306 2314
2307 2315 # Make sure we can open the file
2308 2316 try:
2309 2317 with open(fname) as thefile:
2310 2318 pass
2311 2319 except:
2312 2320 warn('Could not open file <%s> for safe execution.' % fname)
2313 2321 return
2314 2322
2315 2323 # Find things also in current directory. This is needed to mimic the
2316 2324 # behavior of running a script from the system command line, where
2317 2325 # Python inserts the script's directory into sys.path
2318 2326 dname = os.path.dirname(fname)
2319 2327
2320 2328 with prepended_to_syspath(dname):
2321 2329 try:
2322 2330 with open(fname) as thefile:
2323 2331 # self.run_cell currently captures all exceptions
2324 2332 # raised in user code. It would be nice if there were
2325 2333 # versions of runlines, execfile that did raise, so
2326 2334 # we could catch the errors.
2327 2335 self.run_cell(thefile.read(), store_history=False)
2328 2336 except:
2329 2337 self.showtraceback()
2330 2338 warn('Unknown failure executing file: <%s>' % fname)
2331 2339
2332 2340 def run_cell(self, raw_cell, store_history=False):
2333 2341 """Run a complete IPython cell.
2334 2342
2335 2343 Parameters
2336 2344 ----------
2337 2345 raw_cell : str
2338 2346 The code (including IPython code such as %magic functions) to run.
2339 2347 store_history : bool
2340 2348 If True, the raw and translated cell will be stored in IPython's
2341 2349 history. For user code calling back into IPython's machinery, this
2342 2350 should be set to False.
2343 2351 """
2344 2352 if (not raw_cell) or raw_cell.isspace():
2345 2353 return
2346 2354
2347 2355 for line in raw_cell.splitlines():
2348 2356 self.input_splitter.push(line)
2349 2357 cell = self.input_splitter.source_reset()
2350 2358
2351 2359 with self.builtin_trap:
2352 2360 prefilter_failed = False
2353 2361 if len(cell.splitlines()) == 1:
2354 2362 try:
2355 2363 # use prefilter_lines to handle trailing newlines
2356 2364 # restore trailing newline for ast.parse
2357 2365 cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
2358 2366 except AliasError as e:
2359 2367 error(e)
2360 2368 prefilter_failed = True
2361 2369 except Exception:
2362 2370 # don't allow prefilter errors to crash IPython
2363 2371 self.showtraceback()
2364 2372 prefilter_failed = True
2365 2373
2366 2374 # Store raw and processed history
2367 2375 if store_history:
2368 2376 self.history_manager.store_inputs(self.execution_count,
2369 2377 cell, raw_cell)
2370 2378
2371 2379 self.logger.log(cell, raw_cell)
2372 2380
2373 2381 if not prefilter_failed:
2374 2382 # don't run if prefilter failed
2375 2383 cell_name = self.compile.cache(cell, self.execution_count)
2376 2384
2377 2385 with self.display_trap:
2378 2386 try:
2379 2387 code_ast = self.compile.ast_parse(cell, filename=cell_name)
2380 2388 except IndentationError:
2381 2389 self.showindentationerror()
2382 2390 self.execution_count += 1
2383 2391 return None
2384 2392 except (OverflowError, SyntaxError, ValueError, TypeError,
2385 2393 MemoryError):
2386 2394 self.showsyntaxerror()
2387 2395 self.execution_count += 1
2388 2396 return None
2389 2397
2390 2398 self.run_ast_nodes(code_ast.body, cell_name,
2391 2399 interactivity="last_expr")
2392 2400
2393 2401 # Execute any registered post-execution functions.
2394 2402 for func, status in self._post_execute.iteritems():
2395 2403 if not status:
2396 2404 continue
2397 2405 try:
2398 2406 func()
2399 2407 except:
2400 2408 self.showtraceback()
2401 2409 # Deactivate failing function
2402 2410 self._post_execute[func] = False
2403 2411
2404 2412 if store_history:
2405 2413 # Write output to the database. Does nothing unless
2406 2414 # history output logging is enabled.
2407 2415 self.history_manager.store_output(self.execution_count)
2408 2416 # Each cell is a *single* input, regardless of how many lines it has
2409 2417 self.execution_count += 1
2410 2418
2411 2419 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
2412 2420 """Run a sequence of AST nodes. The execution mode depends on the
2413 2421 interactivity parameter.
2414 2422
2415 2423 Parameters
2416 2424 ----------
2417 2425 nodelist : list
2418 2426 A sequence of AST nodes to run.
2419 2427 cell_name : str
2420 2428 Will be passed to the compiler as the filename of the cell. Typically
2421 2429 the value returned by ip.compile.cache(cell).
2422 2430 interactivity : str
2423 2431 'all', 'last', 'last_expr' or 'none', specifying which nodes should be
2424 2432 run interactively (displaying output from expressions). 'last_expr'
2425 2433 will run the last node interactively only if it is an expression (i.e.
2426 2434 expressions in loops or other blocks are not displayed. Other values
2427 2435 for this parameter will raise a ValueError.
2428 2436 """
2429 2437 if not nodelist:
2430 2438 return
2431 2439
2432 2440 if interactivity == 'last_expr':
2433 2441 if isinstance(nodelist[-1], ast.Expr):
2434 2442 interactivity = "last"
2435 2443 else:
2436 2444 interactivity = "none"
2437 2445
2438 2446 if interactivity == 'none':
2439 2447 to_run_exec, to_run_interactive = nodelist, []
2440 2448 elif interactivity == 'last':
2441 2449 to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
2442 2450 elif interactivity == 'all':
2443 2451 to_run_exec, to_run_interactive = [], nodelist
2444 2452 else:
2445 2453 raise ValueError("Interactivity was %r" % interactivity)
2446 2454
2447 2455 exec_count = self.execution_count
2448 2456
2449 2457 try:
2450 2458 for i, node in enumerate(to_run_exec):
2451 2459 mod = ast.Module([node])
2452 2460 code = self.compile(mod, cell_name, "exec")
2453 2461 if self.run_code(code):
2454 2462 return True
2455 2463
2456 2464 for i, node in enumerate(to_run_interactive):
2457 2465 mod = ast.Interactive([node])
2458 2466 code = self.compile(mod, cell_name, "single")
2459 2467 if self.run_code(code):
2460 2468 return True
2461 2469 except:
2462 2470 # It's possible to have exceptions raised here, typically by
2463 2471 # compilation of odd code (such as a naked 'return' outside a
2464 2472 # function) that did parse but isn't valid. Typically the exception
2465 2473 # is a SyntaxError, but it's safest just to catch anything and show
2466 2474 # the user a traceback.
2467 2475
2468 2476 # We do only one try/except outside the loop to minimize the impact
2469 2477 # on runtime, and also because if any node in the node list is
2470 2478 # broken, we should stop execution completely.
2471 2479 self.showtraceback()
2472 2480
2473 2481 return False
2474 2482
2475 2483 def run_code(self, code_obj):
2476 2484 """Execute a code object.
2477 2485
2478 2486 When an exception occurs, self.showtraceback() is called to display a
2479 2487 traceback.
2480 2488
2481 2489 Parameters
2482 2490 ----------
2483 2491 code_obj : code object
2484 2492 A compiled code object, to be executed
2485 2493 post_execute : bool [default: True]
2486 2494 whether to call post_execute hooks after this particular execution.
2487 2495
2488 2496 Returns
2489 2497 -------
2490 2498 False : successful execution.
2491 2499 True : an error occurred.
2492 2500 """
2493 2501
2494 2502 # Set our own excepthook in case the user code tries to call it
2495 2503 # directly, so that the IPython crash handler doesn't get triggered
2496 2504 old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
2497 2505
2498 2506 # we save the original sys.excepthook in the instance, in case config
2499 2507 # code (such as magics) needs access to it.
2500 2508 self.sys_excepthook = old_excepthook
2501 2509 outflag = 1 # happens in more places, so it's easier as default
2502 2510 try:
2503 2511 try:
2504 2512 self.hooks.pre_run_code_hook()
2505 2513 #rprint('Running code', repr(code_obj)) # dbg
2506 2514 exec code_obj in self.user_global_ns, self.user_ns
2507 2515 finally:
2508 2516 # Reset our crash handler in place
2509 2517 sys.excepthook = old_excepthook
2510 2518 except SystemExit:
2511 2519 self.showtraceback(exception_only=True)
2512 2520 warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
2513 2521 except self.custom_exceptions:
2514 2522 etype,value,tb = sys.exc_info()
2515 2523 self.CustomTB(etype,value,tb)
2516 2524 except:
2517 2525 self.showtraceback()
2518 2526 else:
2519 2527 outflag = 0
2520 2528 if softspace(sys.stdout, 0):
2521 2529 print
2522 2530
2523 2531 return outflag
2524 2532
2525 2533 # For backwards compatibility
2526 2534 runcode = run_code
2527 2535
2528 2536 #-------------------------------------------------------------------------
2529 2537 # Things related to GUI support and pylab
2530 2538 #-------------------------------------------------------------------------
2531 2539
2532 2540 def enable_pylab(self, gui=None, import_all=True):
2533 2541 raise NotImplementedError('Implement enable_pylab in a subclass')
2534 2542
2535 2543 #-------------------------------------------------------------------------
2536 2544 # Utilities
2537 2545 #-------------------------------------------------------------------------
2538 2546
2539 2547 def var_expand(self,cmd,depth=0):
2540 2548 """Expand python variables in a string.
2541 2549
2542 2550 The depth argument indicates how many frames above the caller should
2543 2551 be walked to look for the local namespace where to expand variables.
2544 2552
2545 2553 The global namespace for expansion is always the user's interactive
2546 2554 namespace.
2547 2555 """
2548 2556 res = ItplNS(cmd, self.user_ns, # globals
2549 2557 # Skip our own frame in searching for locals:
2550 2558 sys._getframe(depth+1).f_locals # locals
2551 2559 )
2552 2560 return py3compat.str_to_unicode(str(res), res.codec)
2553 2561
2554 2562 def mktempfile(self, data=None, prefix='ipython_edit_'):
2555 2563 """Make a new tempfile and return its filename.
2556 2564
2557 2565 This makes a call to tempfile.mktemp, but it registers the created
2558 2566 filename internally so ipython cleans it up at exit time.
2559 2567
2560 2568 Optional inputs:
2561 2569
2562 2570 - data(None): if data is given, it gets written out to the temp file
2563 2571 immediately, and the file is closed again."""
2564 2572
2565 2573 filename = tempfile.mktemp('.py', prefix)
2566 2574 self.tempfiles.append(filename)
2567 2575
2568 2576 if data:
2569 2577 tmp_file = open(filename,'w')
2570 2578 tmp_file.write(data)
2571 2579 tmp_file.close()
2572 2580 return filename
2573 2581
2574 2582 # TODO: This should be removed when Term is refactored.
2575 2583 def write(self,data):
2576 2584 """Write a string to the default output"""
2577 2585 io.stdout.write(data)
2578 2586
2579 2587 # TODO: This should be removed when Term is refactored.
2580 2588 def write_err(self,data):
2581 2589 """Write a string to the default error output"""
2582 2590 io.stderr.write(data)
2583 2591
2584 2592 def ask_yes_no(self,prompt,default=True):
2585 2593 if self.quiet:
2586 2594 return True
2587 2595 return ask_yes_no(prompt,default)
2588 2596
2589 2597 def show_usage(self):
2590 2598 """Show a usage message"""
2591 2599 page.page(IPython.core.usage.interactive_usage)
2592 2600
2593 2601 def find_user_code(self, target, raw=True):
2594 2602 """Get a code string from history, file, or a string or macro.
2595 2603
2596 2604 This is mainly used by magic functions.
2597 2605
2598 2606 Parameters
2599 2607 ----------
2600 2608 target : str
2601 2609 A string specifying code to retrieve. This will be tried respectively
2602 2610 as: ranges of input history (see %history for syntax), a filename, or
2603 2611 an expression evaluating to a string or Macro in the user namespace.
2604 2612 raw : bool
2605 2613 If true (default), retrieve raw history. Has no effect on the other
2606 2614 retrieval mechanisms.
2607 2615
2608 2616 Returns
2609 2617 -------
2610 2618 A string of code.
2611 2619
2612 2620 ValueError is raised if nothing is found, and TypeError if it evaluates
2613 2621 to an object of another type. In each case, .args[0] is a printable
2614 2622 message.
2615 2623 """
2616 2624 code = self.extract_input_lines(target, raw=raw) # Grab history
2617 2625 if code:
2618 2626 return code
2619 2627 if os.path.isfile(target): # Read file
2620 2628 return open(target, "r").read()
2621 2629
2622 2630 try: # User namespace
2623 2631 codeobj = eval(target, self.user_ns)
2624 2632 except Exception:
2625 2633 raise ValueError(("'%s' was not found in history, as a file, nor in"
2626 2634 " the user namespace.") % target)
2627 2635 if isinstance(codeobj, basestring):
2628 2636 return codeobj
2629 2637 elif isinstance(codeobj, Macro):
2630 2638 return codeobj.value
2631 2639
2632 2640 raise TypeError("%s is neither a string nor a macro." % target,
2633 2641 codeobj)
2634 2642
2635 2643 #-------------------------------------------------------------------------
2636 2644 # Things related to IPython exiting
2637 2645 #-------------------------------------------------------------------------
2638 2646 def atexit_operations(self):
2639 2647 """This will be executed at the time of exit.
2640 2648
2641 2649 Cleanup operations and saving of persistent data that is done
2642 2650 unconditionally by IPython should be performed here.
2643 2651
2644 2652 For things that may depend on startup flags or platform specifics (such
2645 2653 as having readline or not), register a separate atexit function in the
2646 2654 code that has the appropriate information, rather than trying to
2647 2655 clutter
2648 2656 """
2649 2657 # Close the history session (this stores the end time and line count)
2650 2658 # this must be *before* the tempfile cleanup, in case of temporary
2651 2659 # history db
2652 2660 self.history_manager.end_session()
2653 2661
2654 2662 # Cleanup all tempfiles left around
2655 2663 for tfile in self.tempfiles:
2656 2664 try:
2657 2665 os.unlink(tfile)
2658 2666 except OSError:
2659 2667 pass
2660 2668
2661 2669 # Clear all user namespaces to release all references cleanly.
2662 2670 self.reset(new_session=False)
2663 2671
2664 2672 # Run user hooks
2665 2673 self.hooks.shutdown_hook()
2666 2674
2667 2675 def cleanup(self):
2668 2676 self.restore_sys_module_state()
2669 2677
2670 2678
2671 2679 class InteractiveShellABC(object):
2672 2680 """An abstract base class for InteractiveShell."""
2673 2681 __metaclass__ = abc.ABCMeta
2674 2682
2675 2683 InteractiveShellABC.register(InteractiveShell)
@@ -1,195 +1,222 b''
1 # -*- coding: utf-8 -*-
1 2 """Tests for the key interactiveshell module.
2 3
3 4 Historically the main classes in interactiveshell have been under-tested. This
4 5 module should grow as many single-method tests as possible to trap many of the
5 6 recurring bugs we seem to encounter with high-level interaction.
6 7
7 8 Authors
8 9 -------
9 10 * Fernando Perez
10 11 """
11 12 #-----------------------------------------------------------------------------
12 13 # Copyright (C) 2011 The IPython Development Team
13 14 #
14 15 # Distributed under the terms of the BSD License. The full license is in
15 16 # the file COPYING, distributed as part of this software.
16 17 #-----------------------------------------------------------------------------
17 18
18 19 #-----------------------------------------------------------------------------
19 20 # Imports
20 21 #-----------------------------------------------------------------------------
21 22 # stdlib
23 import os
24 import shutil
25 import tempfile
22 26 import unittest
27 from os.path import join
23 28 from StringIO import StringIO
24 29
25 30 from IPython.testing import decorators as dec
26 31 from IPython.utils import io
27 32
28 33 #-----------------------------------------------------------------------------
29 34 # Tests
30 35 #-----------------------------------------------------------------------------
31 36
32 37 class InteractiveShellTestCase(unittest.TestCase):
33 38 def test_naked_string_cells(self):
34 39 """Test that cells with only naked strings are fully executed"""
35 40 ip = get_ipython()
36 41 # First, single-line inputs
37 42 ip.run_cell('"a"\n')
38 43 self.assertEquals(ip.user_ns['_'], 'a')
39 44 # And also multi-line cells
40 45 ip.run_cell('"""a\nb"""\n')
41 46 self.assertEquals(ip.user_ns['_'], 'a\nb')
42 47
43 48 def test_run_empty_cell(self):
44 49 """Just make sure we don't get a horrible error with a blank
45 50 cell of input. Yes, I did overlook that."""
46 51 ip = get_ipython()
47 52 old_xc = ip.execution_count
48 53 ip.run_cell('')
49 54 self.assertEquals(ip.execution_count, old_xc)
50 55
51 56 def test_run_cell_multiline(self):
52 57 """Multi-block, multi-line cells must execute correctly.
53 58 """
54 59 ip = get_ipython()
55 60 src = '\n'.join(["x=1",
56 61 "y=2",
57 62 "if 1:",
58 63 " x += 1",
59 64 " y += 1",])
60 65 ip.run_cell(src)
61 66 self.assertEquals(ip.user_ns['x'], 2)
62 67 self.assertEquals(ip.user_ns['y'], 3)
63 68
64 69 def test_multiline_string_cells(self):
65 70 "Code sprinkled with multiline strings should execute (GH-306)"
66 71 ip = get_ipython()
67 72 ip.run_cell('tmp=0')
68 73 self.assertEquals(ip.user_ns['tmp'], 0)
69 74 ip.run_cell('tmp=1;"""a\nb"""\n')
70 75 self.assertEquals(ip.user_ns['tmp'], 1)
71 76
72 77 def test_dont_cache_with_semicolon(self):
73 78 "Ending a line with semicolon should not cache the returned object (GH-307)"
74 79 ip = get_ipython()
75 80 oldlen = len(ip.user_ns['Out'])
76 81 a = ip.run_cell('1;', store_history=True)
77 82 newlen = len(ip.user_ns['Out'])
78 83 self.assertEquals(oldlen, newlen)
79 84 #also test the default caching behavior
80 85 ip.run_cell('1', store_history=True)
81 86 newlen = len(ip.user_ns['Out'])
82 87 self.assertEquals(oldlen+1, newlen)
83 88
84 89 def test_In_variable(self):
85 90 "Verify that In variable grows with user input (GH-284)"
86 91 ip = get_ipython()
87 92 oldlen = len(ip.user_ns['In'])
88 93 ip.run_cell('1;', store_history=True)
89 94 newlen = len(ip.user_ns['In'])
90 95 self.assertEquals(oldlen+1, newlen)
91 96 self.assertEquals(ip.user_ns['In'][-1],'1;')
92 97
93 98 def test_magic_names_in_string(self):
94 99 ip = get_ipython()
95 100 ip.run_cell('a = """\n%exit\n"""')
96 101 self.assertEquals(ip.user_ns['a'], '\n%exit\n')
97 102
98 103 def test_alias_crash(self):
99 104 """Errors in prefilter can't crash IPython"""
100 105 ip = get_ipython()
101 106 ip.run_cell('%alias parts echo first %s second %s')
102 107 # capture stderr:
103 108 save_err = io.stderr
104 109 io.stderr = StringIO()
105 110 ip.run_cell('parts 1')
106 111 err = io.stderr.getvalue()
107 112 io.stderr = save_err
108 113 self.assertEquals(err.split(':')[0], 'ERROR')
109 114
110 115 def test_trailing_newline(self):
111 116 """test that running !(command) does not raise a SyntaxError"""
112 117 ip = get_ipython()
113 118 ip.run_cell('!(true)\n', False)
114 119 ip.run_cell('!(true)\n\n\n', False)
115 120
116 121 def test_gh_597(self):
117 122 """Pretty-printing lists of objects with non-ascii reprs may cause
118 123 problems."""
119 124 class Spam(object):
120 125 def __repr__(self):
121 126 return "\xe9"*50
122 127 import IPython.core.formatters
123 128 f = IPython.core.formatters.PlainTextFormatter()
124 129 f([Spam(),Spam()])
125 130
126 131 def test_future_flags(self):
127 132 """Check that future flags are used for parsing code (gh-777)"""
128 133 ip = get_ipython()
129 134 ip.run_cell('from __future__ import print_function')
130 135 try:
131 136 ip.run_cell('prfunc_return_val = print(1,2, sep=" ")')
132 137 assert 'prfunc_return_val' in ip.user_ns
133 138 finally:
134 139 # Reset compiler flags so we don't mess up other tests.
135 140 ip.compile.reset_compiler_flags()
136 141
137 142 def test_future_unicode(self):
138 143 """Check that unicode_literals is imported from __future__ (gh #786)"""
139 144 ip = get_ipython()
140 145 try:
141 146 ip.run_cell(u'byte_str = "a"')
142 147 assert isinstance(ip.user_ns['byte_str'], str) # string literals are byte strings by default
143 148 ip.run_cell('from __future__ import unicode_literals')
144 149 ip.run_cell(u'unicode_str = "a"')
145 150 assert isinstance(ip.user_ns['unicode_str'], unicode) # strings literals are now unicode
146 151 finally:
147 152 # Reset compiler flags so we don't mess up other tests.
148 153 ip.compile.reset_compiler_flags()
149 154
150 155 def test_bad_custom_tb(self):
151 156 """Check that InteractiveShell is protected from bad custom exception handlers"""
152 157 ip = get_ipython()
153 158 from IPython.utils import io
154 159 save_stderr = io.stderr
155 160 try:
156 161 # capture stderr
157 162 io.stderr = StringIO()
158 163 ip.set_custom_exc((IOError,), lambda etype,value,tb: 1/0)
159 164 self.assertEquals(ip.custom_exceptions, (IOError,))
160 165 ip.run_cell(u'raise IOError("foo")')
161 166 self.assertEquals(ip.custom_exceptions, ())
162 167 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
163 168 finally:
164 169 io.stderr = save_stderr
165 170
166 171 def test_bad_custom_tb_return(self):
167 172 """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
168 173 ip = get_ipython()
169 174 from IPython.utils import io
170 175 save_stderr = io.stderr
171 176 try:
172 177 # capture stderr
173 178 io.stderr = StringIO()
174 179 ip.set_custom_exc((NameError,),lambda etype,value,tb, tb_offset=None: 1)
175 180 self.assertEquals(ip.custom_exceptions, (NameError,))
176 181 ip.run_cell(u'a=abracadabra')
177 182 self.assertEquals(ip.custom_exceptions, ())
178 183 self.assertTrue("Custom TB Handler failed" in io.stderr.getvalue())
179 184 finally:
180 185 io.stderr = save_stderr
181 186
182 187 def test_drop_by_id(self):
183 188 ip = get_ipython()
184 189 myvars = {"a":object(), "b":object(), "c": object()}
185 190 ip.push(myvars, interactive=False)
186 191 for name in myvars:
187 192 assert name in ip.user_ns, name
188 193 assert name in ip.user_ns_hidden, name
189 194 ip.user_ns['b'] = 12
190 195 ip.drop_by_id(myvars)
191 196 for name in ["a", "c"]:
192 197 assert name not in ip.user_ns, name
193 198 assert name not in ip.user_ns_hidden, name
194 199 assert ip.user_ns['b'] == 12
195 200 ip.reset()
201
202 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
203
204 def setUp(self):
205 self.BASETESTDIR = tempfile.mkdtemp()
206 self.TESTDIR = join(self.BASETESTDIR, u"åäö")
207 os.mkdir(self.TESTDIR)
208 with open(join(self.TESTDIR, u"åäötestscript.py"), "w") as sfile:
209 sfile.write("pass\n")
210 self.oldpath = os.getcwdu()
211 os.chdir(self.TESTDIR)
212 self.fname = u"åäötestscript.py"
213
214
215 def tearDown(self):
216 os.chdir(self.oldpath)
217 shutil.rmtree(self.BASETESTDIR)
218
219 def test_1(self):
220 """Test safe_execfile with non-ascii path
221 """
222 _ip.shell.safe_execfile(self.fname, raise_exceptions=True)
@@ -1,172 +1,172 b''
1 1 # coding: utf-8
2 2 """Compatibility tricks for Python 3. Mainly to do with unicode."""
3 3 import __builtin__
4 4 import functools
5 5 import sys
6 6 import re
7 7 import types
8 8
9 9 orig_open = open
10 10
11 11 def no_code(x, encoding=None):
12 12 return x
13 13
14 14 def decode(s, encoding=None):
15 15 encoding = encoding or sys.stdin.encoding or sys.getdefaultencoding()
16 16 return s.decode(encoding, "replace")
17 17
18 18 def encode(u, encoding=None):
19 19 encoding = encoding or sys.stdin.encoding or sys.getdefaultencoding()
20 20 return u.encode(encoding, "replace")
21 21
22 22 def cast_unicode(s, encoding=None):
23 23 if isinstance(s, bytes):
24 24 return decode(s, encoding)
25 25 return s
26 26
27 27 def cast_bytes(s, encoding=None):
28 28 if not isinstance(s, bytes):
29 29 return encode(s, encoding)
30 30 return s
31 31
32 32 def _modify_str_or_docstring(str_change_func):
33 33 @functools.wraps(str_change_func)
34 34 def wrapper(func_or_str):
35 35 if isinstance(func_or_str, str):
36 36 func = None
37 37 doc = func_or_str
38 38 else:
39 39 func = func_or_str
40 40 doc = func.__doc__
41 41
42 42 doc = str_change_func(doc)
43 43
44 44 if func:
45 45 func.__doc__ = doc
46 46 return func
47 47 return doc
48 48 return wrapper
49 49
50 50 if sys.version_info[0] >= 3:
51 51 PY3 = True
52 52
53 53 input = input
54 54 builtin_mod_name = "builtins"
55 55
56 56 str_to_unicode = no_code
57 57 unicode_to_str = no_code
58 58 str_to_bytes = encode
59 59 bytes_to_str = decode
60 60 cast_bytes_py2 = no_code
61 61
62 62 def isidentifier(s, dotted=False):
63 63 if dotted:
64 64 return all(isidentifier(a) for a in s.split("."))
65 65 return s.isidentifier()
66 66
67 67 open = orig_open
68 68
69 69 MethodType = types.MethodType
70 70
71 71 def execfile(fname, glob, loc=None):
72 72 loc = loc if (loc is not None) else glob
73 73 exec compile(open(fname).read(), fname, 'exec') in glob, loc
74 74
75 75 # Refactor print statements in doctests.
76 76 _print_statement_re = re.compile(r"\bprint (?P<expr>.*)$", re.MULTILINE)
77 77 def _print_statement_sub(match):
78 78 expr = match.groups('expr')
79 79 return "print(%s)" % expr
80 80
81 81 @_modify_str_or_docstring
82 82 def doctest_refactor_print(doc):
83 83 """Refactor 'print x' statements in a doctest to print(x) style. 2to3
84 84 unfortunately doesn't pick up on our doctests.
85 85
86 86 Can accept a string or a function, so it can be used as a decorator."""
87 87 return _print_statement_re.sub(_print_statement_sub, doc)
88 88
89 89 # Abstract u'abc' syntax:
90 90 @_modify_str_or_docstring
91 91 def u_format(s):
92 92 """"{u}'abc'" --> "'abc'" (Python 3)
93 93
94 94 Accepts a string or a function, so it can be used as a decorator."""
95 95 return s.format(u='')
96 96
97 97 else:
98 98 PY3 = False
99 99
100 100 input = raw_input
101 101 builtin_mod_name = "__builtin__"
102 102
103 103 str_to_unicode = decode
104 104 unicode_to_str = encode
105 105 str_to_bytes = no_code
106 106 bytes_to_str = no_code
107 107 cast_bytes_py2 = cast_bytes
108 108
109 109 import re
110 110 _name_re = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*$")
111 111 def isidentifier(s, dotted=False):
112 112 if dotted:
113 113 return all(isidentifier(a) for a in s.split("."))
114 114 return bool(_name_re.match(s))
115 115
116 116 class open(object):
117 117 """Wrapper providing key part of Python 3 open() interface."""
118 118 def __init__(self, fname, mode="r", encoding="utf-8"):
119 119 self.f = orig_open(fname, mode)
120 120 self.enc = encoding
121 121
122 122 def write(self, s):
123 123 return self.f.write(s.encode(self.enc))
124 124
125 125 def read(self, size=-1):
126 126 return self.f.read(size).decode(self.enc)
127 127
128 128 def close(self):
129 129 return self.f.close()
130 130
131 131 def __enter__(self):
132 132 return self
133 133
134 134 def __exit__(self, etype, value, traceback):
135 135 self.f.close()
136 136
137 137 def MethodType(func, instance):
138 138 return types.MethodType(func, instance, type(instance))
139 139
140 140 # don't override system execfile on 2.x:
141 141 execfile = execfile
142 142
143 143 def doctest_refactor_print(func_or_str):
144 144 return func_or_str
145 145
146 146
147 147 # Abstract u'abc' syntax:
148 148 @_modify_str_or_docstring
149 149 def u_format(s):
150 150 """"{u}'abc'" --> "u'abc'" (Python 2)
151 151
152 152 Accepts a string or a function, so it can be used as a decorator."""
153 153 return s.format(u='u')
154 154
155 155 if sys.platform == 'win32':
156 def execfile(fname, glob, loc=None):
156 def execfile(fname, glob=None, loc=None):
157 157 loc = loc if (loc is not None) else glob
158 158 scripttext = __builtin__.open(fname).read()
159 159 #compile converts unicode filename to str assuming
160 160 #ascii. Let's do the conversion before calling compile
161 161 if isinstance(fname, unicode):
162 162 filename = unicode_to_str(fname)
163 163 else:
164 164 filename = fname
165 165 exec compile(scripttext, filename, 'exec') in glob, loc
166 166 else:
167 def execfile(fname, glob, loc=None):
167 def execfile(fname, glob=None, loc=None):
168 168 if isinstance(fname, unicode):
169 169 filename = fname.encode(sys.getfilesystemencoding())
170 170 else:
171 171 filename = fname
172 172 __builtin__.execfile(filename, glob, loc)
General Comments 0
You need to be logged in to leave comments. Login now