upstream/ipython Commit - r1038:0401e9e4

1

# -*- coding: utf-8 -*-

2

"""

3

IPython -- An enhanced Interactive Python

4

5

Requires Python 2.3 or newer.

6

7

This file contains all the classes and helper functions specific to IPython.

8

9

"""

10

11

#*****************************************************************************

12

13

14

#

15

# Distributed under the terms of the BSD License. The full license is in

16

# the file COPYING, distributed as part of this software.

17

#

18

# Note: this code originally subclassed code.InteractiveConsole from the

19

# Python standard library. Over time, all of that class has been copied

20

# verbatim here for modifications which could not be accomplished by

21

# subclassing. At this point, there are no dependencies at all on the code

22

# module anymore (it is not even imported). The Python License (sec. 2)

23

# allows for this, but it's always nice to acknowledge credit where credit is

24

# due.

25

#*****************************************************************************

26

27

#****************************************************************************

28

# Modules and globals

29

30

from IPython import Release

31

__author__ = '%s <%s>\n%s <%s>' % \

32

( Release.authors['Janko'] + Release.authors['Fernando'] )

33

__license__ = Release.license

34

__version__ = Release.version

35

36

# Python standard modules

37

import __main__

38

import __builtin__

39

import StringIO

40

import bdb

41

import cPickle as pickle

42

import codeop

43

import exceptions

44

import glob

45

import inspect

46

import keyword

47

import new

48

import os

49

import pydoc

50

import re

51

import shutil

52

import string

53

import sys

54

import tempfile

55

import traceback

56

import types

57

from sets import Set

58

from pprint import pprint, pformat

59

60

# IPython's own modules

61

#import IPython

62

from IPython import Debugger,OInspect,PyColorize,ultraTB

63

from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names

64

from IPython.Extensions import pickleshare

65

from IPython.FakeModule import FakeModule

66

from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns

67

from IPython.Logger import Logger

68

from IPython.Magic import Magic

69

from IPython.Prompts import CachedOutput

70

from IPython.ipstruct import Struct

71

from IPython.background_jobs import BackgroundJobManager

72

from IPython.usage import cmd_line_usage,interactive_usage

73

from IPython.genutils import *

74

from IPython.strdispatch import StrDispatch

75

import IPython.ipapi

76

import IPython.history

77

import IPython.prefilter as prefilter

78

import IPython.shadowns

79

# Globals

80

81

# store the builtin raw_input globally, and use this always, in case user code

82

# overwrites it (like wx.py.PyShell does)

83

raw_input_original = raw_input

84

85

# compiled regexps for autoindent management

86

dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')

87

88

89

#****************************************************************************

90

# Some utility function definitions

91

92

ini_spaces_re = re.compile(r'^(\s+)')

93

94

def num_ini_spaces(strng):

95

"""Return the number of initial spaces in a string"""

96

97

ini_spaces = ini_spaces_re.match(strng)

98

if ini_spaces:

99

return ini_spaces.end()

100

else:

101

return 0

102

103

def softspace(file, newvalue):

104

"""Copied from code.py, to remove the dependency"""

105

106

oldvalue = 0

107

try:

108

oldvalue = file.softspace

109

except AttributeError:

110

pass

111

try:

112

file.softspace = newvalue

113

except (AttributeError, TypeError):

114

# "attribute-less object" or "read-only attributes"

115

pass

116

return oldvalue

117

118

119

#****************************************************************************

120

# Local use exceptions

121

class SpaceInInput(exceptions.Exception): pass

122

123

124

#****************************************************************************

125

# Local use classes

126

class Bunch: pass

127

128

class Undefined: pass

129

130

class Quitter(object):

131

"""Simple class to handle exit, similar to Python 2.5's.

132

133

It handles exiting in an ipython-safe manner, which the one in Python 2.5

134

doesn't do (obviously, since it doesn't know about ipython)."""

135

136

def __init__(self,shell,name):

137

self.shell = shell

138

self.name = name

139

140

def __repr__(self):

141

return 'Type %s() to exit.' % self.name

142

__str__ = __repr__

143

144

def __call__(self):

145

self.shell.exit()

146

147

class InputList(list):

148

"""Class to store user input.

149

150

It's basically a list, but slices return a string instead of a list, thus

151

allowing things like (assuming 'In' is an instance):

152

153

exec In[4:7]

154

155

or

156

157

exec In[5:9] + In[14] + In[21:25]"""

158

159

def __getslice__(self,i,j):

160

return ''.join(list.__getslice__(self,i,j))

161

162

class SyntaxTB(ultraTB.ListTB):

163

"""Extension which holds some state: the last exception value"""

164

165

def __init__(self,color_scheme = 'NoColor'):

166

ultraTB.ListTB.__init__(self,color_scheme)

167

self.last_syntax_error = None

168

169

def __call__(self, etype, value, elist):

170

self.last_syntax_error = value

171

ultraTB.ListTB.__call__(self,etype,value,elist)

172

173

def clear_err_state(self):

174

"""Return the current error state and clear it"""

175

e = self.last_syntax_error

176

self.last_syntax_error = None

177

return e

178

179

#****************************************************************************

180

# Main IPython class

181

182

# FIXME: the Magic class is a mixin for now, and will unfortunately remain so

183

# until a full rewrite is made. I've cleaned all cross-class uses of

184

# attributes and methods, but too much user code out there relies on the

185

# equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.

186

#

187

# But at least now, all the pieces have been separated and we could, in

188

# principle, stop using the mixin. This will ease the transition to the

189

# chainsaw branch.

190

191

# For reference, the following is the list of 'self.foo' uses in the Magic

192

# class as of 2005-12-28. These are names we CAN'T use in the main ipython

193

# class, to prevent clashes.

194

195

# ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',

196

# 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',

197

# 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',

198

# 'self.value']

199

200

class InteractiveShell(object,Magic):

201

"""An enhanced console for Python."""

202

203

# class attribute to indicate whether the class supports threads or not.

204

# Subclasses with thread support should override this as needed.

205

isthreaded = False

206

207

def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),

208

user_ns = None,user_global_ns=None,banner2='',

209

custom_exceptions=((),None),embedded=False):

210

211

# log system

212

self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')

213

214

# some minimal strict typechecks. For some core data structures, I

215

# want actual basic python types, not just anything that looks like

216

# one. This is especially true for namespaces.

217

for ns in (user_ns,user_global_ns):

218

if ns is not None and type(ns) != types.DictType:

219

raise TypeError,'namespace must be a dictionary'

220

# Job manager (for jobs run as background threads)

221

self.jobs = BackgroundJobManager()

222

223

# Store the actual shell's name

224

self.name = name

225

self.more = False

226

227

# We need to know whether the instance is meant for embedding, since

228

# global/local namespaces need to be handled differently in that case

229

self.embedded = embedded

230

if embedded:

231

# Control variable so users can, from within the embedded instance,

232

# permanently deactivate it.

233

self.embedded_active = True

234

235

# command compiler

236

self.compile = codeop.CommandCompiler()

237

238

# User input buffer

239

self.buffer = []

240

241

# Default name given in compilation of code

242

self.filename = '<ipython console>'

243

244

# Install our own quitter instead of the builtins. For python2.3-2.4,

245

# this brings in behavior like 2.5, and for 2.5 it's identical.

246

__builtin__.exit = Quitter(self,'exit')

247

__builtin__.quit = Quitter(self,'quit')

248

249

# Make an empty namespace, which extension writers can rely on both

250

# existing and NEVER being used by ipython itself. This gives them a

251

# convenient location for storing additional information and state

252

# their extensions may require, without fear of collisions with other

253

# ipython names that may develop later.

254

self.meta = Struct()

255

256

# Create the namespace where the user will operate. user_ns is

257

# normally the only one used, and it is passed to the exec calls as

258

# the locals argument. But we do carry a user_global_ns namespace

259

# given as the exec 'globals' argument, This is useful in embedding

260

# situations where the ipython shell opens in a context where the

261

# distinction between locals and globals is meaningful.

262

263

# FIXME. For some strange reason, __builtins__ is showing up at user

264

# level as a dict instead of a module. This is a manual fix, but I

265

# should really track down where the problem is coming from. Alex

266

# Schmolck reported this problem first.

267

268

# A useful post by Alex Martelli on this topic:

269

# Re: inconsistent value from __builtins__

270

# Von: Alex Martelli <aleaxit@yahoo.com>

271

# Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends

272

# Gruppen: comp.lang.python

273

274

# Michael Hohn <hohn@hooknose.lbl.gov> wrote:

275

# > >>> print type(builtin_check.get_global_binding('__builtins__'))

276

# > <type 'dict'>

277

# > >>> print type(__builtins__)

278

# > <type 'module'>

279

# > Is this difference in return value intentional?

280

281

# Well, it's documented that '__builtins__' can be either a dictionary

282

# or a module, and it's been that way for a long time. Whether it's

283

# intentional (or sensible), I don't know. In any case, the idea is

284

# that if you need to access the built-in namespace directly, you

285

# should start with "import __builtin__" (note, no 's') which will

286

# definitely give you a module. Yeah, it's somewhat confusing:-(.

287

288

# These routines return properly built dicts as needed by the rest of

289

# the code, and can also be used by extension writers to generate

290

# properly initialized namespaces.

291

user_ns = IPython.ipapi.make_user_ns(user_ns)

292

user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)

293

294

# Assign namespaces

295

# This is the namespace where all normal user variables live

296

self.user_ns = user_ns

297

# Embedded instances require a separate namespace for globals.

298

# Normally this one is unused by non-embedded instances.

299

self.user_global_ns = user_global_ns

300

# A namespace to keep track of internal data structures to prevent

301

# them from cluttering user-visible stuff. Will be updated later

302

self.internal_ns = {}

303

304

# Namespace of system aliases. Each entry in the alias

305

# table must be a 2-tuple of the form (N,name), where N is the number

306

# of positional arguments of the alias.

307

self.alias_table = {}

308

309

# A table holding all the namespaces IPython deals with, so that

310

# introspection facilities can search easily.

311

self.ns_table = {'user':user_ns,

312

'user_global':user_global_ns,

313

'alias':self.alias_table,

314

'internal':self.internal_ns,

315

'builtin':__builtin__.__dict__

316

}

317

# The user namespace MUST have a pointer to the shell itself.

318

self.user_ns[name] = self

319

320

# We need to insert into sys.modules something that looks like a

321

# module but which accesses the IPython namespace, for shelve and

322

# pickle to work interactively. Normally they rely on getting

323

# everything out of __main__, but for embedding purposes each IPython

324

# instance has its own private namespace, so we can't go shoving

325

# everything into __main__.

326

327

# note, however, that we should only do this for non-embedded

328

# ipythons, which really mimic the __main__.__dict__ with their own

329

# namespace. Embedded instances, on the other hand, should not do

330

# this because they need to manage the user local/global namespaces

331

# only, but they live within a 'normal' __main__ (meaning, they

332

# shouldn't overtake the execution environment of the script they're

333

# embedded in).

334

335

if not embedded:

336

try:

337

main_name = self.user_ns['__name__']

338

except KeyError:

339

raise KeyError,'user_ns dictionary MUST have a "__name__" key'

340

else:

341

#print "pickle hack in place" # dbg

342

#print 'main_name:',main_name # dbg

343

sys.modules[main_name] = FakeModule(self.user_ns)

344

345

# Now that FakeModule produces a real module, we've run into a nasty

346

# problem: after script execution (via %run), the module where the user

347

# code ran is deleted. Now that this object is a true module (needed

348

# so docetst and other tools work correctly), the Python module

349

# teardown mechanism runs over it, and sets to None every variable

350

# present in that module. This means that later calls to functions

351

# defined in the script (which have become interactively visible after

352

# script exit) fail, because they hold references to objects that have

353

# become overwritten into None. The only solution I see right now is

354

# to protect every FakeModule used by %run by holding an internal

355

# reference to it. This private list will be used for that. The

356

# %reset command will flush it as well.

357

self._user_main_modules = []

358

359

# List of input with multi-line handling.

360

# Fill its zero entry, user counter starts at 1

361

self.input_hist = InputList(['\n'])

362

# This one will hold the 'raw' input history, without any

363

# pre-processing. This will allow users to retrieve the input just as

364

# it was exactly typed in by the user, with %hist -r.

365

self.input_hist_raw = InputList(['\n'])

366

367

# list of visited directories

368

try:

369

self.dir_hist = [os.getcwd()]

370

except OSError:

371

self.dir_hist = []

372

373

# dict of output history

374

self.output_hist = {}

375

376

# Get system encoding at startup time. Certain terminals (like Emacs

377

# under Win32 have it set to None, and we need to have a known valid

378

# encoding to use in the raw_input() method

379

try:

380

self.stdin_encoding = sys.stdin.encoding or 'ascii'

381

except AttributeError:

382

self.stdin_encoding = 'ascii'

383

384

# dict of things NOT to alias (keywords, builtins and some magics)

385

no_alias = {}

386

no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']

387

for key in keyword.kwlist + no_alias_magics:

388

no_alias[key] = 1

389

no_alias.update(__builtin__.__dict__)

390

self.no_alias = no_alias

391

392

# make global variables for user access to these

393

self.user_ns['_ih'] = self.input_hist

394

self.user_ns['_oh'] = self.output_hist

395

self.user_ns['_dh'] = self.dir_hist

396

397

# user aliases to input and output histories

398

self.user_ns['In'] = self.input_hist

399

self.user_ns['Out'] = self.output_hist

400

401

self.user_ns['_sh'] = IPython.shadowns

402

# Object variable to store code object waiting execution. This is

403

# used mainly by the multithreaded shells, but it can come in handy in

404

# other situations. No need to use a Queue here, since it's a single

405

# item which gets cleared once run.

406

self.code_to_run = None

407

408

# escapes for automatic behavior on the command line

409

self.ESC_SHELL = '!'

410

self.ESC_SH_CAP = '!!'

411

self.ESC_HELP = '?'

412

self.ESC_MAGIC = '%'

413

self.ESC_QUOTE = ','

414

self.ESC_QUOTE2 = ';'

415

self.ESC_PAREN = '/'

416

417

# And their associated handlers

418

self.esc_handlers = {self.ESC_PAREN : self.handle_auto,

419

self.ESC_QUOTE : self.handle_auto,

420

self.ESC_QUOTE2 : self.handle_auto,

421

self.ESC_MAGIC : self.handle_magic,

422

self.ESC_HELP : self.handle_help,

423

self.ESC_SHELL : self.handle_shell_escape,

424

self.ESC_SH_CAP : self.handle_shell_escape,

425

}

426

427

# class initializations

428

Magic.__init__(self,self)

429

430

# Python source parser/formatter for syntax highlighting

431

pyformat = PyColorize.Parser().format

432

self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])

433

434

# hooks holds pointers used for user-side customizations

435

self.hooks = Struct()

436

437

self.strdispatchers = {}

438

439

# Set all default hooks, defined in the IPython.hooks module.

440

hooks = IPython.hooks

441

for hook_name in hooks.__all__:

442

# default hooks have priority 100, i.e. low; user hooks should have

443

# 0-100 priority

444

self.set_hook(hook_name,getattr(hooks,hook_name), 100)

445

#print "bound hook",hook_name

446

447

# Flag to mark unconditional exit

448

self.exit_now = False

449

450

self.usage_min = """\

451

An enhanced console for Python.

452

Some of its features are:

453

- Readline support if the readline library is present.

454

- Tab completion in the local namespace.

455

- Logging of input, see command-line options.

456

- System shell escape via ! , eg !ls.

457

- Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)

458

- Keeps track of locally defined variables via %who, %whos.

459

- Show object information with a ? eg ?x or x? (use ?? for more info).

460

"""

461

if usage: self.usage = usage

462

else: self.usage = self.usage_min

463

464

# Storage

465

self.rc = rc # This will hold all configuration information

466

self.pager = 'less'

467

# temporary files used for various purposes. Deleted at exit.

468

self.tempfiles = []

469

470

# Keep track of readline usage (later set by init_readline)

471

self.has_readline = False

472

473

# template for logfile headers. It gets resolved at runtime by the

474

# logstart method.

475

self.loghead_tpl = \

476

"""#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***

477

#log# DO NOT CHANGE THIS LINE OR THE TWO BELOW

478

#log# opts = %s

479

#log# args = %s

480

#log# It is safe to make manual edits below here.

481

#log#-----------------------------------------------------------------------

482

"""

483

# for pushd/popd management

484

try:

485

self.home_dir = get_home_dir()

486

except HomeDirError,msg:

487

fatal(msg)

488

489

self.dir_stack = []

490

491

# Functions to call the underlying shell.

492

493

# The first is similar to os.system, but it doesn't return a value,

494

# and it allows interpolation of variables in the user's namespace.

495

self.system = lambda cmd: \

496

self.hooks.shell_hook(self.var_expand(cmd,depth=2))

497

498

# These are for getoutput and getoutputerror:

499

self.getoutput = lambda cmd: \

500

getoutput(self.var_expand(cmd,depth=2),

501

header=self.rc.system_header,

502

verbose=self.rc.system_verbose)

503

504

self.getoutputerror = lambda cmd: \

505

getoutputerror(self.var_expand(cmd,depth=2),

506

header=self.rc.system_header,

507

verbose=self.rc.system_verbose)

508

509

510

# keep track of where we started running (mainly for crash post-mortem)

511

self.starting_dir = os.getcwd()

512

513

# Various switches which can be set

514

self.CACHELENGTH = 5000 # this is cheap, it's just text

515

self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__

516

self.banner2 = banner2

517

518

# TraceBack handlers:

519

520

# Syntax error handler.

521

self.SyntaxTB = SyntaxTB(color_scheme='NoColor')

522

523

# The interactive one is initialized with an offset, meaning we always

524

# want to remove the topmost item in the traceback, which is our own

525

# internal code. Valid modes: ['Plain','Context','Verbose']

526

self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',

527

color_scheme='NoColor',

528

tb_offset = 1)

529

530

# IPython itself shouldn't crash. This will produce a detailed

531

# post-mortem if it does. But we only install the crash handler for

532

# non-threaded shells, the threaded ones use a normal verbose reporter

533

# and lose the crash handler. This is because exceptions in the main

534

# thread (such as in GUI code) propagate directly to sys.excepthook,

535

# and there's no point in printing crash dumps for every user exception.

536

if self.isthreaded:

537

ipCrashHandler = ultraTB.FormattedTB()

538

else:

539

from IPython import CrashHandler

540

ipCrashHandler = CrashHandler.IPythonCrashHandler(self)

541

self.set_crash_handler(ipCrashHandler)

542

543

# and add any custom exception handlers the user may have specified

544

self.set_custom_exc(*custom_exceptions)

545

546

# indentation management

547

self.autoindent = False

548

self.indent_current_nsp = 0

549

550

# Make some aliases automatically

551

# Prepare list of shell aliases to auto-define

552

if os.name == 'posix':

553

auto_alias = ('mkdir mkdir', 'rmdir rmdir',

554

'mv mv -i','rm rm -i','cp cp -i',

555

'cat cat','less less','clear clear',

556

# a better ls

557

'ls ls -F',

558

# long ls

559

'll ls -lF')

560

# Extra ls aliases with color, which need special treatment on BSD

561

# variants

562

ls_extra = ( # color ls

563

'lc ls -F -o --color',

564

# ls normal files only

565

'lf ls -F -o --color %l | grep ^-',

566

# ls symbolic links

567

'lk ls -F -o --color %l | grep ^l',

568

# directories or links to directories,

569

'ldir ls -F -o --color %l | grep /$',

570

# things which are executable

571

'lx ls -F -o --color %l | grep ^-..x',

572

)

573

# The BSDs don't ship GNU ls, so they don't understand the

574

# --color switch out of the box

575

if 'bsd' in sys.platform:

576

ls_extra = ( # ls normal files only

577

'lf ls -lF | grep ^-',

578

# ls symbolic links

579

'lk ls -lF | grep ^l',

580

# directories or links to directories,

581

'ldir ls -lF | grep /$',

582

# things which are executable

583

'lx ls -lF | grep ^-..x',

584

)

585

auto_alias = auto_alias + ls_extra

586

elif os.name in ['nt','dos']:

587

auto_alias = ('ls dir /on',

588

'ddir dir /ad /on', 'ldir dir /ad /on',

589

'mkdir mkdir','rmdir rmdir','echo echo',

590

'ren ren','cls cls','copy copy')

591

else:

592

auto_alias = ()

593

self.auto_alias = [s.split(None,1) for s in auto_alias]

594

595

596

# Produce a public API instance

597

self.api = IPython.ipapi.IPApi(self)

598

599

# Call the actual (public) initializer

600

self.init_auto_alias()

601

602

# track which builtins we add, so we can clean up later

603

self.builtins_added = {}

604

# This method will add the necessary builtins for operation, but

605

# tracking what it did via the builtins_added dict.

606

607

#TODO: remove this, redundant

608

self.add_builtins()

609

610

611

612

613

# end __init__

614

615

def var_expand(self,cmd,depth=0):

616

"""Expand python variables in a string.

617

618

The depth argument indicates how many frames above the caller should

619

be walked to look for the local namespace where to expand variables.

620

621

The global namespace for expansion is always the user's interactive

622

namespace.

623

"""

624

625

return str(ItplNS(cmd,

626

self.user_ns, # globals

627

# Skip our own frame in searching for locals:

628

sys._getframe(depth+1).f_locals # locals

629

))

630

631

def pre_config_initialization(self):

632

"""Pre-configuration init method

633

634

This is called before the configuration files are processed to

635

prepare the services the config files might need.

636

637

self.rc already has reasonable default values at this point.

638

"""

639

rc = self.rc

640

try:

641

self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")

642

except exceptions.UnicodeDecodeError:

643

print "Your ipythondir can't be decoded to unicode!"

644

print "Please set HOME environment variable to something that"

645

print r"only has ASCII characters, e.g. c:\home"

646

print "Now it is",rc.ipythondir

647

sys.exit()

648

self.shadowhist = IPython.history.ShadowHist(self.db)

649

650

651

def post_config_initialization(self):

652

"""Post configuration init method

653

654

This is called after the configuration files have been processed to

655

'finalize' the initialization."""

656

657

rc = self.rc

658

659

# Object inspector

660

self.inspector = OInspect.Inspector(OInspect.InspectColors,

661

PyColorize.ANSICodeColors,

662

'NoColor',

663

rc.object_info_string_level)

664

665

self.rl_next_input = None

666

self.rl_do_indent = False

667

# Load readline proper

668

if rc.readline:

669

self.init_readline()

670

671

672

# local shortcut, this is used a LOT

673

self.log = self.logger.log

674

675

# Initialize cache, set in/out prompts and printing system

676

self.outputcache = CachedOutput(self,

677

rc.cache_size,

678

rc.pprint,

679

input_sep = rc.separate_in,

680

output_sep = rc.separate_out,

681

output_sep2 = rc.separate_out2,

682

ps1 = rc.prompt_in1,

683

ps2 = rc.prompt_in2,

684

ps_out = rc.prompt_out,

685

pad_left = rc.prompts_pad_left)

686

687

# user may have over-ridden the default print hook:

688

try:

689

self.outputcache.__class__.display = self.hooks.display

690

except AttributeError:

691

pass

692

693

# I don't like assigning globally to sys, because it means when

694

# embedding instances, each embedded instance overrides the previous

695

# choice. But sys.displayhook seems to be called internally by exec,

696

# so I don't see a way around it. We first save the original and then

697

# overwrite it.

698

self.sys_displayhook = sys.displayhook

699

sys.displayhook = self.outputcache

700

701

# Do a proper resetting of doctest, including the necessary displayhook

702

# monkeypatching

703

doctest_reload()

704

705

# Set user colors (don't do it in the constructor above so that it

706

# doesn't crash if colors option is invalid)

707

self.magic_colors(rc.colors)

708

709

# Set calling of pdb on exceptions

710

self.call_pdb = rc.pdb

711

712

# Load user aliases

713

for alias in rc.alias:

714

self.magic_alias(alias)

715

716

self.hooks.late_startup_hook()

717

718

for cmd in self.rc.autoexec:

719

#print "autoexec>",cmd #dbg

720

self.api.runlines(cmd)

721

722

batchrun = False

723

for batchfile in [path(arg) for arg in self.rc.args

724

if arg.lower().endswith('.ipy')]:

725

if not batchfile.isfile():

726

print "No such batch file:", batchfile

727

continue

728

self.api.runlines(batchfile.text())

729

batchrun = True

730

# without -i option, exit after running the batch file

731

if batchrun and not self.rc.interact:

732

self.exit_now = True

733

734

def add_builtins(self):

735

"""Store ipython references into the builtin namespace.

736

737

Some parts of ipython operate via builtins injected here, which hold a

738

reference to IPython itself."""

739

740

# TODO: deprecate all of these, they are unsafe

741

builtins_new = dict(__IPYTHON__ = self,

742

ip_set_hook = self.set_hook,

743

jobs = self.jobs,

744

ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),

745

ipalias = wrap_deprecated(self.ipalias),

746

ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),

747

#_ip = self.api

748

)

749

for biname,bival in builtins_new.items():

750

try:

751

# store the orignal value so we can restore it

752

self.builtins_added[biname] = __builtin__.__dict__[biname]

753

except KeyError:

754

# or mark that it wasn't defined, and we'll just delete it at

755

# cleanup

756

self.builtins_added[biname] = Undefined

757

__builtin__.__dict__[biname] = bival

758

759

# Keep in the builtins a flag for when IPython is active. We set it

760

# with setdefault so that multiple nested IPythons don't clobber one

761

# another. Each will increase its value by one upon being activated,

762

# which also gives us a way to determine the nesting level.

763

__builtin__.__dict__.setdefault('__IPYTHON__active',0)

764

765

def clean_builtins(self):

766

"""Remove any builtins which might have been added by add_builtins, or

767

restore overwritten ones to their previous values."""

768

for biname,bival in self.builtins_added.items():

769

if bival is Undefined:

770

del __builtin__.__dict__[biname]

771

else:

772

__builtin__.__dict__[biname] = bival

773

self.builtins_added.clear()

774

775

def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):

776

"""set_hook(name,hook) -> sets an internal IPython hook.

777

778

IPython exposes some of its internal API as user-modifiable hooks. By

779

adding your function to one of these hooks, you can modify IPython's

780

behavior to call at runtime your own routines."""

781

782

# At some point in the future, this should validate the hook before it

783

# accepts it. Probably at least check that the hook takes the number

784

# of args it's supposed to.

785

786

f = new.instancemethod(hook,self,self.__class__)

787

788

# check if the hook is for strdispatcher first

789

if str_key is not None:

790

sdp = self.strdispatchers.get(name, StrDispatch())

791

sdp.add_s(str_key, f, priority )

792

self.strdispatchers[name] = sdp

793

return

794

if re_key is not None:

795

sdp = self.strdispatchers.get(name, StrDispatch())

796

sdp.add_re(re.compile(re_key), f, priority )

797

self.strdispatchers[name] = sdp

798

return

799

800

dp = getattr(self.hooks, name, None)

801

if name not in IPython.hooks.__all__:

802

print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )

803

if not dp:

804

dp = IPython.hooks.CommandChainDispatcher()

805

806

try:

807

dp.add(f,priority)

808

except AttributeError:

809

# it was not commandchain, plain old func - replace

810

dp = f

811

812

setattr(self.hooks,name, dp)

813

814

815

#setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))

816

817

def set_crash_handler(self,crashHandler):

818

"""Set the IPython crash handler.

819

820

This must be a callable with a signature suitable for use as

821

sys.excepthook."""

822

823

# Install the given crash handler as the Python exception hook

824

sys.excepthook = crashHandler

825

826

# The instance will store a pointer to this, so that runtime code

827

# (such as magics) can access it. This is because during the

828

# read-eval loop, it gets temporarily overwritten (to deal with GUI

829

# frameworks).

830

self.sys_excepthook = sys.excepthook

831

832

833

def set_custom_exc(self,exc_tuple,handler):

834

"""set_custom_exc(exc_tuple,handler)

835

836

Set a custom exception handler, which will be called if any of the

837

exceptions in exc_tuple occur in the mainloop (specifically, in the

838

runcode() method.

839

840

Inputs:

841

842

- exc_tuple: a *tuple* of valid exceptions to call the defined

843

handler for. It is very important that you use a tuple, and NOT A

844

LIST here, because of the way Python's except statement works. If

845

you only want to trap a single exception, use a singleton tuple:

846

847

exc_tuple == (MyCustomException,)

848

849

- handler: this must be defined as a function with the following

850

basic interface: def my_handler(self,etype,value,tb).

851

852

This will be made into an instance method (via new.instancemethod)

853

of IPython itself, and it will be called if any of the exceptions

854

listed in the exc_tuple are caught. If the handler is None, an

855

internal basic one is used, which just prints basic info.

856

857

WARNING: by putting in your own exception handler into IPython's main

858

execution loop, you run a very good chance of nasty crashes. This

859

facility should only be used if you really know what you are doing."""

860

861

assert type(exc_tuple)==type(()) , \

862

"The custom exceptions must be given AS A TUPLE."

863

864

def dummy_handler(self,etype,value,tb):

865

print '*** Simple custom exception handler ***'

866

print 'Exception type :',etype

867

print 'Exception value:',value

868

print 'Traceback :',tb

869

print 'Source code :','\n'.join(self.buffer)

870

871

if handler is None: handler = dummy_handler

872

873

self.CustomTB = new.instancemethod(handler,self,self.__class__)

874

self.custom_exceptions = exc_tuple

875

876

def set_custom_completer(self,completer,pos=0):

877

"""set_custom_completer(completer,pos=0)

878

879

Adds a new custom completer function.

880

881

The position argument (defaults to 0) is the index in the completers

882

list where you want the completer to be inserted."""

883

884

newcomp = new.instancemethod(completer,self.Completer,

885

self.Completer.__class__)

886

self.Completer.matchers.insert(pos,newcomp)

887

888

def set_completer(self):

889

"""reset readline's completer to be our own."""

890

self.readline.set_completer(self.Completer.complete)

891

892

def _get_call_pdb(self):

893

return self._call_pdb

894

895

def _set_call_pdb(self,val):

896

897

if val not in (0,1,False,True):

898

raise ValueError,'new call_pdb value must be boolean'

899

900

# store value in instance

901

self._call_pdb = val

902

903

# notify the actual exception handlers

904

self.InteractiveTB.call_pdb = val

905

if self.isthreaded:

906

try:

907

self.sys_excepthook.call_pdb = val

908

except:

909

warn('Failed to activate pdb for threaded exception handler')

910

911

call_pdb = property(_get_call_pdb,_set_call_pdb,None,

912

'Control auto-activation of pdb at exceptions')

913

914

915

# These special functions get installed in the builtin namespace, to

916

# provide programmatic (pure python) access to magics, aliases and system

917

# calls. This is important for logging, user scripting, and more.

918

919

# We are basically exposing, via normal python functions, the three

920

# mechanisms in which ipython offers special call modes (magics for

921

# internal control, aliases for direct system access via pre-selected

922

# names, and !cmd for calling arbitrary system commands).

923

924

def ipmagic(self,arg_s):

925

"""Call a magic function by name.

926

927

Input: a string containing the name of the magic function to call and any

928

additional arguments to be passed to the magic.

929

930

ipmagic('name -opt foo bar') is equivalent to typing at the ipython

931

prompt:

932

933

In[1]: %name -opt foo bar

934

935

To call a magic without arguments, simply use ipmagic('name').

936

937

This provides a proper Python function to call IPython's magics in any

938

valid Python code you can type at the interpreter, including loops and

939

compound statements. It is added by IPython to the Python builtin

940

namespace upon initialization."""

941

942

args = arg_s.split(' ',1)

943

magic_name = args[0]

944

magic_name = magic_name.lstrip(self.ESC_MAGIC)

945

946

try:

947

magic_args = args[1]

948

except IndexError:

949

magic_args = ''

950

fn = getattr(self,'magic_'+magic_name,None)

951

if fn is None:

952

error("Magic function `%s` not found." % magic_name)

953

else:

954

magic_args = self.var_expand(magic_args,1)

955

return fn(magic_args)

956

957

def ipalias(self,arg_s):

958

"""Call an alias by name.

959

960

Input: a string containing the name of the alias to call and any

961

additional arguments to be passed to the magic.

962

963

ipalias('name -opt foo bar') is equivalent to typing at the ipython

964

prompt:

965

966

In[1]: name -opt foo bar

967

968

To call an alias without arguments, simply use ipalias('name').

969

970

This provides a proper Python function to call IPython's aliases in any

971

valid Python code you can type at the interpreter, including loops and

972

compound statements. It is added by IPython to the Python builtin

973

namespace upon initialization."""

974

975

args = arg_s.split(' ',1)

976

alias_name = args[0]

977

try:

978

alias_args = args[1]

979

except IndexError:

980

alias_args = ''

981

if alias_name in self.alias_table:

982

self.call_alias(alias_name,alias_args)

983

else:

984

error("Alias `%s` not found." % alias_name)

985

986

def ipsystem(self,arg_s):

987

"""Make a system call, using IPython."""

988

989

self.system(arg_s)

990

991

def complete(self,text):

992

"""Return a sorted list of all possible completions on text.

993

994

Inputs:

995

996

- text: a string of text to be completed on.

997

998

This is a wrapper around the completion mechanism, similar to what

999

readline does at the command line when the TAB key is hit. By

1000

exposing it as a method, it can be used by other non-readline

1001

environments (such as GUIs) for text completion.

1002

1003

Simple usage example:

1004

1005

In [1]: x = 'hello'

1006

1007

In [2]: __IP.complete('x.l')

1008

Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""

1009

1010

complete = self.Completer.complete

1011

state = 0

1012

# use a dict so we get unique keys, since ipyhton's multiple

1013

# completers can return duplicates. When we make 2.4 a requirement,

1014

# start using sets instead, which are faster.

1015

comps = {}

1016

while True:

1017

newcomp = complete(text,state,line_buffer=text)

1018

if newcomp is None:

1019

break

1020

comps[newcomp] = 1

1021

state += 1

1022

outcomps = comps.keys()

1023

outcomps.sort()

1024

return outcomps

1025

1026

def set_completer_frame(self, frame=None):

1027

if frame:

1028

self.Completer.namespace = frame.f_locals

1029

self.Completer.global_namespace = frame.f_globals

1030

else:

1031

self.Completer.namespace = self.user_ns

1032

self.Completer.global_namespace = self.user_global_ns

1033

1034

def init_auto_alias(self):

1035

"""Define some aliases automatically.

1036

1037

These are ALL parameter-less aliases"""

1038

1039

for alias,cmd in self.auto_alias:

1040

self.getapi().defalias(alias,cmd)

1041

1042

1043

def alias_table_validate(self,verbose=0):

1044

"""Update information about the alias table.

1045

1046

In particular, make sure no Python keywords/builtins are in it."""

1047

1048

no_alias = self.no_alias

1049

for k in self.alias_table.keys():

1050

if k in no_alias:

1051

del self.alias_table[k]

1052

if verbose:

1053

print ("Deleting alias <%s>, it's a Python "

1054

"keyword or builtin." % k)

1055

1056

def set_autoindent(self,value=None):

1057

"""Set the autoindent flag, checking for readline support.

1058

1059

If called with no arguments, it acts as a toggle."""

1060

1061

if not self.has_readline:

1062

if os.name == 'posix':

1063

warn("The auto-indent feature requires the readline library")

1064

self.autoindent = 0

1065

return

1066

if value is None:

1067

self.autoindent = not self.autoindent

1068

else:

1069

self.autoindent = value

1070

1071

def rc_set_toggle(self,rc_field,value=None):

1072

"""Set or toggle a field in IPython's rc config. structure.

1073

1074

If called with no arguments, it acts as a toggle.

1075

1076

If called with a non-existent field, the resulting AttributeError

1077

exception will propagate out."""

1078

1079

rc_val = getattr(self.rc,rc_field)

1080

if value is None:

1081

value = not rc_val

1082

setattr(self.rc,rc_field,value)

1083

1084

def user_setup(self,ipythondir,rc_suffix,mode='install'):

1085

"""Install the user configuration directory.

1086

1087

Can be called when running for the first time or to upgrade the user's

1088

.ipython/ directory with the mode parameter. Valid modes are 'install'

1089

and 'upgrade'."""

1090

1091

def wait():

1092

try:

1093

raw_input("Please press <RETURN> to start IPython.")

1094

except EOFError:

1095

print >> Term.cout

1096

print '*'*70

1097

1098

cwd = os.getcwd() # remember where we started

1099

glb = glob.glob

1100

print '*'*70

1101

if mode == 'install':

1102

print \

1103

"""Welcome to IPython. I will try to create a personal configuration directory

1104

where you can customize many aspects of IPython's functionality in:\n"""

1105

else:

1106

print 'I am going to upgrade your configuration in:'

1107

1108

print ipythondir

1109

1110

rcdirend = os.path.join('IPython','UserConfig')

1111

cfg = lambda d: os.path.join(d,rcdirend)

1112

try:

1113

rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]

1114

print "Initializing from configuration",rcdir

1115

except IndexError:

1116

warning = """

1117

Installation error. IPython's directory was not found.

1118

1119

Check the following:

1120

1121

The ipython/IPython directory should be in a directory belonging to your

1122

PYTHONPATH environment variable (that is, it should be in a directory

1123

belonging to sys.path). You can copy it explicitly there or just link to it.

1124

1125

IPython will create a minimal default configuration for you.

1126

1127

"""

1128

warn(warning)

1129

wait()

1130

1131

if sys.platform =='win32':

1132

inif = 'ipythonrc.ini'

1133

else:

1134

inif = 'ipythonrc'

1135

minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }

1136

os.makedirs(ipythondir, mode = 0777)

1137

for f, cont in minimal_setup.items():

1138

open(ipythondir + '/' + f,'w').write(cont)

1139

1140

return

1141

1142

if mode == 'install':

1143

try:

1144

shutil.copytree(rcdir,ipythondir)

1145

os.chdir(ipythondir)

1146

rc_files = glb("ipythonrc*")

1147

for rc_file in rc_files:

1148

os.rename(rc_file,rc_file+rc_suffix)

1149

except:

1150

warning = """

1151

1152

There was a problem with the installation:

1153

%s

1154

Try to correct it or contact the developers if you think it's a bug.

1155

IPython will proceed with builtin defaults.""" % sys.exc_info()[1]

1156

warn(warning)

1157

wait()

1158

return

1159

1160

elif mode == 'upgrade':

1161

try:

1162

os.chdir(ipythondir)

1163

except:

1164

print """

1165

Can not upgrade: changing to directory %s failed. Details:

1166

%s

1167

""" % (ipythondir,sys.exc_info()[1])

1168

wait()

1169

return

1170

else:

1171

sources = glb(os.path.join(rcdir,'[A-Za-z]*'))

1172

for new_full_path in sources:

1173

new_filename = os.path.basename(new_full_path)

1174

if new_filename.startswith('ipythonrc'):

1175

new_filename = new_filename + rc_suffix

1176

# The config directory should only contain files, skip any

1177

# directories which may be there (like CVS)

1178

if os.path.isdir(new_full_path):

1179

continue

1180

if os.path.exists(new_filename):

1181

old_file = new_filename+'.old'

1182

if os.path.exists(old_file):

1183

os.remove(old_file)

1184

os.rename(new_filename,old_file)

1185

shutil.copy(new_full_path,new_filename)

1186

else:

1187

raise ValueError,'unrecognized mode for install:',`mode`

1188

1189

# Fix line-endings to those native to each platform in the config

1190

# directory.

1191

try:

1192

os.chdir(ipythondir)

1193

except:

1194

print """

1195

Problem: changing to directory %s failed.

1196

Details:

1197

%s

1198

1199

Some configuration files may have incorrect line endings. This should not

1200

cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])

1201

wait()

1202

else:

1203

for fname in glb('ipythonrc*'):

1204

try:

1205

native_line_ends(fname,backup=0)

1206

except IOError:

1207

pass

1208

1209

if mode == 'install':

1210

print """

1211

Successful installation!

1212

1213

Please read the sections 'Initial Configuration' and 'Quick Tips' in the

1214

IPython manual (there are both HTML and PDF versions supplied with the

1215

distribution) to make sure that your system environment is properly configured

1216

to take advantage of IPython's features.

1217

1218

Important note: the configuration system has changed! The old system is

1219

still in place, but its setting may be partly overridden by the settings in

1220

"~/.ipython/ipy_user_conf.py" config file. Please take a look at the file

1221

if some of the new settings bother you.

1222

1223

"""

1224

else:

1225

print """

1226

Successful upgrade!

1227

1228

All files in your directory:

1229

%(ipythondir)s

1230

which would have been overwritten by the upgrade were backed up with a .old

1231

extension. If you had made particular customizations in those files you may

1232

want to merge them back into the new files.""" % locals()

1233

wait()

1234

os.chdir(cwd)

1235

# end user_setup()

1236

1237

def atexit_operations(self):

1238

"""This will be executed at the time of exit.

1239

1240

Saving of persistent data should be performed here. """

1241

1242

#print '*** IPython exit cleanup ***' # dbg

1243

# input history

1244

self.savehist()

1245

1246

# Cleanup all tempfiles left around

1247

for tfile in self.tempfiles:

1248

try:

1249

os.unlink(tfile)

1250

except OSError:

1251

pass

1252

1253

self.hooks.shutdown_hook()

1254

1255

def savehist(self):

1256

"""Save input history to a file (via readline library)."""

1257

1258

if not self.has_readline:

1259

return

1260

1261

try:

1262

self.readline.write_history_file(self.histfile)

1263

except:

1264

print 'Unable to save IPython command history to file: ' + \

1265

`self.histfile`

1266

1267

def reloadhist(self):

1268

"""Reload the input history from disk file."""

1269

1270

if self.has_readline:

1271

self.readline.clear_history()

1272

self.readline.~~read~~_history~~_file~~(~~self~~.~~shell~~.~~histfile~~)

1273

1274

def history_saving_wrapper(self, func):

1275

""" Wrap func for readline history saving

1276

1277

Convert func into callable that saves & restores

1278

history around the call """

1279

1280

if not self.has_readline:

1281

return func

1282

1283

def wrapper():

1284

self.~~savehist~~()

1285

~~try~~:

1286

func()

1287

finally:

1288

readline.read_history_file(self.histfile)

1289

return wrapper

1290

1291

1292

def pre_readline(self):

1293

"""readline hook to be used at the start of each line.

1294

1295

Currently it handles auto-indent only."""

1296

1297

#debugx('self.indent_current_nsp','pre_readline:')

1298

1299

if self.rl_do_indent:

1300

self.readline.insert_text(self.indent_current_str())

1301

if self.rl_next_input is not None:

1302

self.readline.insert_text(self.rl_next_input)

1303

self.rl_~~next_input~~ = ~~None~~

1304

1305

def init_readline(self):

1306

"""Command history completion/saving/reloading."""

1307

1308

1309

import IPython.rlineimpl as readline

1310

1311

if not readline.have_readline:

1312

self.has_readline = 0

1313

self.readline = None

1314

# no point in bugging windows users with this every time:

1315

warn('Readline services not available on this platform.')

1316

else:

1317

sys.~~modules~~['readline'] = ~~readli~~ne

1318

import atexit

1319

from IPython.completer import IPCompleter

1320

self.Completer = IPCompleter(self,

1321

self.user_ns,

1322

self.user_global_ns,

1323

self.rc.readline_omit__names,

1324

self.alias_table)

1325

sdisp = self.strdispatchers.get('complete_command', StrDispatch())

1326

self.strdispatchers['complete_command'] = sdisp

1327

self.Completer.custom_completers = sdisp

1328

# Platform-specific configuration

1329

if os.name == 'nt':

1330

self.readline_startup_hook = readline.set_pre_input_hook

1331

else:

1332

self.readline_startup_hook = readline.set_startup_hook

1333

1334

# Load user's initrc file (readline config)

1335

# Or if libedit is used, load editrc.

1336

inputrc_name = os.environ.get('INPUTRC')

1337

if inputrc_name is None:

1338

home_dir = get_home_dir()

1339

if home_dir is not None:

1340

inputrc_name = '.inputrc'

1341

if readline.uses_libedit:

1342

inputrc_name = '.editrc'

1343

inputrc_name = os.path.join(home_dir, inputrc_name)

1344

if os.path.isfile(inputrc_name):

1345

try:

1346

~~readline~~.~~read_init_file~~(inputrc_name)

1347

except:

1348

warn('Problems reading readline initialization file <%s>'

1349

% ~~inputrc_name~~)

1350

1351

self.has_readline = 1

1352

self.readline = readline

1353

# save this in sys so embedded copies can restore it properly

1354

sys.ipcompleter = self.Completer.complete

1355

self.~~set_completer~~()

1356

1357

# Configure readline according to user's prefs

1358

# This is only done if GNU readline is being used. If libedit

1359

# is being used (as on Leopard) the readline config is

1360

# not run as the syntax for libedit is different.

1361

if not readline.uses_libedit:

1362

for rlcommand in self.rc.readline_parse_and_bind:

1363

readline.parse_and_bind(rlcommand)

1364

1365

# remove some chars from the delimiters list

1366

delims = readline.get_completer_delims()

1367

delims = delims.translate(string._idmap,

1368

self.rc.readline_remove_delims)

1369

readline.set_completer_delims(delims)

1370

# otherwise we end up with a monster history after a while:

1371

readline.set_history_length(1000)

1372

try:

1373

#print '*** Reading readline history' # dbg

1374

readline.read_history_file(self.histfile)

1375

except IOError:

1376

pass # It doesn't exist yet.

1377

1378

atexit.register(self.atexit_operations)

1379

~~del~~ ~~atexit~~

1380

1381

# Configure auto-indent for all platforms

1382

self.set_autoindent(self.rc.autoindent)

1383

1384

def ask_yes_no(self,prompt,default=True):

1385

if self.rc.quiet:

1386

return True

1387

return ask_yes_no(prompt,default)

1388

1389

def _should_recompile(self,e):

1390

"""Utility routine for edit_syntax_error"""

1391

1392

if e.filename in ('<ipython console>','<input>','<string>',

1393

'<console>','<BackgroundJob compilation>',

1394

None):

1395

1396

return False

1397

try:

1398

if (self.rc.autoedit_syntax and

1399

not self.ask_yes_no('Return to editor to correct syntax error? '

1400

'[Y/n] ','y')):

1401

return False

1402

except EOFError:

1403

return False

1404

1405

def int0(x):

1406

try:

1407

return ~~int~~(x)

1408

except TypeError:

1409

return 0

1410

# always pass integer line and offset values to editor hook

1411

self.hooks.fix_error_editor(e.filename,

1412

int0(e.lineno),int0(e.offset),e.msg)

1413

return ~~True~~

1414

1415

def edit_syntax_error(self):

1416

"""The bottom half of the syntax error handler called in the main loop.

1417

1418

Loop until syntax error is fixed or user cancels.

1419

"""

1420

1421

while self.SyntaxTB.last_syntax_error:

1422

# copy and clear last_syntax_error

1423

err = self.SyntaxTB.clear_err_state()

1424

if not self._should_recompile(err):

1425

return

1426

try:

1427

# may set last_syntax_error again if a SyntaxError is raised

1428

self.safe_execfile(err.filename,self.user_ns)

1429

~~except~~:

1430

self.showtraceback()

1431

else:

1432

try:

1433

f = file(err.filename)

1434

~~try~~:

1435

sys.displayhook(f.read())

1436

~~finall~~y:

1437

f.~~close~~()

1438

~~except~~:

1439

~~self~~.~~showtraceback~~()

1440

1441

def showsyntaxerror(self, filename=None):

1442

"""Display the syntax error that just occurred.

1443

1444

This doesn't display a stack trace because there isn't one.

1445

1446

If a filename is given, it is stuffed in the exception instead

1447

of what was there before (because Python's parser always uses

1448

"<string>" when reading from a string).

1449

"""

1450

etype, value, last_traceback = sys.exc_info()

1451

1452

# See note about these variables in showtraceback() below

1453

sys.last_type = etype

1454

sys.last_value = value

1455

sys.last_traceback = last_traceback

1456

1457

if filename and etype is SyntaxError:

1458

# Work hard to stuff the correct filename in the exception

1459

try:

1460

msg, (dummy_filename, lineno, offset, line) = value

1461

except:

1462

# Not the format we expect; leave it alone

1463

~~pass~~

1464

else:

1465

# Stuff in the right filename

1466

try:

1467

# Assume SyntaxError is a class exception

1468

value = SyntaxError(msg, (filename, lineno, offset, line))

1469

except:

1470

# If that failed, assume SyntaxError is a string

1471

value = msg, (filename, lineno, offset, line)

1472

self.SyntaxTB(etype,value,[])

1473

1474

def debugger(self,force=False):

1475

"""Call the pydb/pdb debugger.

1476

1477

Keywords:

1478

1479

- force(False): by default, this routine checks the instance call_pdb

1480

flag and does not actually invoke the debugger if the flag is false.

1481

The 'force' option forces the debugger to activate even if the flag

1482

is false.

1483

"""

1484

1485

if not (force or self.call_pdb):

1486

~~return~~

1487

1488

if not hasattr(sys,'last_traceback'):

1489

error('No traceback has been produced, nothing to debug.')

1490

return

1491

1492

# use pydb if available

1493

if Debugger.has_pydb:

1494

from pydb import pm

1495

else:

1496

# fallback to our internal debugger

1497

pm = lambda : self.InteractiveTB.debugger(force=True)

1498

self.history_saving_wrapper(pm)()

1499

1500

def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):

1501

"""Display the exception that just occurred.

1502

1503

If nothing is known about the exception, this is the method which

1504

should be used throughout the code for presenting user tracebacks,

1505

rather than directly invoking the InteractiveTB object.

1506

1507

A specific showsyntaxerror() also exists, but this method can take

1508

care of calling it if needed, so unless you are explicitly catching a

1509

SyntaxError exception, don't try to analyze the stack manually and

1510

simply call this method."""

1511

1512

1513

# Though this won't be called by syntax errors in the input line,

1514

# there may be SyntaxError cases whith imported code.

1515

1516

~~try~~:

1517

if exc_tuple is None:

1518

etype, value, tb = sys.exc_info()

1519

~~else~~:

1520

etype, value, tb = exc_tuple

1521

1522

if etype is SyntaxError:

1523

self.showsyntaxerror(filename)

1524

elif etype is IPython.ipapi.UsageError:

1525

print "UsageError:", value

1526

else:

1527

# WARNING: these variables are somewhat deprecated and not

1528

# necessarily safe to use in a threaded environment, but tools

1529

# like pdb depend on their existence, so let's set them. If we

1530

# find problems in the field, we'll need to revisit their use.

1531

sys.last_type = etype

1532

sys.last_value = value

1533

sys.last_traceback = tb

1534

1535

if etype in self.custom_exceptions:

1536

self.CustomTB(etype,value,tb)

1537

else:

1538

self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)

1539

if self.InteractiveTB.call_pdb and self.has_readline:

1540

# pdb mucks up readline, fix it back

1541

self.set_completer()

1542

except KeyboardInterrupt:

1543

self.write("\nKeyboardInterrupt\n")

1544

1545

1546

1547

def mainloop(self,banner=None):

1548

"""Creates the local namespace and starts the mainloop.

1549

1550

If an optional banner argument is given, it will override the

1551

internally created default banner."""

1552

1553

if self.rc.c: # Emulate Python's -c option

1554

self.exec_init_cmd()

1555

if banner is None:

1556

if not self.rc.banner:

1557

banner = ''

1558

# banner is string? Use it directly!

1559

elif isinstance(self.rc.banner,basestring):

1560

~~banner~~ = self.rc.banner

1561

else:

1562

banner = self.BANNER+self.banner2

1563

1564

while 1:

1565

try:

1566

self.interact(banner)

1567

#self.interact_with_readline()

1568

# XXX for testing of a readline-decoupled repl loop, call interact_with_readline above

1569

1570

~~break~~

1571

except KeyboardInterrupt:

1572

# this should not be necessary, but KeyboardInterrupt

1573

# handling seems rather unpredictable...

1574

self.write("\nKeyboardInterrupt in interact()\n")

1575

1576

def exec_init_cmd(self):

1577

"""Execute a command given at the command line.

1578

1579

This emulates Python's -c option."""

1580

1581

#sys.argv = ['-c']

1582

self.push(self.prefilter(self.rc.c, False))

1583

if not self.rc.interact:

1584

self.exit_now = True

1585

1586

def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):

1587

"""Embeds IPython into a running python program.

1588

1589

Input:

1590

1591

- header: An optional header message can be specified.

1592

1593

- local_ns, global_ns: working namespaces. If given as None, the

1594

IPython-initialized one is updated with __main__.__dict__, so that

1595

program variables become visible but user-specific configuration

1596

remains possible.

1597

1598

- stack_depth: specifies how many levels in the stack to go to

1599

looking for namespaces (when local_ns and global_ns are None). This

1600

allows an intermediate caller to make sure that this function gets

1601

the namespace from the intended level in the stack. By default (0)

1602

it will get its locals and globals from the immediate caller.

1603

1604

Warning: it's possible to use this in a program which is being run by

1605

IPython itself (via %run), but some funny things will happen (a few

1606

globals get overwritten). In the future this will be cleaned up, as

1607

there is no fundamental reason why it can't work perfectly."""

1608

1609

# Get locals and globals from caller

1610

if local_ns is None or global_ns is None:

1611

call_frame = sys._getframe(stack_depth).f_back

1612

1613

if local_ns is None:

1614

local_ns = call_frame.f_locals

1615

if global_ns is None:

1616

global_ns = call_frame.f_globals

1617

1618

# Update namespaces and fire up interpreter

1619

1620

# The global one is easy, we can just throw it in

1621

self.user_global_ns = global_ns

1622

1623

# but the user/local one is tricky: ipython needs it to store internal

1624

# data, but we also need the locals. We'll copy locals in the user

1625

# one, but will track what got copied so we can delete them at exit.

1626

# This is so that a later embedded call doesn't see locals from a

1627

# previous call (which most likely existed in a separate scope).

1628

local_varnames = local_ns.keys()

1629

self.user_ns.update(local_ns)

1630

1631

# Patch for global embedding to make sure that things don't overwrite

1632

# user globals accidentally. Thanks to Richard <rxe@renre-europe.com>

1633

# FIXME. Test this a bit more carefully (the if.. is new)

1634

if local_ns is None and global_ns is None:

1635

self.user_global_ns.update(__main__.__dict__)

1636

1637

# make sure the tab-completer has the correct frame information, so it

1638

# actually completes using the frame's locals/globals

1639

self.set_completer_frame()

1640

1641

# before activating the interactive mode, we need to make sure that

1642

# all names in the builtin namespace needed by ipython point to

1643

# ourselves, and not to other instances.

1644

self.add_builtins()

1645

1646

self.interact(header)

1647

1648

# now, purge out the user namespace from anything we might have added

1649

# from the caller's local namespace

1650

delvar = self.user_ns.pop

1651

for var in local_varnames:

1652

delvar(var,None)

1653

# and clean builtins we may have overridden

1654

self.clean_builtins()

1655

1656

def interact_prompt(self):

1657

""" Print the prompt (in read-eval-print loop)

1658

1659

Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not

1660

used in standard IPython flow.

1661

"""

1662

if self.more:

1663

try:

1664

prompt = self.hooks.generate_prompt(True)

1665

except:

1666

self.showtraceback()

1667

if self.autoindent:

1668

self.rl_do_indent = True

1669

1670

else:

1671

try:

1672

prompt = self.hooks.generate_prompt(False)

1673

except:

1674

self.showtraceback()

1675

self.write(prompt)

1676

1677

def interact_handle_input(self,line):

1678

""" Handle the input line (in read-eval-print loop)

1679

1680

Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not

1681

used in standard IPython flow.

1682

"""

1683

if line.lstrip() == line:

1684

self.shadowhist.add(line.strip())

1685

lineout = self.prefilter(line,self.more)

1686

1687

if line.strip():

1688

if self.more:

1689

self.input_hist_raw[-1] += '%s\n' % line

1690

else:

1691

self.input_hist_raw.append('%s\n' % line)

1692

1693

1694

self.more = self.push(lineout)

1695

if (self.SyntaxTB.last_syntax_error and

1696

self.rc.autoedit_syntax):

1697

self.edit_syntax_error()

1698

1699

def interact_with_readline(self):

1700

""" Demo of using interact_handle_input, interact_prompt

1701

1702

This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),

1703

it should work like this.

1704

"""

1705

self.readline_startup_hook(self.pre_readline)

1706

while not self.exit_now:

1707

self.interact_prompt()

1708

if self.more:

1709

self.rl_do_indent = True

1710

else:

1711

self.rl_do_indent = False

1712

line = raw_input_original().decode(self.stdin_encoding)

1713

self.interact_handle_input(line)

1714

1715

1716

def interact(self, banner=None):

1717

"""Closely emulate the interactive Python console.

1718

1719

The optional banner argument specify the banner to print

1720

before the first interaction; by default it prints a banner

1721

similar to the one printed by the real Python interpreter,

1722

followed by the current class name in parentheses (so as not

1723

to confuse this with the real interpreter -- since it's so

1724

close!).

1725

1726

"""

1727

1728

if self.exit_now:

1729

# batch run -> do not interact

1730

return

1731

cprt = 'Type "copyright", "credits" or "license" for more information.'

1732

if banner is None:

1733

self.write("Python %s on %s\n%s\n(%s)\n" %

1734

(sys.version, sys.platform, cprt,

1735

self.__class__.__name__))

1736

~~els~~e:

1737

self.write(~~banner~~)

1738

1739

more = 0

1740

1741

# Mark activity in the builtins

1742

__builtin__.__dict__['__IPYTHON__active'] += 1

1743

1744

if self.has_readline:

1745

self.readline_startup_hook(self.pre_readline)

1746

# exit_now is set by a call to %Exit or %Quit

1747

1748

~~while~~ ~~not~~ self.~~exit_now~~:

1749

self.hooks.pre_prompt_hook()

1750

if more:

1751

try:

1752

prompt = self.hooks.generate_prompt(True)

1753

except:

1754

self.showtraceback()

1755

if ~~self~~.~~autoindent~~:

1756

~~self~~.~~rl_do_inden~~t = True

1757

1758

else:

1759

~~try~~:

1760

prompt = self.hooks.generate_prompt(False)

1761

~~except~~:

1762

self.showtraceback()

1763

try:

1764

~~line~~ = self.~~raw_inpu~~t(~~prompt~~,~~mor~~e)

1765

if ~~self~~.~~exit_now~~:

1766

# quick exit on sys.std[in|out] close

1767

~~break~~

1768

if self.~~autoindent~~:

1769

self.~~rl_do_indent~~ = ~~False~~

1770

1771

except KeyboardInterrupt:

1772

#double-guard against keyboardinterrupts during kbdint handling

1773

try:

1774

self.write('\nKeyboardInterrupt\n')

1775

self.resetbuffer()

1776

# keep cache in sync with the prompt counter:

1777

self.outputcache.prompt_count -= 1

1778

1779

if self.~~autoindent~~:

1780

self.indent_current_nsp = 0

1781

~~more~~ = 0

1782

except KeyboardInterrupt:

1783

~~pass~~

1784

except EOFError:

1785

if self.autoindent:

1786

self.rl_do_indent = False

1787

self.readline_startup_hook(None)

1788

self.write('\n')

1789

self.~~exit~~()

1790

except bdb.BdbQuit:

1791

warn('The Python debugger has exited with a BdbQuit exception.\n'

1792

'Because of how pdb handles the stack, it is impossible\n'

1793

'for IPython to properly format this particular exception.\n'

1794

'IPython will resume normal operation.')

1795

except:

1796

# exceptions here are VERY RARE, but they can be triggered

1797

# asynchronously by signal handlers, for example.

1798

self.showtraceback()

1799

e~~lse~~:

1800

more = self.push(line)

1801

if (self.SyntaxTB.last_syntax_error and

1802

self.rc.~~autoedit_syntax~~):

1803

self.edit_syntax_error()

1804

1805

# We are off again...

1806

__builtin__.__dict__['__IPYTHON__active'] -= 1

1807

1808

def excepthook(self, etype, value, tb):

1809

"""One more defense for GUI apps that call sys.excepthook.

1810

1811

GUI frameworks like wxPython trap exceptions and call

1812

sys.excepthook themselves. I guess this is a feature that

1813

enables them to keep running after exceptions that would

1814

otherwise kill their mainloop. This is a bother for IPython

1815

which excepts to catch all of the program exceptions with a try:

1816

except: statement.

1817

1818

Normally, IPython sets sys.excepthook to a CrashHandler instance, so if

1819

any app directly invokes sys.excepthook, it will look to the user like

1820

IPython crashed. In order to work around this, we can disable the

1821

CrashHandler and replace it with this excepthook instead, which prints a

1822

regular traceback using our InteractiveTB. In this fashion, apps which

1823

call sys.excepthook will generate a regular-looking exception from

1824

IPython, and the CrashHandler will only be triggered by real IPython

1825

crashes.

1826

1827

This hook should be used sparingly, only in places which are not likely

1828

to be true IPython errors.

1829

"""

1830

self.showtraceback((etype,value,tb),tb_offset=0)

1831

1832

def expand_aliases(self,fn,rest):

1833

""" Expand multiple levels of aliases:

1834

1835

if:

1836

1837

alias foo bar /tmp

1838

alias baz foo

1839

1840

~~then:~~

1841

1842

baz huhhahhei -> bar /tmp huhhahhei

1843

1844

~~"""~~

1845

line = fn + " " + rest

1846

1847

done = Set()

1848

while 1:

1849

pre,fn,rest = prefilter.splitUserInput(line,

1850

prefilter.shell_line_split)

1851

if fn in self.alias_table:

1852

if fn in done:

1853

warn("Cyclic alias definition, repeated '%s'" % fn)

1854

return ""

1855

done.add(fn)

1856

1857

l2 = self.transform_alias(fn,rest)

1858

~~# dir -> dir~~

1859

# print "alias",line, "->",l2 #dbg

1860

if l2 == line:

1861

break

1862

# ls -> ls -F should not recurse forever

1863

if l2.split(None,1)[0] == line.split(None,1)[0]:

1864

~~line~~ = l2

1865

break

1866

1867

line=l2

1868

1869

1870

# print "al expand to",line #dbg

1871

~~else~~:

1872

~~break~~

1873

1874

return line

1875

1876

def transform_alias(self, alias,rest=''):

1877

""" Transform alias to system command string.

1878

"""

1879

trg = self.alias_table[alias]

1880

1881

nargs,cmd = trg

1882

# print trg #dbg

1883

if ' ' in cmd and os.path.isfile(cmd):

1884

cmd = '"%s"' % cmd

1885

1886

# Expand the %l special to be the user's input line

1887

if cmd.find('%l') >= 0:

1888

cmd = cmd.~~replace~~(~~'%l'~~,~~rest~~)

1889

rest = ''

1890

if nargs==0:

1891

# Simple, argument-less aliases

1892

cmd = '%s %s' % (~~cmd~~,rest)

1893

else:

1894

# Handle aliases with positional arguments

1895

args = rest.split(None,nargs)

1896

if len(args)< nargs:

1897

error('Alias <%s> requires %s arguments, %s given.' %

1898

(alias,nargs,len(args)))

1899

~~return~~ None

1900

cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))

1901

# Now call the macro, evaluating in the user's namespace

1902

#print 'new command: <%r>' % cmd # dbg

1903

return ~~cmd~~

1904

1905

def call_alias(self,alias,rest=''):

1906

"""Call an alias given its name and the rest of the line.

1907

1908

This is only used to provide backwards compatibility for users of

1909

ipalias(), use of which is not recommended for anymore."""

1910

1911

# Now call the macro, evaluating in the user's namespace

1912

cmd = self.transform_alias(alias, rest)

1913

try:

1914

self.system(cmd)

1915

except:

1916

self.showtraceback()

1917

1918

def indent_current_str(self):

1919

"""return the current level of indentation as a string"""

1920

return self.indent_current_nsp * ' '

1921

1922

def ~~auto~~indent_~~update~~(self,~~line~~):

1923

"""Keep track of the indent level."""

1924

1925

#debugx('line')

1926

#debugx('self.indent_current_nsp')

1927

if self.autoindent:

1928

if line:

1929

inisp = num_ini_spaces(line)

1930

if ~~inisp~~ < self.indent_current_nsp:

1931

self.indent_current_nsp = inisp

1932

1933

if line[-1] == ':':

1934

self.indent_current_nsp += 4

1935

~~elif~~ ~~dedent_re~~.~~match~~(~~line~~):

1936

self.indent_current_nsp -= 4

1937

else:

1938

self.indent_current_nsp = 0

1939

1940

def runlines(self,lines):

1941

"""Run a string of one or more lines of source.

1942

1943

This method is capable of running a string containing multiple source

1944

lines, as if they had been entered at the IPython prompt. Since it

1945

exposes IPython's processing machinery, the given strings can contain

1946

magic calls (%magic), special shell access (!cmd), etc."""

1947

1948

# We must start with a clean buffer, in case this is run from an

1949

# interactive IPython session (via a magic, for example).

1950

self.resetbuffer()

1951

lines = lines.split('\n')

1952

more = 0

1953

1954

for line in lines:

1955

# skip blank lines so we don't mess up the prompt counter, but do

1956

# NOT skip even a blank line if we are in a code block (more is

1957

# true)

1958

1959

1960

if line or more:

1961

# push to raw history, so hist line numbers stay in sync

1962

self.input_hist_raw.append("# " + line + "\n")

1963

more = self.push(self.prefilter(line,more))

1964

# IPython's runsource returns None if there was an error

1965

# compiling the code. This allows us to stop processing right

1966

# away, so the user gets the error message at the right place.

1967

if more is None:

1968

break

1969

else:

1970

self.input_hist_raw.append("\n")

1971

# final newline in case the input didn't have it, so that the code

1972

# actually does get executed

1973

if ~~mor~~e:

1974

self.~~push~~('\n')

1975

1976

def runsource(self, source, filename='<input>', symbol='single'):

1977

"""Compile and run some source in the interpreter.

1978

1979

Arguments are as for compile_command().

1980

1981

One several things can happen:

1982

1983

~~1) The input is incorrect;~~ compile_command() ~~raised an~~

1984

exception (SyntaxError or OverflowError). A syntax traceback

1985

will be printed by calling the showsyntaxerror() method.

1986

1987

2) The input is incomplete, and more input is required;

1988

compile_command() returned None. Nothing happens.

1989

1990

3) The input is complete; compile_command() returned a code

1991

object. The code is executed by calling self.runcode() (which

1992

also handles run-time exceptions, except for SystemExit).

1993

1994

The return value is:

1995

1996

- True in case 2

1997

1998

- False in the other cases, unless an exception is raised, where

1999

None is returned instead. This can be used by external callers to

2000

know whether to continue feeding input or not.

2001

2002

The return value can be used to decide whether to use sys.ps1 or

2003

sys.ps2 to prompt the next line."""

2004

2005

# if the source code has leading blanks, add 'if 1:\n' to it

2006

# this allows execution of indented pasted code. It is tempting

2007

# to add '\n' at the end of source to run commands like ' a=1'

2008

# directly, but this fails for more complicated scenarios

2009

source=source.encode(self.stdin_encoding)

2010

if source[:1] in [' ', '\t']:

2011

source = 'if 1:\n%s' % source

2012

2013

try:

2014

code = self.compile(source,filename,symbol)

2015

except (OverflowError, SyntaxError, ValueError):

2016

# Case 1

2017

self.showsyntaxerror(filename)

2018

return None

2019

2020

if code is None:

2021

# Case 2

2022

return ~~Tru~~e

2023

2024

# Case 3

2025

# We store the code object so that threaded shells and

2026

# custom exception handlers can access all this info if needed.

2027

# The source corresponding to this can be obtained from the

2028

# buffer attribute as '\n'.join(self.buffer).

2029

self.code_to_run = code

2030

# now actually execute the code object

2031

if self.runcode(code) == 0:

2032

return False

2033

else:

2034

return None

2035

2036

def runcode(self,code_obj):

2037

"""Execute a code object.

2038

2039

When an exception occurs, self.showtraceback() is called to display a

2040

traceback.

2041

2042

Return value: a flag indicating whether the code to be run completed

2043

successfully:

2044

2045

- 0: successful execution.

2046

- 1: an error occurred.

2047

"""

2048

2049

# Set our own excepthook in case the user code tries to call it

2050

# directly, so that the IPython crash handler doesn't get triggered

2051

old_excepthook,sys.excepthook = sys.excepthook, self.excepthook

2052

2053

# we save the original sys.excepthook in the instance, in case config

2054

# code (such as magics) needs access to it.

2055

self.sys_excepthook = old_excepthook

2056

outflag = 1 # happens in more places, so it's easier as default

2057

try:

2058

try:

2059

# Embedded instances require separate global/local namespaces

2060

# so they can see both the surrounding (local) namespace and

2061

# the module-level globals when called inside another function.

2062

if self.embedded:

2063

exec code_obj in self.user_global_ns, self.user_ns

2064

# Normal (non-embedded) instances should only have a single

2065

# namespace for user code execution, otherwise functions won't

2066

# see interactive top-level globals.

2067

else:

2068

exec code_obj in self.user_ns

2069

finally:

2070

# Reset our crash handler in place

2071

sys.excepthook = old_excepthook

2072

except SystemExit:

2073

self.resetbuffer()

2074

self.showtraceback()

2075

warn("Type %exit or %quit to exit IPython "

2076

"(%Exit or %Quit do so unconditionally).",level=1)

2077

except self.custom_exceptions:

2078

etype,value,tb = sys.exc_info()

2079

self.CustomTB(etype,value,tb)

2080

except:

2081

self.showtraceback()

2082

else:

2083

outflag = 0

2084

if softspace(sys.stdout, 0):

2085

print

2086

# Flush out code object which has been run (and source)

2087

self.code_to_run = None

2088

return outflag

2089

2090

def push(self, line):

2091

"""Push a line to the interpreter.

2092

2093

The line should not have a trailing newline; it may have

2094

internal newlines. The line is appended to a buffer and the

2095

interpreter's runsource() method is called with the

2096

concatenated contents of the buffer as source. If this

2097

indicates that the command was executed or invalid, the buffer

2098

is reset; otherwise, the command is incomplete, and the buffer

2099

is left as it was after the line was appended. The return

2100

value is 1 if more input is required, 0 if the line was dealt

2101

with in some way (this is the same as runsource()).

2102

"""

2103

2104

# autoindent management should be done here, and not in the

2105

# interactive loop, since that one is only seen by keyboard input. We

2106

# need this done correctly even for code run via runlines (which uses

2107

# push).

2108

2109

#print 'push line: <%s>' % line # dbg

2110

for subline in line.splitlines():

2111

self.autoindent_update(subline)

2112

self.buffer.append(line)

2113

more = self.runsource('\n'.join(self.buffer), self.filename)

2114

if not more:

2115

self.resetbuffer()

2116

return more

2117

2118

def split_user_input(self, line):

2119

# This is really a hold-over to support ipapi and some extensions

2120

return prefilter.splitUserInput(line)

2121

2122

def resetbuffer(self):

2123

"""Reset the input buffer."""

2124

self.buffer[:] = []

2125

2126

def raw_input(self,prompt='',continue_prompt=False):

2127

"""Write a prompt and read a line.

2128

2129

The returned line does not include the trailing newline.

2130

When the user enters the EOF key sequence, EOFError is raised.

2131

2132

Optional inputs:

2133

2134

- prompt(''): a string to be printed to prompt the user.

2135

2136

- continue_prompt(False): whether this line is the first one or a

2137

continuation in a sequence of inputs.

2138

"""

2139

2140

# Code run by the user may have modified the readline completer state.

2141

# We must ensure that our completer is back in place.

2142

if self.has_readline:

2143

self.set_completer()

2144

2145

try:

2146

line = raw_input_original(prompt).decode(self.stdin_encoding)

2147

except ValueError:

2148

warn("\n********\nYou or a %run:ed script called sys.stdin.close()"

2149

" or sys.stdout.close()!\nExiting IPython!")

2150

self.exit_now = True

2151

return ""

2152

2153

# Try to be reasonably smart about not re-indenting pasted input more

2154

# than necessary. We do this by trimming out the auto-indent initial

2155

# spaces, if the user's actual input started itself with whitespace.

2156

#debugx('self.buffer[-1]')

2157

2158

if self.autoindent:

2159

if num_ini_spaces(line) > self.indent_current_nsp:

2160

line = line[self.indent_current_nsp:]

2161

self.indent_current_nsp = 0

2162

2163

# store the unfiltered input before the user has any chance to modify

2164

# it.

2165

if line.strip():

2166

if continue_prompt:

2167

self.input_hist_raw[-1] += '%s\n' % line

2168

if self.has_readline: # and some config option is set?

2169

try:

2170

histlen = self.readline.get_current_history_length()

2171

if histlen > 1:

2172

newhist = self.input_hist_raw[-1].rstrip()

2173

self.readline.remove_history_item(histlen-1)

2174

self.readline.~~replace_history_item~~(~~histlen~~-2,

2175

newhist.encode(self.stdin_encoding))

2176

except AttributeError:

2177

pass # re{move,place}_history_item are new in 2.4.

2178

else:

2179

self.input_hist_raw.append('%s\n' % line)

2180

# only entries starting at first column go to shadow history

2181

if line.lstrip() == line:

2182

self.shadowhist.add(line.strip())

2183

elif not continue_prompt:

2184

self.input_hist_raw.append('\n')

2185

try:

2186

lineout = self.prefilter(line,continue_prompt)

2187

except:

2188

# blanket except, in case a user-defined prefilter crashes, so it

2189

# can't take all of ipython with it.

2190

self.showtraceback()

2191

return ''

2192

else:

2193

return lineout

2194

2195

def _prefilter(self, line, continue_prompt):

2196

"""Calls different preprocessors, depending on the form of line."""

2197

2198

# All handlers *must* return a value, even if it's blank ('').

2199

2200

# Lines are NOT logged here. Handlers should process the line as

2201

# needed, update the cache AND log it (so that the input cache array

2202

# stays synced).

2203

2204

#.....................................................................

2205

# Code begins

2206

2207

#if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg

2208

2209

# save the line away in case we crash, so the post-mortem handler can

2210

# record it

2211

self._last_input_line = line

2212

2213

#print '***line: <%s>' % line # dbg

2214

2215

if not line:

2216

# Return immediately on purely empty lines, so that if the user

2217

# previously typed some whitespace that started a continuation

2218

# prompt, he can break out of that loop with just an empty line.

2219

# This is how the default python prompt works.

2220

2221

# Only return if the accumulated input buffer was just whitespace!

2222

if ''.join(self.buffer).isspace():

2223

self.buffer[:] = []

2224

return ''

2225

2226

line_info = prefilter.LineInfo(line, continue_prompt)

2227

2228

# the input history needs to track even empty lines

2229

stripped = line.strip()

2230

2231

if not stripped:

2232

if not continue_prompt:

2233

self.outputcache.prompt_count -= 1

2234

return self.handle_normal(line_info)

2235

2236

~~# print '***cont',~~continue_prompt ~~# dbg~~

2237

# special handlers are only allowed for single line statements

2238

if continue_prompt and not self.rc.multi_line_specials:

2239

return self.handle_normal(line_info)

2240

2241

2242

# See whether any pre-existing handler can take care of it

2243

rewritten = self.hooks.input_prefilter(stripped)

2244

if rewritten != stripped: # ok, some prefilter did something

2245

rewritten = line_info.pre + rewritten # add indentation

2246

return self.handle_normal(prefilter.LineInfo(rewritten,

2247

continue_prompt))

2248

2249

#print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg

2250

2251

return prefilter.prefilter(line_info, self)

2252

2253

2254

def _prefilter_dumb(self, line, continue_prompt):

2255

"""simple prefilter function, for debugging"""

2256

return self.handle_normal(line,continue_prompt)

2257

2258

2259

def multiline_prefilter(self, line, continue_prompt):

2260

""" Run _prefilter for each line of input

2261

2262

Covers cases where there are multiple lines in the user entry,

2263

which is the case when the user goes back to a multiline history

2264

entry and presses enter.

2265

2266

"""

2267

out = []

2268

for l in line.rstrip('\n').split('\n'):

2269

out.append(self._prefilter(l, continue_prompt))

2270

return '\n'.join(out)

2271

2272

# Set the default prefilter() function (this can be user-overridden)

2273

prefilter = multiline_prefilter

2274

2275

def handle_normal(self,line_info):

2276

"""Handle normal input lines. Use as a template for handlers."""

2277

2278

# With autoindent on, we need some way to exit the input loop, and I

2279

# don't want to force the user to have to backspace all the way to

2280

# clear the line. The rule will be in this case, that either two

2281

# lines of pure whitespace in a row, or a line of pure whitespace but

2282

# of a size different to the indent level, will exit the input loop.

2283

line = line_info.line

2284

continue_prompt = line_info.continue_prompt

2285

2286

if (continue_prompt and self.autoindent and line.isspace() and

2287

(0 < abs(len(line) - self.indent_current_nsp) <= 2 or

2288

(self.buffer[-1]).isspace() )):

2289

line = ''

2290

2291

self.log(line,line,continue_prompt)

2292

return line

2293

2294

def handle_alias(self,line_info):

2295

"""Handle alias input lines. """

2296

tgt = self.alias_table[line_info.iFun]

2297

# print "=>",tgt #dbg

2298

if callable(tgt):

2299

if '$' in line_info.line:

2300

call_meth = '(_ip, _ip.itpl(%s))'

2301

else:

2302

call_meth = '(_ip,%s)'

2303

line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,

2304

line_info.iFun,

2305

make_quoted_expr(line_info.line))

2306

else:

2307

transformed = self.expand_aliases(line_info.iFun,line_info.theRest)

2308

2309

# pre is needed, because it carries the leading whitespace. Otherwise

2310

# aliases won't work in indented sections.

2311

line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,

2312

make_quoted_expr( transformed ))

2313

2314

self.log(line_info.line,line_out,line_info.continue_prompt)

2315

#print 'line out:',line_out # dbg

2316

return line_out

2317

2318

def handle_shell_escape(self, line_info):

2319

"""Execute the line in a shell, empty return value"""

2320

#print 'line in :', `line` # dbg

2321

line = line_info.line

2322

if line.lstrip().startswith('!!'):

2323

# rewrite LineInfo's line, iFun and theRest to properly hold the

2324

# call to %sx and the actual command to be executed, so

2325

# handle_magic can work correctly. Note that this works even if

2326

# the line is indented, so it handles multi_line_specials

2327

# properly.

2328

new_rest = line.lstrip()[2:]

2329

line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)

2330

line_info.iFun = 'sx'

2331

line_info.theRest = new_rest

2332

return self.handle_magic(line_info)

2333

else:

2334

cmd = line.lstrip().lstrip('!')

2335

line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,

2336

make_quoted_expr(cmd))

2337

# update cache/log and return

2338

self.log(line,line_out,line_info.continue_prompt)

2339

return line_out

2340

2341

def handle_magic(self, line_info):

2342

"""Execute magic functions."""

2343

~~iFun~~ = line_~~info~~.~~iFun~~

2344

theRest = line_info.theRest

2345

cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,

2346

make_quoted_expr(iFun + " " + theRest))

2347

self.log(line_info.line,cmd,line_info.continue_prompt)

2348

#print 'in handle_magic, cmd=<%s>' % cmd # dbg

2349

return cmd

2350

2351

def handle_auto(self, line_info):

2352

"""Hande lines which can be auto-executed, quoting if requested."""

2353

2354

#print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg

2355

line = line_info.line

2356

iFun = line_info.iFun

2357

theRest = line_info.theRest

2358

pre = line_info.pre

2359

~~continue_prompt~~ = line_info.~~continue_prompt~~

2360

~~obj~~ = line_info.ofind(~~self~~)[~~'obj'~~]

2361

2362

# This should only be active for single-line input!

2363

if continue_prompt:

2364

self.log(line,line,continue_prompt)

2365

return line

2366

2367

force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)

2368

auto_rewrite = True

2369

2370

if pre == self.ESC_QUOTE:

2371

# Auto-quote splitting on whitespace

2372

newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )

2373

elif pre == self.ESC_QUOTE2:

2374

# Auto-quote whole string

2375

newcmd = '%s("%s")' % (iFun,theRest)

2376

elif pre == self.ESC_PAREN:

2377

newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))

2378

else:

2379

# Auto-paren.

2380

# We only apply it to argument-less calls if the autocall

2381

# parameter is set to 2. We only need to check that autocall is <

2382

# 2, since this function isn't called unless it's at least 1.

2383

if not theRest and (self.rc.autocall < 2) and not force_auto:

2384

newcmd = '%s %s' % (iFun,theRest)

2385

auto_rewrite = False

2386

else:

2387

if not force_auto and theRest.startswith('['):

2388

if hasattr(obj,'__getitem__'):

2389

# Don't autocall in this case: item access for an object

2390

# which is BOTH callable and implements __getitem__.

2391

newcmd = '%s %s' % (iFun,theRest)

2392

~~auto_rewrite~~ = ~~False~~

2393

else:

2394

# if the object doesn't support [] access, go ahead and

2395

# autocall

2396

newcmd = '%s(%s)' % (iFun.rstrip(),theRest)

2397

elif theRest.endswith(';'):

2398

newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])

2399

~~else~~:

2400

newcmd = '%s(%s)' % (iFun.rstrip(), theRest)

2401

2402

if auto_rewrite:

2403

rw = self.outputcache.prompt1.auto_rewrite() + newcmd

2404

2405

try:

2406

# plain ascii works better w/ pyreadline, on some machines, so

2407

# we use it and only print uncolored rewrite if we have unicode

2408

rw = ~~str~~(rw)

2409

print >>Term.cout, rw

2410

except UnicodeEncodeError:

2411

print "-------------->" + newcmd

2412

2413

# log what is now valid Python, not the actual user input (without the

2414

# final newline)

2415

self.log(line,newcmd,continue_prompt)

2416

return newcmd

2417

2418

def handle_help(self, line_info):

2419

"""Try to get some help for the object.

2420

2421

obj? or ?obj -> basic information.

2422

obj?? or ??obj -> more details.

2423

"""

2424

2425

line = line_info.line

2426

# We need to make sure that we don't process lines which would be

2427

# otherwise valid python, such as "x=1 # what?"

2428

~~try~~:

2429

codeop.compile_command(line)

2430

except SyntaxError:

2431

# We should only handle as help stuff which is NOT valid syntax

2432

if line[0]==self.ESC_HELP:

2433

line = line[1:]

2434

elif line[-1]==self.ESC_HELP:

2435

line = line[:-1]

2436

self.log(line,'#?'+line,line_info.continue_prompt)

2437

if line:

2438

#print 'line:<%r>' % line # dbg

2439

self.magic_pinfo(line)

2440

else:

2441

page(self.usage,screen_lines=self.rc.screen_length)

2442

return '' # Empty string is needed here!

2443

except:

2444

# Pass any other exceptions through to the normal handler

2445

return self.handle_normal(line_info)

2446

else:

2447

# If the code compiles ok, we should handle it normally

2448

return self.handle_normal(line_info)

2449

2450

def getapi(self):

2451

""" Get an IPApi object for this shell instance

2452

2453

Getting an IPApi object is always preferable to accessing the shell

2454

directly, but this holds true especially for extensions.

2455

2456

It should always be possible to implement an extension with IPApi

2457

alone. If not, contact maintainer to request an addition.

2458

2459

~~"""~~

2460

return self.api

2461

2462

def handle_emacs(self, line_info):

2463

"""Handle input lines marked by python-mode."""

2464

2465

# Currently, nothing is done. Later more functionality can be added

2466

# here if needed.

2467

2468

# The input cache shouldn't be updated

2469

return line_info.line

2470

2471

2472

def mktempfile(self,data=None):

2473

"""Make a new tempfile and return its filename.

2474

2475

This makes a call to tempfile.mktemp, but it registers the created

2476

filename internally so ipython cleans it up at exit time.

2477

2478

Optional inputs:

2479

2480

- data(None): if data is given, it gets written out to the temp file

2481

immediately, and the file is closed again."""

2482

2483

filename = tempfile.mktemp('.py','ipython_edit_')

2484

self.tempfiles.append(filename)

2485

2486

if data:

2487

tmp_file = open(filename,'w')

2488

tmp_file.write(data)

2489

tmp_file.close()

2490

return filename

2491

2492

def write(self,data):

2493

"""Write a string to the default output"""

2494

Term.cout.write(data)

2495

2496

def write~~_err~~(self,data):

2497

"""Write a string to the default ~~error~~ output"""

2498

Term.c~~err~~.write(data)

2499

2500

def ~~exit~~(self):

2501

"""Handle interactive exit.

2502

2503

This method sets the exit_now attribute."""

2504

2505

if self.rc.confirm_exit:

2506

if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):

2507

self.exit_now = True

2508

else:

2509

self.exit_now = True

2510

2511

def safe_execfile(self,fname,*where,**kw):

2512

"""A safe version of the builtin execfile().

2513

2514

This version will never throw an exception, and knows how to handle

2515

ipython logs as well.

2516

2517

:Parameters:

2518

fname : string

2519

Name of the file to be executed.

2520

2521

where : tuple

2522

One or two namespaces, passed to execfile() as (globals,locals).

2523

If only one is given, it is passed as both.

2524

2525

:Keywords:

2526

islog : boolean (False)

2527

2528

quiet : boolean (True)

2529

2530

~~exit_ignore~~ : boolean (False)

2531

"""

2532

2533

def syspath_cleanup():

2534

"""Internal cleanup routine for sys.path."""

2535

if add_dname:

2536

try:

2537

sys.path.remove(dname)

2538

except ValueError:

2539

# For some reason the user has already removed it, ignore.

2540

~~pass~~

2541

2542

fname = os.path.expanduser(fname)

2543

2544

# Find things also in current directory. This is needed to mimic the

2545

# behavior of running a script from the system command line, where

2546

# Python inserts the script's directory into sys.path

2547

dname = os.path.dirname(os.path.abspath(fname))

2548

add_dname = False

2549

if dname not in sys.path:

2550

sys.path.insert(0,dname)

2551

add_dname = True

2552

2553

try:

2554

xfile = open(fname)

2555

except:

2556

print >> Term.cerr, \

2557

'Could not open file <%s> for safe execution.' % fname

2558

syspath_cleanup()

2559

return None

2560

2561

kw.setdefault('islog',0)

2562

kw.setdefault('quiet',1)

2563

kw.setdefault('exit_ignore',0)

2564

2565

first = xfile.readline()

2566

loghead = str(self.loghead_tpl).split('\n',1)[0].strip()

2567

xfile.close()

2568

# line by line execution

2569

if first.startswith(loghead) or kw['islog']:

2570

print 'Loading log file <%s> one line at a time...' % fname

2571

if kw['quiet']:

2572

stdout_save = sys.stdout

2573

sys.stdout = StringIO.StringIO()

2574

try:

2575

globs,locs = where[0:2]

2576

except:

2577

try:

2578

globs = locs = where[0]

2579

~~except~~:

2580

globs = locs = globals()

2581

~~badblocks~~ = []

2582

2583

# we also need to identify indented blocks of code when replaying

2584

# logs and put them together before passing them to an exec

2585

# statement. This takes a bit of regexp and look-ahead work in the

2586

# file. It's easiest if we swallow the whole thing in memory

2587

# first, and manually walk through the lines list moving the

2588

# counter ourselves.

2589

indent_re = re.compile('\s+\S')

2590

xfile = open(fname)

2591

filelines = xfile.readlines()

2592

xfile.close()

2593

~~nlines~~ = len(~~filelines~~)

2594

~~lnum~~ = 0

2595

while lnum < nlines:

2596

line = filelines[lnum]

2597

lnum += 1

2598

# don't re-insert logger status info into cache

2599

if line.startswith('#log#'):

2600

continue

2601

~~else~~:

2602

# build a block of code (maybe a single line) for execution

2603

block = line

2604

~~try~~:

2605

next = filelines[lnum] # lnum has already incremented

2606

except:

2607

~~next~~ = None

2608

while next and indent_re.match(next):

2609

block += next

2610

~~lnum~~ += 1

2611

~~try~~:

2612

next = filelines[lnum]

2613

~~except~~:

2614

~~next~~ = ~~None~~

2615

# now execute the block of one or more lines

2616

try:

2617

exec ~~block~~ in ~~globs~~,~~locs~~

2618

ex~~cep~~t ~~SystemExit~~:

2619

pass

2620

~~excep~~t:

2621

~~badblocks~~.~~append~~(block.~~rstrip())~~

2622

if kw['quiet']: # restore stdout

2623

sys.stdout.close()

2624

sys.stdout = stdout_save

2625

print 'Finished replaying log file <%s>' % fname

2626

if badblocks:

2627

print >> sys.stderr, ('\nThe following lines/blocks in file '

2628

'<%s> reported errors:' % fname)

2629

2630

~~for~~ ~~badline~~ in badblocks:

2631

print >> sys.stderr, badline

2632

else: # regular file execution

2633

~~try~~:

2634

if sys.platform == 'win32' and sys.version_info < (2,5,1):

2635

# Work around a bug in Python for Windows. The bug was

2636

# fixed in in Python 2.5 r54159 and 54158, but that's still

2637

# SVN Python as of March/07. For details, see:

2638

# http://projects.scipy.org/ipython/ipython/ticket/123

2639

try:

2640

globs,locs = where[0:2]

2641

except:

2642

try:

2643

globs = locs = where[0]

2644

~~except~~:

2645

globs = locs = globals()

2646

exec file(fname) in globs,locs

2647

else:

2648

~~execfile~~(~~fname~~,*~~where~~)

2649

except SyntaxError:

2650

self.showsyntaxerror()

2651

warn('Failure executing file: <%s>' % fname)

2652

except SystemExit,status:

2653

# Code that correctly sets the exit status flag to success (0)

2654

# shouldn't be bothered with a traceback. Note that a plain

2655

# sys.exit() does NOT set the message to 0 (it's empty) so that

2656

# will still get a traceback. Note that the structure of the

2657

# SystemExit exception changed between Python 2.4 and 2.5, so

2658

# the checks must be done in a version-dependent way.

2659

show = False

2660

2661

if sys.version_info[:2] > (2,5):

2662

if status.message!=0 and not kw['exit_ignore']:

2663

show = ~~Tru~~e

2664

else:

2665

if status.code and not kw['exit_ignore']:

2666

show = True

2667

if ~~show~~:

2668

self.showtraceback()

2669

warn('Failure executing file: <%s>' % fname)

2670

except:

2671

~~self~~.~~showtraceback~~()

2672

warn('Failure executing file: <%s>' % fname)

2673

2674

syspath_cleanup()

2675

2676

#************************* end of file <iplib.py> *****************************

1

# -*- coding: utf-8 -*-

2

"""

3

IPython -- An enhanced Interactive Python

4

5

Requires Python 2.3 or newer.

6

7

This file contains all the classes and helper functions specific to IPython.

8

9

"""

10

11

#*****************************************************************************

12

13

14

#

15

# Distributed under the terms of the BSD License. The full license is in

16

# the file COPYING, distributed as part of this software.

17

#

18

# Note: this code originally subclassed code.InteractiveConsole from the

19

# Python standard library. Over time, all of that class has been copied

20

# verbatim here for modifications which could not be accomplished by

21

# subclassing. At this point, there are no dependencies at all on the code

22

# module anymore (it is not even imported). The Python License (sec. 2)

23

# allows for this, but it's always nice to acknowledge credit where credit is

24

# due.

25

#*****************************************************************************

26

27

#****************************************************************************

28

# Modules and globals

29

30

from IPython import Release

31

__author__ = '%s <%s>\n%s <%s>' % \

32

( Release.authors['Janko'] + Release.authors['Fernando'] )

33

__license__ = Release.license

34

__version__ = Release.version

35

36

# Python standard modules

37

import __main__

38

import __builtin__

39

import StringIO

40

import bdb

41

import cPickle as pickle

42

import codeop

43

import exceptions

44

import glob

45

import inspect

46

import keyword

47

import new

48

import os

49

import pydoc

50

import re

51

import shutil

52

import string

53

import sys

54

import tempfile

55

import traceback

56

import types

57

from sets import Set

58

from pprint import pprint, pformat

59

60

# IPython's own modules

61

#import IPython

62

from IPython import Debugger,OInspect,PyColorize,ultraTB

63

from IPython.ColorANSI import ColorScheme,ColorSchemeTable # too long names

64

from IPython.Extensions import pickleshare

65

from IPython.FakeModule import FakeModule

66

from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns

67

from IPython.Logger import Logger

68

from IPython.Magic import Magic

69

from IPython.Prompts import CachedOutput

70

from IPython.ipstruct import Struct

71

from IPython.background_jobs import BackgroundJobManager

72

from IPython.usage import cmd_line_usage,interactive_usage

73

from IPython.genutils import *

74

from IPython.strdispatch import StrDispatch

75

import IPython.ipapi

76

import IPython.history

77

import IPython.prefilter as prefilter

78

import IPython.shadowns

79

# Globals

80

81

# store the builtin raw_input globally, and use this always, in case user code

82

# overwrites it (like wx.py.PyShell does)

83

raw_input_original = raw_input

84

85

# compiled regexps for autoindent management

86

dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')

87

88

89

#****************************************************************************

90

# Some utility function definitions

91

92

ini_spaces_re = re.compile(r'^(\s+)')

93

94

def num_ini_spaces(strng):

95

"""Return the number of initial spaces in a string"""

96

97

ini_spaces = ini_spaces_re.match(strng)

98

if ini_spaces:

99

return ini_spaces.end()

100

else:

101

return 0

102

103

def softspace(file, newvalue):

104

"""Copied from code.py, to remove the dependency"""

105

106

oldvalue = 0

107

try:

108

oldvalue = file.softspace

109

except AttributeError:

110

pass

111

try:

112

file.softspace = newvalue

113

except (AttributeError, TypeError):

114

# "attribute-less object" or "read-only attributes"

115

pass

116

return oldvalue

117

118

119

#****************************************************************************

120

# Local use exceptions

121

class SpaceInInput(exceptions.Exception): pass

122

123

124

#****************************************************************************

125

# Local use classes

126

class Bunch: pass

127

128

class Undefined: pass

129

130

class Quitter(object):

131

"""Simple class to handle exit, similar to Python 2.5's.

132

133

It handles exiting in an ipython-safe manner, which the one in Python 2.5

134

doesn't do (obviously, since it doesn't know about ipython)."""

135

136

def __init__(self,shell,name):

137

self.shell = shell

138

self.name = name

139

140

def __repr__(self):

141

return 'Type %s() to exit.' % self.name

142

__str__ = __repr__

143

144

def __call__(self):

145

self.shell.exit()

146

147

class InputList(list):

148

"""Class to store user input.

149

150

It's basically a list, but slices return a string instead of a list, thus

151

allowing things like (assuming 'In' is an instance):

152

153

exec In[4:7]

154

155

or

156

157

exec In[5:9] + In[14] + In[21:25]"""

158

159

def __getslice__(self,i,j):

160

return ''.join(list.__getslice__(self,i,j))

161

162

class SyntaxTB(ultraTB.ListTB):

163

"""Extension which holds some state: the last exception value"""

164

165

def __init__(self,color_scheme = 'NoColor'):

166

ultraTB.ListTB.__init__(self,color_scheme)

167

self.last_syntax_error = None

168

169

def __call__(self, etype, value, elist):

170

self.last_syntax_error = value

171

ultraTB.ListTB.__call__(self,etype,value,elist)

172

173

def clear_err_state(self):

174

"""Return the current error state and clear it"""

175

e = self.last_syntax_error

176

self.last_syntax_error = None

177

return e

178

179

#****************************************************************************

180

# Main IPython class

181

182

# FIXME: the Magic class is a mixin for now, and will unfortunately remain so

183

# until a full rewrite is made. I've cleaned all cross-class uses of

184

# attributes and methods, but too much user code out there relies on the

185

# equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.

186

#

187

# But at least now, all the pieces have been separated and we could, in

188

# principle, stop using the mixin. This will ease the transition to the

189

# chainsaw branch.

190

191

# For reference, the following is the list of 'self.foo' uses in the Magic

192

# class as of 2005-12-28. These are names we CAN'T use in the main ipython

193

# class, to prevent clashes.

194

195

# ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',

196

# 'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',

197

# 'self.magic_', 'self.options_table', 'self.parse', 'self.shell',

198

# 'self.value']

199

200

class InteractiveShell(object,Magic):

201

"""An enhanced console for Python."""

202

203

# class attribute to indicate whether the class supports threads or not.

204

# Subclasses with thread support should override this as needed.

205

isthreaded = False

206

207

def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),

208

user_ns = None,user_global_ns=None,banner2='',

209

custom_exceptions=((),None),embedded=False):

210

211

# log system

212

self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')

213

214

# some minimal strict typechecks. For some core data structures, I

215

# want actual basic python types, not just anything that looks like

216

# one. This is especially true for namespaces.

217

for ns in (user_ns,user_global_ns):

218

if ns is not None and type(ns) != types.DictType:

219

raise TypeError,'namespace must be a dictionary'

220

# Job manager (for jobs run as background threads)

221

self.jobs = BackgroundJobManager()

222

223

# Store the actual shell's name

224

self.name = name

225

self.more = False

226

227

# We need to know whether the instance is meant for embedding, since

228

# global/local namespaces need to be handled differently in that case

229

self.embedded = embedded

230

if embedded:

231

# Control variable so users can, from within the embedded instance,

232

# permanently deactivate it.

233

self.embedded_active = True

234

235

# command compiler

236

self.compile = codeop.CommandCompiler()

237

238

# User input buffer

239

self.buffer = []

240

241

# Default name given in compilation of code

242

self.filename = '<ipython console>'

243

244

# Install our own quitter instead of the builtins. For python2.3-2.4,

245

# this brings in behavior like 2.5, and for 2.5 it's identical.

246

__builtin__.exit = Quitter(self,'exit')

247

__builtin__.quit = Quitter(self,'quit')

248

249

# Make an empty namespace, which extension writers can rely on both

250

# existing and NEVER being used by ipython itself. This gives them a

251

# convenient location for storing additional information and state

252

# their extensions may require, without fear of collisions with other

253

# ipython names that may develop later.

254

self.meta = Struct()

255

256

# Create the namespace where the user will operate. user_ns is

257

# normally the only one used, and it is passed to the exec calls as

258

# the locals argument. But we do carry a user_global_ns namespace

259

# given as the exec 'globals' argument, This is useful in embedding

260

# situations where the ipython shell opens in a context where the

261

# distinction between locals and globals is meaningful.

262

263

# FIXME. For some strange reason, __builtins__ is showing up at user

264

# level as a dict instead of a module. This is a manual fix, but I

265

# should really track down where the problem is coming from. Alex

266

# Schmolck reported this problem first.

267

268

# A useful post by Alex Martelli on this topic:

269

# Re: inconsistent value from __builtins__

270

# Von: Alex Martelli <aleaxit@yahoo.com>

271

# Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends

272

# Gruppen: comp.lang.python

273

274

# Michael Hohn <hohn@hooknose.lbl.gov> wrote:

275

# > >>> print type(builtin_check.get_global_binding('__builtins__'))

276

# > <type 'dict'>

277

# > >>> print type(__builtins__)

278

# > <type 'module'>

279

# > Is this difference in return value intentional?

280

281

# Well, it's documented that '__builtins__' can be either a dictionary

282

# or a module, and it's been that way for a long time. Whether it's

283

# intentional (or sensible), I don't know. In any case, the idea is

284

# that if you need to access the built-in namespace directly, you

285

# should start with "import __builtin__" (note, no 's') which will

286

# definitely give you a module. Yeah, it's somewhat confusing:-(.

287

288

# These routines return properly built dicts as needed by the rest of

289

# the code, and can also be used by extension writers to generate

290

# properly initialized namespaces.

291

user_ns = IPython.ipapi.make_user_ns(user_ns)

292

user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)

293

294

# Assign namespaces

295

# This is the namespace where all normal user variables live

296

self.user_ns = user_ns

297

# Embedded instances require a separate namespace for globals.

298

# Normally this one is unused by non-embedded instances.

299

self.user_global_ns = user_global_ns

300

# A namespace to keep track of internal data structures to prevent

301

# them from cluttering user-visible stuff. Will be updated later

302

self.internal_ns = {}

303

304

# Namespace of system aliases. Each entry in the alias

305

# table must be a 2-tuple of the form (N,name), where N is the number

306

# of positional arguments of the alias.

307

self.alias_table = {}

308

309

# A table holding all the namespaces IPython deals with, so that

310

# introspection facilities can search easily.

311

self.ns_table = {'user':user_ns,

312

'user_global':user_global_ns,

313

'alias':self.alias_table,

314

'internal':self.internal_ns,

315

'builtin':__builtin__.__dict__

316

}

317

# The user namespace MUST have a pointer to the shell itself.

318

self.user_ns[name] = self

319

320

# We need to insert into sys.modules something that looks like a

321

# module but which accesses the IPython namespace, for shelve and

322

# pickle to work interactively. Normally they rely on getting

323

# everything out of __main__, but for embedding purposes each IPython

324

# instance has its own private namespace, so we can't go shoving

325

# everything into __main__.

326

327

# note, however, that we should only do this for non-embedded

328

# ipythons, which really mimic the __main__.__dict__ with their own

329

# namespace. Embedded instances, on the other hand, should not do

330

# this because they need to manage the user local/global namespaces

331

# only, but they live within a 'normal' __main__ (meaning, they

332

# shouldn't overtake the execution environment of the script they're

333

# embedded in).

334

335

if not embedded:

336

try:

337

main_name = self.user_ns['__name__']

338

except KeyError:

339

raise KeyError,'user_ns dictionary MUST have a "__name__" key'

340

else:

341

#print "pickle hack in place" # dbg

342

#print 'main_name:',main_name # dbg

343

sys.modules[main_name] = FakeModule(self.user_ns)

344

345

# Now that FakeModule produces a real module, we've run into a nasty

346

# problem: after script execution (via %run), the module where the user

347

# code ran is deleted. Now that this object is a true module (needed

348

# so docetst and other tools work correctly), the Python module

349

# teardown mechanism runs over it, and sets to None every variable

350

# present in that module. This means that later calls to functions

351

# defined in the script (which have become interactively visible after

352

# script exit) fail, because they hold references to objects that have

353

# become overwritten into None. The only solution I see right now is

354

# to protect every FakeModule used by %run by holding an internal

355

# reference to it. This private list will be used for that. The

356

# %reset command will flush it as well.

357

self._user_main_modules = []

358

359

# List of input with multi-line handling.

360

# Fill its zero entry, user counter starts at 1

361

self.input_hist = InputList(['\n'])

362

# This one will hold the 'raw' input history, without any

363

# pre-processing. This will allow users to retrieve the input just as

364

# it was exactly typed in by the user, with %hist -r.

365

self.input_hist_raw = InputList(['\n'])

366

367

# list of visited directories

368

try:

369

self.dir_hist = [os.getcwd()]

370

except OSError:

371

self.dir_hist = []

372

373

# dict of output history

374

self.output_hist = {}

375

376

# Get system encoding at startup time. Certain terminals (like Emacs

377

# under Win32 have it set to None, and we need to have a known valid

378

# encoding to use in the raw_input() method

379

try:

380

self.stdin_encoding = sys.stdin.encoding or 'ascii'

381

except AttributeError:

382

self.stdin_encoding = 'ascii'

383

384

# dict of things NOT to alias (keywords, builtins and some magics)

385

no_alias = {}

386

no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']

387

for key in keyword.kwlist + no_alias_magics:

388

no_alias[key] = 1

389

no_alias.update(__builtin__.__dict__)

390

self.no_alias = no_alias

391

392

# make global variables for user access to these

393

self.user_ns['_ih'] = self.input_hist

394

self.user_ns['_oh'] = self.output_hist

395

self.user_ns['_dh'] = self.dir_hist

396

397

# user aliases to input and output histories

398

self.user_ns['In'] = self.input_hist

399

self.user_ns['Out'] = self.output_hist

400

401

self.user_ns['_sh'] = IPython.shadowns

402

# Object variable to store code object waiting execution. This is

403

# used mainly by the multithreaded shells, but it can come in handy in

404

# other situations. No need to use a Queue here, since it's a single

405

# item which gets cleared once run.

406

self.code_to_run = None

407

408

# escapes for automatic behavior on the command line

409

self.ESC_SHELL = '!'

410

self.ESC_SH_CAP = '!!'

411

self.ESC_HELP = '?'

412

self.ESC_MAGIC = '%'

413

self.ESC_QUOTE = ','

414

self.ESC_QUOTE2 = ';'

415

self.ESC_PAREN = '/'

416

417

# And their associated handlers

418

self.esc_handlers = {self.ESC_PAREN : self.handle_auto,

419

self.ESC_QUOTE : self.handle_auto,

420

self.ESC_QUOTE2 : self.handle_auto,

421

self.ESC_MAGIC : self.handle_magic,

422

self.ESC_HELP : self.handle_help,

423

self.ESC_SHELL : self.handle_shell_escape,

424

self.ESC_SH_CAP : self.handle_shell_escape,

425

}

426

427

# class initializations

428

Magic.__init__(self,self)

429

430

# Python source parser/formatter for syntax highlighting

431

pyformat = PyColorize.Parser().format

432

self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])

433

434

# hooks holds pointers used for user-side customizations

435

self.hooks = Struct()

436

437

self.strdispatchers = {}

438

439

# Set all default hooks, defined in the IPython.hooks module.

440

hooks = IPython.hooks

441

for hook_name in hooks.__all__:

442

# default hooks have priority 100, i.e. low; user hooks should have

443

# 0-100 priority

444

self.set_hook(hook_name,getattr(hooks,hook_name), 100)

445

#print "bound hook",hook_name

446

447

# Flag to mark unconditional exit

448

self.exit_now = False

449

450

self.usage_min = """\

451

An enhanced console for Python.

452

Some of its features are:

453

- Readline support if the readline library is present.

454

- Tab completion in the local namespace.

455

- Logging of input, see command-line options.

456

- System shell escape via ! , eg !ls.

457

- Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)

458

- Keeps track of locally defined variables via %who, %whos.

459

- Show object information with a ? eg ?x or x? (use ?? for more info).

460

"""

461

if usage: self.usage = usage

462

else: self.usage = self.usage_min

463

464

# Storage

465

self.rc = rc # This will hold all configuration information

466

self.pager = 'less'

467

# temporary files used for various purposes. Deleted at exit.

468

self.tempfiles = []

469

470

# Keep track of readline usage (later set by init_readline)

471

self.has_readline = False

472

473

# template for logfile headers. It gets resolved at runtime by the

474

# logstart method.

475

self.loghead_tpl = \

476

"""#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***

477

#log# DO NOT CHANGE THIS LINE OR THE TWO BELOW

478

#log# opts = %s

479

#log# args = %s

480

#log# It is safe to make manual edits below here.

481

#log#-----------------------------------------------------------------------

482

"""

483

# for pushd/popd management

484

try:

485

self.home_dir = get_home_dir()

486

except HomeDirError,msg:

487

fatal(msg)

488

489

self.dir_stack = []

490

491

# Functions to call the underlying shell.

492

493

# The first is similar to os.system, but it doesn't return a value,

494

# and it allows interpolation of variables in the user's namespace.

495

self.system = lambda cmd: \

496

self.hooks.shell_hook(self.var_expand(cmd,depth=2))

497

498

# These are for getoutput and getoutputerror:

499

self.getoutput = lambda cmd: \

500

getoutput(self.var_expand(cmd,depth=2),

501

header=self.rc.system_header,

502

verbose=self.rc.system_verbose)

503

504

self.getoutputerror = lambda cmd: \

505

getoutputerror(self.var_expand(cmd,depth=2),

506

header=self.rc.system_header,

507

verbose=self.rc.system_verbose)

508

509

510

# keep track of where we started running (mainly for crash post-mortem)

511

self.starting_dir = os.getcwd()

512

513

# Various switches which can be set

514

self.CACHELENGTH = 5000 # this is cheap, it's just text

515

self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__

516

self.banner2 = banner2

517

518

# TraceBack handlers:

519

520

# Syntax error handler.

521

self.SyntaxTB = SyntaxTB(color_scheme='NoColor')

522

523

# The interactive one is initialized with an offset, meaning we always

524

# want to remove the topmost item in the traceback, which is our own

525

# internal code. Valid modes: ['Plain','Context','Verbose']

526

self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',

527

color_scheme='NoColor',

528

tb_offset = 1)

529

530

# IPython itself shouldn't crash. This will produce a detailed

531

# post-mortem if it does. But we only install the crash handler for

532

# non-threaded shells, the threaded ones use a normal verbose reporter

533

# and lose the crash handler. This is because exceptions in the main

534

# thread (such as in GUI code) propagate directly to sys.excepthook,

535

# and there's no point in printing crash dumps for every user exception.

536

if self.isthreaded:

537

ipCrashHandler = ultraTB.FormattedTB()

538

else:

539

from IPython import CrashHandler

540

ipCrashHandler = CrashHandler.IPythonCrashHandler(self)

541

self.set_crash_handler(ipCrashHandler)

542

543

# and add any custom exception handlers the user may have specified

544

self.set_custom_exc(*custom_exceptions)

545

546

# indentation management

547

self.autoindent = False

548

self.indent_current_nsp = 0

549

550

# Make some aliases automatically

551

# Prepare list of shell aliases to auto-define

552

if os.name == 'posix':

553

auto_alias = ('mkdir mkdir', 'rmdir rmdir',

554

'mv mv -i','rm rm -i','cp cp -i',

555

'cat cat','less less','clear clear',

556

# a better ls

557

'ls ls -F',

558

# long ls

559

'll ls -lF')

560

# Extra ls aliases with color, which need special treatment on BSD

561

# variants

562

ls_extra = ( # color ls

563

'lc ls -F -o --color',

564

# ls normal files only

565

'lf ls -F -o --color %l | grep ^-',

566

# ls symbolic links

567

'lk ls -F -o --color %l | grep ^l',

568

# directories or links to directories,

569

'ldir ls -F -o --color %l | grep /$',

570

# things which are executable

571

'lx ls -F -o --color %l | grep ^-..x',

572

)

573

# The BSDs don't ship GNU ls, so they don't understand the

574

# --color switch out of the box

575

if 'bsd' in sys.platform:

576

ls_extra = ( # ls normal files only

577

'lf ls -lF | grep ^-',

578

# ls symbolic links

579

'lk ls -lF | grep ^l',

580

# directories or links to directories,

581

'ldir ls -lF | grep /$',

582

# things which are executable

583

'lx ls -lF | grep ^-..x',

584

)

585

auto_alias = auto_alias + ls_extra

586

elif os.name in ['nt','dos']:

587

auto_alias = ('ls dir /on',

588

'ddir dir /ad /on', 'ldir dir /ad /on',

589

'mkdir mkdir','rmdir rmdir','echo echo',

590

'ren ren','cls cls','copy copy')

591

else:

592

auto_alias = ()

593

self.auto_alias = [s.split(None,1) for s in auto_alias]

594

595

596

# Produce a public API instance

597

self.api = IPython.ipapi.IPApi(self)

598

599

# Call the actual (public) initializer

600

self.init_auto_alias()

601

602

# track which builtins we add, so we can clean up later

603

self.builtins_added = {}

604

# This method will add the necessary builtins for operation, but

605

# tracking what it did via the builtins_added dict.

606

607

#TODO: remove this, redundant

608

self.add_builtins()

609

610

611

612

613

# end __init__

614

615

def var_expand(self,cmd,depth=0):

616

"""Expand python variables in a string.

617

618

The depth argument indicates how many frames above the caller should

619

be walked to look for the local namespace where to expand variables.

620

621

The global namespace for expansion is always the user's interactive

622

namespace.

623

"""

624

625

return str(ItplNS(cmd,

626

self.user_ns, # globals

627

# Skip our own frame in searching for locals:

628

sys._getframe(depth+1).f_locals # locals

629

))

630

631

def pre_config_initialization(self):

632

"""Pre-configuration init method

633

634

This is called before the configuration files are processed to

635

prepare the services the config files might need.

636

637

self.rc already has reasonable default values at this point.

638

"""

639

rc = self.rc

640

try:

641

self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")

642

except exceptions.UnicodeDecodeError:

643

print "Your ipythondir can't be decoded to unicode!"

644

print "Please set HOME environment variable to something that"

645

print r"only has ASCII characters, e.g. c:\home"

646

print "Now it is",rc.ipythondir

647

sys.exit()

648

self.shadowhist = IPython.history.ShadowHist(self.db)

649

650

651

def post_config_initialization(self):

652

"""Post configuration init method

653

654

This is called after the configuration files have been processed to

655

'finalize' the initialization."""

656

657

rc = self.rc

658

659

# Object inspector

660

self.inspector = OInspect.Inspector(OInspect.InspectColors,

661

PyColorize.ANSICodeColors,

662

'NoColor',

663

rc.object_info_string_level)

664

665

self.rl_next_input = None

666

self.rl_do_indent = False

667

# Load readline proper

668

if rc.readline:

669

self.init_readline()

670

671

672

# local shortcut, this is used a LOT

673

self.log = self.logger.log

674

675

# Initialize cache, set in/out prompts and printing system

676

self.outputcache = CachedOutput(self,

677

rc.cache_size,

678

rc.pprint,

679

input_sep = rc.separate_in,

680

output_sep = rc.separate_out,

681

output_sep2 = rc.separate_out2,

682

ps1 = rc.prompt_in1,

683

ps2 = rc.prompt_in2,

684

ps_out = rc.prompt_out,

685

pad_left = rc.prompts_pad_left)

686

687

# user may have over-ridden the default print hook:

688

try:

689

self.outputcache.__class__.display = self.hooks.display

690

except AttributeError:

691

pass

692

693

# I don't like assigning globally to sys, because it means when

694

# embedding instances, each embedded instance overrides the previous

695

# choice. But sys.displayhook seems to be called internally by exec,

696

# so I don't see a way around it. We first save the original and then

697

# overwrite it.

698

self.sys_displayhook = sys.displayhook

699

sys.displayhook = self.outputcache

700

701

# Do a proper resetting of doctest, including the necessary displayhook

702

# monkeypatching

703

doctest_reload()

704

705

# Set user colors (don't do it in the constructor above so that it

706

# doesn't crash if colors option is invalid)

707

self.magic_colors(rc.colors)

708

709

# Set calling of pdb on exceptions

710

self.call_pdb = rc.pdb

711

712

# Load user aliases

713

for alias in rc.alias:

714

self.magic_alias(alias)

715

716

self.hooks.late_startup_hook()

717

718

for cmd in self.rc.autoexec:

719

#print "autoexec>",cmd #dbg

720

self.api.runlines(cmd)

721

722

batchrun = False

723

for batchfile in [path(arg) for arg in self.rc.args

724

if arg.lower().endswith('.ipy')]:

725

if not batchfile.isfile():

726

print "No such batch file:", batchfile

727

continue

728

self.api.runlines(batchfile.text())

729

batchrun = True

730

# without -i option, exit after running the batch file

731

if batchrun and not self.rc.interact:

732

self.exit_now = True

733

734

def add_builtins(self):

735

"""Store ipython references into the builtin namespace.

736

737

Some parts of ipython operate via builtins injected here, which hold a

738

reference to IPython itself."""

739

740

# TODO: deprecate all of these, they are unsafe

741

builtins_new = dict(__IPYTHON__ = self,

742

ip_set_hook = self.set_hook,

743

jobs = self.jobs,

744

ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),

745

ipalias = wrap_deprecated(self.ipalias),

746

ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),

747

#_ip = self.api

748

)

749

for biname,bival in builtins_new.items():

750

try:

751

# store the orignal value so we can restore it

752

self.builtins_added[biname] = __builtin__.__dict__[biname]

753

except KeyError:

754

# or mark that it wasn't defined, and we'll just delete it at

755

# cleanup

756

self.builtins_added[biname] = Undefined

757

__builtin__.__dict__[biname] = bival

758

759

# Keep in the builtins a flag for when IPython is active. We set it

760

# with setdefault so that multiple nested IPythons don't clobber one

761

# another. Each will increase its value by one upon being activated,

762

# which also gives us a way to determine the nesting level.

763

__builtin__.__dict__.setdefault('__IPYTHON__active',0)

764

765

def clean_builtins(self):

766

"""Remove any builtins which might have been added by add_builtins, or

767

restore overwritten ones to their previous values."""

768

for biname,bival in self.builtins_added.items():

769

if bival is Undefined:

770

del __builtin__.__dict__[biname]

771

else:

772

__builtin__.__dict__[biname] = bival

773

self.builtins_added.clear()

774

775

def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):

776

"""set_hook(name,hook) -> sets an internal IPython hook.

777

778

IPython exposes some of its internal API as user-modifiable hooks. By

779

adding your function to one of these hooks, you can modify IPython's

780

behavior to call at runtime your own routines."""

781

782

# At some point in the future, this should validate the hook before it

783

# accepts it. Probably at least check that the hook takes the number

784

# of args it's supposed to.

785

786

f = new.instancemethod(hook,self,self.__class__)

787

788

# check if the hook is for strdispatcher first

789

if str_key is not None:

790

sdp = self.strdispatchers.get(name, StrDispatch())

791

sdp.add_s(str_key, f, priority )

792

self.strdispatchers[name] = sdp

793

return

794

if re_key is not None:

795

sdp = self.strdispatchers.get(name, StrDispatch())

796

sdp.add_re(re.compile(re_key), f, priority )

797

self.strdispatchers[name] = sdp

798

return

799

800

dp = getattr(self.hooks, name, None)

801

if name not in IPython.hooks.__all__:

802

print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )

803

if not dp:

804

dp = IPython.hooks.CommandChainDispatcher()

805

806

try:

807

dp.add(f,priority)

808

except AttributeError:

809

# it was not commandchain, plain old func - replace

810

dp = f

811

812

setattr(self.hooks,name, dp)

813

814

815

#setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))

816

817

def set_crash_handler(self,crashHandler):

818

"""Set the IPython crash handler.

819

820

This must be a callable with a signature suitable for use as

821

sys.excepthook."""

822

823

# Install the given crash handler as the Python exception hook

824

sys.excepthook = crashHandler

825

826

# The instance will store a pointer to this, so that runtime code

827

# (such as magics) can access it. This is because during the

828

# read-eval loop, it gets temporarily overwritten (to deal with GUI

829

# frameworks).

830

self.sys_excepthook = sys.excepthook

831

832

833

def set_custom_exc(self,exc_tuple,handler):

834

"""set_custom_exc(exc_tuple,handler)

835

836

Set a custom exception handler, which will be called if any of the

837

exceptions in exc_tuple occur in the mainloop (specifically, in the

838

runcode() method.

839

840

Inputs:

841

842

- exc_tuple: a *tuple* of valid exceptions to call the defined

843

handler for. It is very important that you use a tuple, and NOT A

844

LIST here, because of the way Python's except statement works. If

845

you only want to trap a single exception, use a singleton tuple:

846

847

exc_tuple == (MyCustomException,)

848

849

- handler: this must be defined as a function with the following

850

basic interface: def my_handler(self,etype,value,tb).

851

852

This will be made into an instance method (via new.instancemethod)

853

of IPython itself, and it will be called if any of the exceptions

854

listed in the exc_tuple are caught. If the handler is None, an

855

internal basic one is used, which just prints basic info.

856

857

WARNING: by putting in your own exception handler into IPython's main

858

execution loop, you run a very good chance of nasty crashes. This

859

facility should only be used if you really know what you are doing."""

860

861

assert type(exc_tuple)==type(()) , \

862

"The custom exceptions must be given AS A TUPLE."

863

864

def dummy_handler(self,etype,value,tb):

865

print '*** Simple custom exception handler ***'

866

print 'Exception type :',etype

867

print 'Exception value:',value

868

print 'Traceback :',tb

869

print 'Source code :','\n'.join(self.buffer)

870

871

if handler is None: handler = dummy_handler

872

873

self.CustomTB = new.instancemethod(handler,self,self.__class__)

874

self.custom_exceptions = exc_tuple

875

876

def set_custom_completer(self,completer,pos=0):

877

"""set_custom_completer(completer,pos=0)

878

879

Adds a new custom completer function.

880

881

The position argument (defaults to 0) is the index in the completers

882

list where you want the completer to be inserted."""

883

884

newcomp = new.instancemethod(completer,self.Completer,

885

self.Completer.__class__)

886

self.Completer.matchers.insert(pos,newcomp)

887

888

def set_completer(self):

889

"""reset readline's completer to be our own."""

890

self.readline.set_completer(self.Completer.complete)

891

892

def _get_call_pdb(self):

893

return self._call_pdb

894

895

def _set_call_pdb(self,val):

896

897

if val not in (0,1,False,True):

898

raise ValueError,'new call_pdb value must be boolean'

899

900

# store value in instance

901

self._call_pdb = val

902

903

# notify the actual exception handlers

904

self.InteractiveTB.call_pdb = val

905

if self.isthreaded:

906

try:

907

self.sys_excepthook.call_pdb = val

908

except:

909

warn('Failed to activate pdb for threaded exception handler')

910

911

call_pdb = property(_get_call_pdb,_set_call_pdb,None,

912

'Control auto-activation of pdb at exceptions')

913

914

915

# These special functions get installed in the builtin namespace, to

916

# provide programmatic (pure python) access to magics, aliases and system

917

# calls. This is important for logging, user scripting, and more.

918

919

# We are basically exposing, via normal python functions, the three

920

# mechanisms in which ipython offers special call modes (magics for

921

# internal control, aliases for direct system access via pre-selected

922

# names, and !cmd for calling arbitrary system commands).

923

924

def ipmagic(self,arg_s):

925

"""Call a magic function by name.

926

927

Input: a string containing the name of the magic function to call and any

928

additional arguments to be passed to the magic.

929

930

ipmagic('name -opt foo bar') is equivalent to typing at the ipython

931

prompt:

932

933

In[1]: %name -opt foo bar

934

935

To call a magic without arguments, simply use ipmagic('name').

936

937

This provides a proper Python function to call IPython's magics in any

938

valid Python code you can type at the interpreter, including loops and

939

compound statements. It is added by IPython to the Python builtin

940

namespace upon initialization."""

941

942

args = arg_s.split(' ',1)

943

magic_name = args[0]

944

magic_name = magic_name.lstrip(self.ESC_MAGIC)

945

946

try:

947

magic_args = args[1]

948

except IndexError:

949

magic_args = ''

950

fn = getattr(self,'magic_'+magic_name,None)

951

if fn is None:

952

error("Magic function `%s` not found." % magic_name)

953

else:

954

magic_args = self.var_expand(magic_args,1)

955

return fn(magic_args)

956

957

def ipalias(self,arg_s):

958

"""Call an alias by name.

959

960

Input: a string containing the name of the alias to call and any

961

additional arguments to be passed to the magic.

962

963

ipalias('name -opt foo bar') is equivalent to typing at the ipython

964

prompt:

965

966

In[1]: name -opt foo bar

967

968

To call an alias without arguments, simply use ipalias('name').

969

970

This provides a proper Python function to call IPython's aliases in any

971

valid Python code you can type at the interpreter, including loops and

972

compound statements. It is added by IPython to the Python builtin

973

namespace upon initialization."""

974

975

args = arg_s.split(' ',1)

976

alias_name = args[0]

977

try:

978

alias_args = args[1]

979

except IndexError:

980

alias_args = ''

981

if alias_name in self.alias_table:

982

self.call_alias(alias_name,alias_args)

983

else:

984

error("Alias `%s` not found." % alias_name)

985

986

def ipsystem(self,arg_s):

987

"""Make a system call, using IPython."""

988

989

self.system(arg_s)

990

991

def complete(self,text):

992

"""Return a sorted list of all possible completions on text.

993

994

Inputs:

995

996

- text: a string of text to be completed on.

997

998

This is a wrapper around the completion mechanism, similar to what

999

readline does at the command line when the TAB key is hit. By

1000

exposing it as a method, it can be used by other non-readline

1001

environments (such as GUIs) for text completion.

1002

1003

Simple usage example:

1004

1005

In [1]: x = 'hello'

1006

1007

In [2]: __IP.complete('x.l')

1008

Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""

1009

1010

complete = self.Completer.complete

1011

state = 0

1012

# use a dict so we get unique keys, since ipyhton's multiple

1013

# completers can return duplicates. When we make 2.4 a requirement,

1014

# start using sets instead, which are faster.

1015

comps = {}

1016

while True:

1017

newcomp = complete(text,state,line_buffer=text)

1018

if newcomp is None:

1019

break

1020

comps[newcomp] = 1

1021

state += 1

1022

outcomps = comps.keys()

1023

outcomps.sort()

1024

return outcomps

1025

1026

def set_completer_frame(self, frame=None):

1027

if frame:

1028

self.Completer.namespace = frame.f_locals

1029

self.Completer.global_namespace = frame.f_globals

1030

else:

1031

self.Completer.namespace = self.user_ns

1032

self.Completer.global_namespace = self.user_global_ns

1033

1034

def init_auto_alias(self):

1035

"""Define some aliases automatically.

1036

1037

These are ALL parameter-less aliases"""

1038

1039

for alias,cmd in self.auto_alias:

1040

self.getapi().defalias(alias,cmd)

1041

1042

1043

def alias_table_validate(self,verbose=0):

1044

"""Update information about the alias table.

1045

1046

In particular, make sure no Python keywords/builtins are in it."""

1047

1048

no_alias = self.no_alias

1049

for k in self.alias_table.keys():

1050

if k in no_alias:

1051

del self.alias_table[k]

1052

if verbose:

1053

print ("Deleting alias <%s>, it's a Python "

1054

"keyword or builtin." % k)

1055

1056

def set_autoindent(self,value=None):

1057

"""Set the autoindent flag, checking for readline support.

1058

1059

If called with no arguments, it acts as a toggle."""

1060

1061

if not self.has_readline:

1062

if os.name == 'posix':

1063

warn("The auto-indent feature requires the readline library")

1064

self.autoindent = 0

1065

return

1066

if value is None:

1067

self.autoindent = not self.autoindent

1068

else:

1069

self.autoindent = value

1070

1071

def rc_set_toggle(self,rc_field,value=None):

1072

"""Set or toggle a field in IPython's rc config. structure.

1073

1074

If called with no arguments, it acts as a toggle.

1075

1076

If called with a non-existent field, the resulting AttributeError

1077

exception will propagate out."""

1078

1079

rc_val = getattr(self.rc,rc_field)

1080

if value is None:

1081

value = not rc_val

1082

setattr(self.rc,rc_field,value)

1083

1084

def user_setup(self,ipythondir,rc_suffix,mode='install'):

1085

"""Install the user configuration directory.

1086

1087

Can be called when running for the first time or to upgrade the user's

1088

.ipython/ directory with the mode parameter. Valid modes are 'install'

1089

and 'upgrade'."""

1090

1091

def wait():

1092

try:

1093

raw_input("Please press <RETURN> to start IPython.")

1094

except EOFError:

1095

print >> Term.cout

1096

print '*'*70

1097

1098

cwd = os.getcwd() # remember where we started

1099

glb = glob.glob

1100

print '*'*70

1101

if mode == 'install':

1102

print \

1103

"""Welcome to IPython. I will try to create a personal configuration directory

1104

where you can customize many aspects of IPython's functionality in:\n"""

1105

else:

1106

print 'I am going to upgrade your configuration in:'

1107

1108

print ipythondir

1109

1110

rcdirend = os.path.join('IPython','UserConfig')

1111

cfg = lambda d: os.path.join(d,rcdirend)

1112

try:

1113

rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]

1114

print "Initializing from configuration",rcdir

1115

except IndexError:

1116

warning = """

1117

Installation error. IPython's directory was not found.

1118

1119

Check the following:

1120

1121

The ipython/IPython directory should be in a directory belonging to your

1122

PYTHONPATH environment variable (that is, it should be in a directory

1123

belonging to sys.path). You can copy it explicitly there or just link to it.

1124

1125

IPython will create a minimal default configuration for you.

1126

1127

"""

1128

warn(warning)

1129

wait()

1130

1131

if sys.platform =='win32':

1132

inif = 'ipythonrc.ini'

1133

else:

1134

inif = 'ipythonrc'

1135

minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }

1136

os.makedirs(ipythondir, mode = 0777)

1137

for f, cont in minimal_setup.items():

1138

open(ipythondir + '/' + f,'w').write(cont)

1139

1140

return

1141

1142

if mode == 'install':

1143

try:

1144

shutil.copytree(rcdir,ipythondir)

1145

os.chdir(ipythondir)

1146

rc_files = glb("ipythonrc*")

1147

for rc_file in rc_files:

1148

os.rename(rc_file,rc_file+rc_suffix)

1149

except:

1150

warning = """

1151

1152

There was a problem with the installation:

1153

%s

1154

Try to correct it or contact the developers if you think it's a bug.

1155

IPython will proceed with builtin defaults.""" % sys.exc_info()[1]

1156

warn(warning)

1157

wait()

1158

return

1159

1160

elif mode == 'upgrade':

1161

try:

1162

os.chdir(ipythondir)

1163

except:

1164

print """

1165

Can not upgrade: changing to directory %s failed. Details:

1166

%s

1167

""" % (ipythondir,sys.exc_info()[1])

1168

wait()

1169

return

1170

else:

1171

sources = glb(os.path.join(rcdir,'[A-Za-z]*'))

1172

for new_full_path in sources:

1173

new_filename = os.path.basename(new_full_path)

1174

if new_filename.startswith('ipythonrc'):

1175

new_filename = new_filename + rc_suffix

1176

# The config directory should only contain files, skip any

1177

# directories which may be there (like CVS)

1178

if os.path.isdir(new_full_path):

1179

continue

1180

if os.path.exists(new_filename):

1181

old_file = new_filename+'.old'

1182

if os.path.exists(old_file):

1183

os.remove(old_file)

1184

os.rename(new_filename,old_file)

1185

shutil.copy(new_full_path,new_filename)

1186

else:

1187

raise ValueError,'unrecognized mode for install:',`mode`

1188

1189

# Fix line-endings to those native to each platform in the config

1190

# directory.

1191

try:

1192

os.chdir(ipythondir)

1193

except:

1194

print """

1195

Problem: changing to directory %s failed.

1196

Details:

1197

%s

1198

1199

Some configuration files may have incorrect line endings. This should not

1200

cause any problems during execution. """ % (ipythondir,sys.exc_info()[1])

1201

wait()

1202

else:

1203

for fname in glb('ipythonrc*'):

1204

try:

1205

native_line_ends(fname,backup=0)

1206

except IOError:

1207

pass

1208

1209

if mode == 'install':

1210

print """

1211

Successful installation!

1212

1213

Please read the sections 'Initial Configuration' and 'Quick Tips' in the

1214

IPython manual (there are both HTML and PDF versions supplied with the

1215

distribution) to make sure that your system environment is properly configured

1216

to take advantage of IPython's features.

1217

1218

Important note: the configuration system has changed! The old system is

1219

still in place, but its setting may be partly overridden by the settings in

1220

"~/.ipython/ipy_user_conf.py" config file. Please take a look at the file

1221

if some of the new settings bother you.

1222

1223

"""

1224

else:

1225

print """

1226

Successful upgrade!

1227

1228

All files in your directory:

1229

%(ipythondir)s

1230

which would have been overwritten by the upgrade were backed up with a .old

1231

extension. If you had made particular customizations in those files you may

1232

want to merge them back into the new files.""" % locals()

1233

wait()

1234

os.chdir(cwd)

1235

# end user_setup()

1236

1237

def atexit_operations(self):

1238

"""This will be executed at the time of exit.

1239

1240

Saving of persistent data should be performed here. """

1241

1242

#print '*** IPython exit cleanup ***' # dbg

1243

# input history

1244

self.savehist()

1245

1246

# Cleanup all tempfiles left around

1247

for tfile in self.tempfiles:

1248

try:

1249

os.unlink(tfile)

1250

except OSError:

1251

pass

1252

1253

self.hooks.shutdown_hook()

1254

1255

def savehist(self):

1256

"""Save input history to a file (via readline library)."""

1257

1258

if not self.has_readline:

1259

return

1260

1261

try:

1262

self.readline.write_history_file(self.histfile)

1263

except:

1264

print 'Unable to save IPython command history to file: ' + \

1265

`self.histfile`

1266

1267

def reloadhist(self):

1268

"""Reload the input history from disk file."""

1269

1270

if self.has_readline:

1271

try:

1272

self.readline.clear_history()

1273

except AttributeError:

1274

pass

1275

1276

self.readline.read_history_file(self.shell.histfile)

1277

1278

def history_saving_wrapper(self, func):

1279

""" Wrap func for readline history saving

1280

1281

Convert func into callable that saves & restores

1282

history around the call """

1283

1284

if not self.has_readline:

1285

return func

1286

1287

def wrapper():

1288

self.savehist()

1289

try:

1290

func()

1291

finally:

1292

readline.read_history_file(self.histfile)

1293

return wrapper

1294

1295

1296

def pre_readline(self):

1297

"""readline hook to be used at the start of each line.

1298

1299

Currently it handles auto-indent only."""

1300

1301

#debugx('self.indent_current_nsp','pre_readline:')

1302

1303

if self.rl_do_indent:

1304

self.readline.insert_text(self.indent_current_str())

1305

if self.rl_next_input is not None:

1306

self.readline.insert_text(self.rl_next_input)

1307

self.rl_next_input = None

1308

1309

def init_readline(self):

1310

"""Command history completion/saving/reloading."""

1311

1312

1313

import IPython.rlineimpl as readline

1314

1315

if not readline.have_readline:

1316

self.has_readline = 0

1317

self.readline = None

1318

# no point in bugging windows users with this every time:

1319

warn('Readline services not available on this platform.')

1320

else:

1321

sys.modules['readline'] = readline

1322

import atexit

1323

from IPython.completer import IPCompleter

1324

self.Completer = IPCompleter(self,

1325

self.user_ns,

1326

self.user_global_ns,

1327

self.rc.readline_omit__names,

1328

self.alias_table)

1329

sdisp = self.strdispatchers.get('complete_command', StrDispatch())

1330

self.strdispatchers['complete_command'] = sdisp

1331

self.Completer.custom_completers = sdisp

1332

# Platform-specific configuration

1333

if os.name == 'nt':

1334

self.readline_startup_hook = readline.set_pre_input_hook

1335

else:

1336

self.readline_startup_hook = readline.set_startup_hook

1337

1338

# Load user's initrc file (readline config)

1339

# Or if libedit is used, load editrc.

1340

inputrc_name = os.environ.get('INPUTRC')

1341

if inputrc_name is None:

1342

home_dir = get_home_dir()

1343

if home_dir is not None:

1344

inputrc_name = '.inputrc'

1345

if readline.uses_libedit:

1346

inputrc_name = '.editrc'

1347

inputrc_name = os.path.join(home_dir, inputrc_name)

1348

if os.path.isfile(inputrc_name):

1349

try:

1350

readline.read_init_file(inputrc_name)

1351

except:

1352

warn('Problems reading readline initialization file <%s>'

1353

% inputrc_name)

1354

1355

self.has_readline = 1

1356

self.readline = readline

1357

# save this in sys so embedded copies can restore it properly

1358

sys.ipcompleter = self.Completer.complete

1359

self.set_completer()

1360

1361

# Configure readline according to user's prefs

1362

# This is only done if GNU readline is being used. If libedit

1363

# is being used (as on Leopard) the readline config is

1364

# not run as the syntax for libedit is different.

1365

if not readline.uses_libedit:

1366

for rlcommand in self.rc.readline_parse_and_bind:

1367

readline.parse_and_bind(rlcommand)

1368

1369

# remove some chars from the delimiters list

1370

delims = readline.get_completer_delims()

1371

delims = delims.translate(string._idmap,

1372

self.rc.readline_remove_delims)

1373

readline.set_completer_delims(delims)

1374

# otherwise we end up with a monster history after a while:

1375

readline.set_history_length(1000)

1376

try:

1377

#print '*** Reading readline history' # dbg

1378

readline.read_history_file(self.histfile)

1379

except IOError:

1380

pass # It doesn't exist yet.

1381

1382

atexit.register(self.atexit_operations)

1383

del atexit

1384

1385

# Configure auto-indent for all platforms

1386

self.set_autoindent(self.rc.autoindent)

1387

1388

def ask_yes_no(self,prompt,default=True):

1389

if self.rc.quiet:

1390

return True

1391

return ask_yes_no(prompt,default)

1392

1393

def _should_recompile(self,e):

1394

"""Utility routine for edit_syntax_error"""

1395

1396

if e.filename in ('<ipython console>','<input>','<string>',

1397

'<console>','<BackgroundJob compilation>',

1398

None):

1399

1400

return False

1401

try:

1402

if (self.rc.autoedit_syntax and

1403

not self.ask_yes_no('Return to editor to correct syntax error? '

1404

'[Y/n] ','y')):

1405

return False

1406

except EOFError:

1407

return False

1408

1409

def int0(x):

1410

try:

1411

return int(x)

1412

except TypeError:

1413

return 0

1414

# always pass integer line and offset values to editor hook

1415

self.hooks.fix_error_editor(e.filename,

1416

int0(e.lineno),int0(e.offset),e.msg)

1417

return True

1418

1419

def edit_syntax_error(self):

1420

"""The bottom half of the syntax error handler called in the main loop.

1421

1422

Loop until syntax error is fixed or user cancels.

1423

"""

1424

1425

while self.SyntaxTB.last_syntax_error:

1426

# copy and clear last_syntax_error

1427

err = self.SyntaxTB.clear_err_state()

1428

if not self._should_recompile(err):

1429

return

1430

try:

1431

# may set last_syntax_error again if a SyntaxError is raised

1432

self.safe_execfile(err.filename,self.user_ns)

1433

except:

1434

self.showtraceback()

1435

else:

1436

try:

1437

f = file(err.filename)

1438

try:

1439

sys.displayhook(f.read())

1440

finally:

1441

f.close()

1442

except:

1443

self.showtraceback()

1444

1445

def showsyntaxerror(self, filename=None):

1446

"""Display the syntax error that just occurred.

1447

1448

This doesn't display a stack trace because there isn't one.

1449

1450

If a filename is given, it is stuffed in the exception instead

1451

of what was there before (because Python's parser always uses

1452

"<string>" when reading from a string).

1453

"""

1454

etype, value, last_traceback = sys.exc_info()

1455

1456

# See note about these variables in showtraceback() below

1457

sys.last_type = etype

1458

sys.last_value = value

1459

sys.last_traceback = last_traceback

1460

1461

if filename and etype is SyntaxError:

1462

# Work hard to stuff the correct filename in the exception

1463

try:

1464

msg, (dummy_filename, lineno, offset, line) = value

1465

except:

1466

# Not the format we expect; leave it alone

1467

pass

1468

else:

1469

# Stuff in the right filename

1470

try:

1471

# Assume SyntaxError is a class exception

1472

value = SyntaxError(msg, (filename, lineno, offset, line))

1473

except:

1474

# If that failed, assume SyntaxError is a string

1475

value = msg, (filename, lineno, offset, line)

1476

self.SyntaxTB(etype,value,[])

1477

1478

def debugger(self,force=False):

1479

"""Call the pydb/pdb debugger.

1480

1481

Keywords:

1482

1483

- force(False): by default, this routine checks the instance call_pdb

1484

flag and does not actually invoke the debugger if the flag is false.

1485

The 'force' option forces the debugger to activate even if the flag

1486

is false.

1487

"""

1488

1489

if not (force or self.call_pdb):

1490

return

1491

1492

if not hasattr(sys,'last_traceback'):

1493

error('No traceback has been produced, nothing to debug.')

1494

return

1495

1496

# use pydb if available

1497

if Debugger.has_pydb:

1498

from pydb import pm

1499

else:

1500

# fallback to our internal debugger

1501

pm = lambda : self.InteractiveTB.debugger(force=True)

1502

self.history_saving_wrapper(pm)()

1503

1504

def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):

1505

"""Display the exception that just occurred.

1506

1507

If nothing is known about the exception, this is the method which

1508

should be used throughout the code for presenting user tracebacks,

1509

rather than directly invoking the InteractiveTB object.

1510

1511

A specific showsyntaxerror() also exists, but this method can take

1512

care of calling it if needed, so unless you are explicitly catching a

1513

SyntaxError exception, don't try to analyze the stack manually and

1514

simply call this method."""

1515

1516

1517

# Though this won't be called by syntax errors in the input line,

1518

# there may be SyntaxError cases whith imported code.

1519

1520

try:

1521

if exc_tuple is None:

1522

etype, value, tb = sys.exc_info()

1523

else:

1524

etype, value, tb = exc_tuple

1525

1526

if etype is SyntaxError:

1527

self.showsyntaxerror(filename)

1528

elif etype is IPython.ipapi.UsageError:

1529

print "UsageError:", value

1530

else:

1531

# WARNING: these variables are somewhat deprecated and not

1532

# necessarily safe to use in a threaded environment, but tools

1533

# like pdb depend on their existence, so let's set them. If we

1534

# find problems in the field, we'll need to revisit their use.

1535

sys.last_type = etype

1536

sys.last_value = value

1537

sys.last_traceback = tb

1538

1539

if etype in self.custom_exceptions:

1540

self.CustomTB(etype,value,tb)

1541

else:

1542

self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)

1543

if self.InteractiveTB.call_pdb and self.has_readline:

1544

# pdb mucks up readline, fix it back

1545

self.set_completer()

1546

except KeyboardInterrupt:

1547

self.write("\nKeyboardInterrupt\n")

1548

1549

1550

1551

def mainloop(self,banner=None):

1552

"""Creates the local namespace and starts the mainloop.

1553

1554

If an optional banner argument is given, it will override the

1555

internally created default banner."""

1556

1557

if self.rc.c: # Emulate Python's -c option

1558

self.exec_init_cmd()

1559

if banner is None:

1560

if not self.rc.banner:

1561

banner = ''

1562

# banner is string? Use it directly!

1563

elif isinstance(self.rc.banner,basestring):

1564

banner = self.rc.banner

1565

else:

1566

banner = self.BANNER+self.banner2

1567

1568

while 1:

1569

try:

1570

self.interact(banner)

1571

#self.interact_with_readline()

1572

# XXX for testing of a readline-decoupled repl loop, call interact_with_readline above

1573

1574

break

1575

except KeyboardInterrupt:

1576

# this should not be necessary, but KeyboardInterrupt

1577

# handling seems rather unpredictable...

1578

self.write("\nKeyboardInterrupt in interact()\n")

1579

1580

def exec_init_cmd(self):

1581

"""Execute a command given at the command line.

1582

1583

This emulates Python's -c option."""

1584

1585

#sys.argv = ['-c']

1586

self.push(self.prefilter(self.rc.c, False))

1587

if not self.rc.interact:

1588

self.exit_now = True

1589

1590

def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):

1591

"""Embeds IPython into a running python program.

1592

1593

Input:

1594

1595

- header: An optional header message can be specified.

1596

1597

- local_ns, global_ns: working namespaces. If given as None, the

1598

IPython-initialized one is updated with __main__.__dict__, so that

1599

program variables become visible but user-specific configuration

1600

remains possible.

1601

1602

- stack_depth: specifies how many levels in the stack to go to

1603

looking for namespaces (when local_ns and global_ns are None). This

1604

allows an intermediate caller to make sure that this function gets

1605

the namespace from the intended level in the stack. By default (0)

1606

it will get its locals and globals from the immediate caller.

1607

1608

Warning: it's possible to use this in a program which is being run by

1609

IPython itself (via %run), but some funny things will happen (a few

1610

globals get overwritten). In the future this will be cleaned up, as

1611

there is no fundamental reason why it can't work perfectly."""

1612

1613

# Get locals and globals from caller

1614

if local_ns is None or global_ns is None:

1615

call_frame = sys._getframe(stack_depth).f_back

1616

1617

if local_ns is None:

1618

local_ns = call_frame.f_locals

1619

if global_ns is None:

1620

global_ns = call_frame.f_globals

1621

1622

# Update namespaces and fire up interpreter

1623

1624

# The global one is easy, we can just throw it in

1625

self.user_global_ns = global_ns

1626

1627

# but the user/local one is tricky: ipython needs it to store internal

1628

# data, but we also need the locals. We'll copy locals in the user

1629

# one, but will track what got copied so we can delete them at exit.

1630

# This is so that a later embedded call doesn't see locals from a

1631

# previous call (which most likely existed in a separate scope).

1632

local_varnames = local_ns.keys()

1633

self.user_ns.update(local_ns)

1634

1635

# Patch for global embedding to make sure that things don't overwrite

1636

# user globals accidentally. Thanks to Richard <rxe@renre-europe.com>

1637

# FIXME. Test this a bit more carefully (the if.. is new)

1638

if local_ns is None and global_ns is None:

1639

self.user_global_ns.update(__main__.__dict__)

1640

1641

# make sure the tab-completer has the correct frame information, so it

1642

# actually completes using the frame's locals/globals

1643

self.set_completer_frame()

1644

1645

# before activating the interactive mode, we need to make sure that

1646

# all names in the builtin namespace needed by ipython point to

1647

# ourselves, and not to other instances.

1648

self.add_builtins()

1649

1650

self.interact(header)

1651

1652

# now, purge out the user namespace from anything we might have added

1653

# from the caller's local namespace

1654

delvar = self.user_ns.pop

1655

for var in local_varnames:

1656

delvar(var,None)

1657

# and clean builtins we may have overridden

1658

self.clean_builtins()

1659

1660

def interact_prompt(self):

1661

""" Print the prompt (in read-eval-print loop)

1662

1663

Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not

1664

used in standard IPython flow.

1665

"""

1666

if self.more:

1667

try:

1668

prompt = self.hooks.generate_prompt(True)

1669

except:

1670

self.showtraceback()

1671

if self.autoindent:

1672

self.rl_do_indent = True

1673

1674

else:

1675

try:

1676

prompt = self.hooks.generate_prompt(False)

1677

except:

1678

self.showtraceback()

1679

self.write(prompt)

1680

1681

def interact_handle_input(self,line):

1682

""" Handle the input line (in read-eval-print loop)

1683

1684

Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not

1685

used in standard IPython flow.

1686

"""

1687

if line.lstrip() == line:

1688

self.shadowhist.add(line.strip())

1689

lineout = self.prefilter(line,self.more)

1690

1691

if line.strip():

1692

if self.more:

1693

self.input_hist_raw[-1] += '%s\n' % line

1694

else:

1695

self.input_hist_raw.append('%s\n' % line)

1696

1697

1698

self.more = self.push(lineout)

1699

if (self.SyntaxTB.last_syntax_error and

1700

self.rc.autoedit_syntax):

1701

self.edit_syntax_error()

1702

1703

def interact_with_readline(self):

1704

""" Demo of using interact_handle_input, interact_prompt

1705

1706

This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),

1707

it should work like this.

1708

"""

1709

self.readline_startup_hook(self.pre_readline)

1710

while not self.exit_now:

1711

self.interact_prompt()

1712

if self.more:

1713

self.rl_do_indent = True

1714

else:

1715

self.rl_do_indent = False

1716

line = raw_input_original().decode(self.stdin_encoding)

1717

self.interact_handle_input(line)

1718

1719

1720

def interact(self, banner=None):

1721

"""Closely emulate the interactive Python console.

1722

1723

The optional banner argument specify the banner to print

1724

before the first interaction; by default it prints a banner

1725

similar to the one printed by the real Python interpreter,

1726

followed by the current class name in parentheses (so as not

1727

to confuse this with the real interpreter -- since it's so

1728

close!).

1729

1730

"""

1731

1732

if self.exit_now:

1733

# batch run -> do not interact

1734

return

1735

cprt = 'Type "copyright", "credits" or "license" for more information.'

1736

if banner is None:

1737

self.write("Python %s on %s\n%s\n(%s)\n" %

1738

(sys.version, sys.platform, cprt,

1739

self.__class__.__name__))

1740

else:

1741

self.write(banner)

1742

1743

more = 0

1744

1745

# Mark activity in the builtins

1746

__builtin__.__dict__['__IPYTHON__active'] += 1

1747

1748

if self.has_readline:

1749

self.readline_startup_hook(self.pre_readline)

1750

# exit_now is set by a call to %Exit or %Quit

1751

1752

while not self.exit_now:

1753

self.hooks.pre_prompt_hook()

1754

if more:

1755

try:

1756

prompt = self.hooks.generate_prompt(True)

1757

except:

1758

self.showtraceback()

1759

if self.autoindent:

1760

self.rl_do_indent = True

1761

1762

else:

1763

try:

1764

prompt = self.hooks.generate_prompt(False)

1765

except:

1766

self.showtraceback()

1767

try:

1768

line = self.raw_input(prompt,more)

1769

if self.exit_now:

1770

# quick exit on sys.std[in|out] close

1771

break

1772

if self.autoindent:

1773

self.rl_do_indent = False

1774

1775

except KeyboardInterrupt:

1776

#double-guard against keyboardinterrupts during kbdint handling

1777

try:

1778

self.write('\nKeyboardInterrupt\n')

1779

self.resetbuffer()

1780

# keep cache in sync with the prompt counter:

1781

self.outputcache.prompt_count -= 1

1782

1783

if self.autoindent:

1784

self.indent_current_nsp = 0

1785

more = 0

1786

except KeyboardInterrupt:

1787

pass

1788

except EOFError:

1789

if self.autoindent:

1790

self.rl_do_indent = False

1791

self.readline_startup_hook(None)

1792

self.write('\n')

1793

self.exit()

1794

except bdb.BdbQuit:

1795

warn('The Python debugger has exited with a BdbQuit exception.\n'

1796

'Because of how pdb handles the stack, it is impossible\n'

1797

'for IPython to properly format this particular exception.\n'

1798

'IPython will resume normal operation.')

1799

except:

1800

# exceptions here are VERY RARE, but they can be triggered

1801

# asynchronously by signal handlers, for example.

1802

self.showtraceback()

1803

else:

1804

more = self.push(line)

1805

if (self.SyntaxTB.last_syntax_error and

1806

self.rc.autoedit_syntax):

1807

self.edit_syntax_error()

1808

1809

# We are off again...

1810

__builtin__.__dict__['__IPYTHON__active'] -= 1

1811

1812

def excepthook(self, etype, value, tb):

1813

"""One more defense for GUI apps that call sys.excepthook.

1814

1815

GUI frameworks like wxPython trap exceptions and call

1816

sys.excepthook themselves. I guess this is a feature that

1817

enables them to keep running after exceptions that would

1818

otherwise kill their mainloop. This is a bother for IPython

1819

which excepts to catch all of the program exceptions with a try:

1820

except: statement.

1821

1822

Normally, IPython sets sys.excepthook to a CrashHandler instance, so if

1823

any app directly invokes sys.excepthook, it will look to the user like

1824

IPython crashed. In order to work around this, we can disable the

1825

CrashHandler and replace it with this excepthook instead, which prints a

1826

regular traceback using our InteractiveTB. In this fashion, apps which

1827

call sys.excepthook will generate a regular-looking exception from

1828

IPython, and the CrashHandler will only be triggered by real IPython

1829

crashes.

1830

1831

This hook should be used sparingly, only in places which are not likely

1832

to be true IPython errors.

1833

"""

1834

self.showtraceback((etype,value,tb),tb_offset=0)

1835

1836

def expand_aliases(self,fn,rest):

1837

""" Expand multiple levels of aliases:

1838

1839

if:

1840

1841

alias foo bar /tmp

1842

alias baz foo

1843

1844

then:

1845

1846

baz huhhahhei -> bar /tmp huhhahhei

1847

1848

"""

1849

line = fn + " " + rest

1850

1851

done = Set()

1852

while 1:

1853

pre,fn,rest = prefilter.splitUserInput(line,

1854

prefilter.shell_line_split)

1855

if fn in self.alias_table:

1856

if fn in done:

1857

warn("Cyclic alias definition, repeated '%s'" % fn)

1858

return ""

1859

done.add(fn)

1860

1861

l2 = self.transform_alias(fn,rest)

1862

# dir -> dir

1863

# print "alias",line, "->",l2 #dbg

1864

if l2 == line:

1865

break

1866

# ls -> ls -F should not recurse forever

1867

if l2.split(None,1)[0] == line.split(None,1)[0]:

1868

line = l2

1869

break

1870

1871

line=l2

1872

1873

1874

# print "al expand to",line #dbg

1875

else:

1876

break

1877

1878

return line

1879

1880

def transform_alias(self, alias,rest=''):

1881

""" Transform alias to system command string.

1882

"""

1883

trg = self.alias_table[alias]

1884

1885

nargs,cmd = trg

1886

# print trg #dbg

1887

if ' ' in cmd and os.path.isfile(cmd):

1888

cmd = '"%s"' % cmd

1889

1890

# Expand the %l special to be the user's input line

1891

if cmd.find('%l') >= 0:

1892

cmd = cmd.replace('%l',rest)

1893

rest = ''

1894

if nargs==0:

1895

# Simple, argument-less aliases

1896

cmd = '%s %s' % (cmd,rest)

1897

else:

1898

# Handle aliases with positional arguments

1899

args = rest.split(None,nargs)

1900

if len(args)< nargs:

1901

error('Alias <%s> requires %s arguments, %s given.' %

1902

(alias,nargs,len(args)))

1903

return None

1904

cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))

1905

# Now call the macro, evaluating in the user's namespace

1906

#print 'new command: <%r>' % cmd # dbg

1907

return cmd

1908

1909

def call_alias(self,alias,rest=''):

1910

"""Call an alias given its name and the rest of the line.

1911

1912

This is only used to provide backwards compatibility for users of

1913

ipalias(), use of which is not recommended for anymore."""

1914

1915

# Now call the macro, evaluating in the user's namespace

1916

cmd = self.transform_alias(alias, rest)

1917

try:

1918

self.system(cmd)

1919

except:

1920

self.showtraceback()

1921

1922

def indent_current_str(self):

1923

"""return the current level of indentation as a string"""

1924

return self.indent_current_nsp * ' '

1925

1926

def autoindent_update(self,line):

1927

"""Keep track of the indent level."""

1928

1929

#debugx('line')

1930

#debugx('self.indent_current_nsp')

1931

if self.autoindent:

1932

if line:

1933

inisp = num_ini_spaces(line)

1934

if inisp < self.indent_current_nsp:

1935

self.indent_current_nsp = inisp

1936

1937

if line[-1] == ':':

1938

self.indent_current_nsp += 4

1939

elif dedent_re.match(line):

1940

self.indent_current_nsp -= 4

1941

else:

1942

self.indent_current_nsp = 0

1943

1944

def runlines(self,lines):

1945

"""Run a string of one or more lines of source.

1946

1947

This method is capable of running a string containing multiple source

1948

lines, as if they had been entered at the IPython prompt. Since it

1949

exposes IPython's processing machinery, the given strings can contain

1950

magic calls (%magic), special shell access (!cmd), etc."""

1951

1952

# We must start with a clean buffer, in case this is run from an

1953

# interactive IPython session (via a magic, for example).

1954

self.resetbuffer()

1955

lines = lines.split('\n')

1956

more = 0

1957

1958

for line in lines:

1959

# skip blank lines so we don't mess up the prompt counter, but do

1960

# NOT skip even a blank line if we are in a code block (more is

1961

# true)

1962

1963

1964

if line or more:

1965

# push to raw history, so hist line numbers stay in sync

1966

self.input_hist_raw.append("# " + line + "\n")

1967

more = self.push(self.prefilter(line,more))

1968

# IPython's runsource returns None if there was an error

1969

# compiling the code. This allows us to stop processing right

1970

# away, so the user gets the error message at the right place.

1971

if more is None:

1972

break

1973

else:

1974

self.input_hist_raw.append("\n")

1975

# final newline in case the input didn't have it, so that the code

1976

# actually does get executed

1977

if more:

1978

self.push('\n')

1979

1980

def runsource(self, source, filename='<input>', symbol='single'):

1981

"""Compile and run some source in the interpreter.

1982

1983

Arguments are as for compile_command().

1984

1985

One several things can happen:

1986

1987

1) The input is incorrect; compile_command() raised an

1988

exception (SyntaxError or OverflowError). A syntax traceback

1989

will be printed by calling the showsyntaxerror() method.

1990

1991

2) The input is incomplete, and more input is required;

1992

compile_command() returned None. Nothing happens.

1993

1994

3) The input is complete; compile_command() returned a code

1995

object. The code is executed by calling self.runcode() (which

1996

also handles run-time exceptions, except for SystemExit).

1997

1998

The return value is:

1999

2000

- True in case 2

2001

2002

- False in the other cases, unless an exception is raised, where

2003

None is returned instead. This can be used by external callers to

2004

know whether to continue feeding input or not.

2005

2006

The return value can be used to decide whether to use sys.ps1 or

2007

sys.ps2 to prompt the next line."""

2008

2009

# if the source code has leading blanks, add 'if 1:\n' to it

2010

# this allows execution of indented pasted code. It is tempting

2011

# to add '\n' at the end of source to run commands like ' a=1'

2012

# directly, but this fails for more complicated scenarios

2013

source=source.encode(self.stdin_encoding)

2014

if source[:1] in [' ', '\t']:

2015

source = 'if 1:\n%s' % source

2016

2017

try:

2018

code = self.compile(source,filename,symbol)

2019

except (OverflowError, SyntaxError, ValueError):

2020

# Case 1

2021

self.showsyntaxerror(filename)

2022

return None

2023

2024

if code is None:

2025

# Case 2

2026

return True

2027

2028

# Case 3

2029

# We store the code object so that threaded shells and

2030

# custom exception handlers can access all this info if needed.

2031

# The source corresponding to this can be obtained from the

2032

# buffer attribute as '\n'.join(self.buffer).

2033

self.code_to_run = code

2034

# now actually execute the code object

2035

if self.runcode(code) == 0:

2036

return False

2037

else:

2038

return None

2039

2040

def runcode(self,code_obj):

2041

"""Execute a code object.

2042

2043

When an exception occurs, self.showtraceback() is called to display a

2044

traceback.

2045

2046

Return value: a flag indicating whether the code to be run completed

2047

successfully:

2048

2049

- 0: successful execution.

2050

- 1: an error occurred.

2051

"""

2052

2053

# Set our own excepthook in case the user code tries to call it

2054

# directly, so that the IPython crash handler doesn't get triggered

2055

old_excepthook,sys.excepthook = sys.excepthook, self.excepthook

2056

2057

# we save the original sys.excepthook in the instance, in case config

2058

# code (such as magics) needs access to it.

2059

self.sys_excepthook = old_excepthook

2060

outflag = 1 # happens in more places, so it's easier as default

2061

try:

2062

try:

2063

# Embedded instances require separate global/local namespaces

2064

# so they can see both the surrounding (local) namespace and

2065

# the module-level globals when called inside another function.

2066

if self.embedded:

2067

exec code_obj in self.user_global_ns, self.user_ns

2068

# Normal (non-embedded) instances should only have a single

2069

# namespace for user code execution, otherwise functions won't

2070

# see interactive top-level globals.

2071

else:

2072

exec code_obj in self.user_ns

2073

finally:

2074

# Reset our crash handler in place

2075

sys.excepthook = old_excepthook

2076

except SystemExit:

2077

self.resetbuffer()

2078

self.showtraceback()

2079

warn("Type %exit or %quit to exit IPython "

2080

"(%Exit or %Quit do so unconditionally).",level=1)

2081

except self.custom_exceptions:

2082

etype,value,tb = sys.exc_info()

2083

self.CustomTB(etype,value,tb)

2084

except:

2085

self.showtraceback()

2086

else:

2087

outflag = 0

2088

if softspace(sys.stdout, 0):

2089

print

2090

# Flush out code object which has been run (and source)

2091

self.code_to_run = None

2092

return outflag

2093

2094

def push(self, line):

2095

"""Push a line to the interpreter.

2096

2097

The line should not have a trailing newline; it may have

2098

internal newlines. The line is appended to a buffer and the

2099

interpreter's runsource() method is called with the

2100

concatenated contents of the buffer as source. If this

2101

indicates that the command was executed or invalid, the buffer

2102

is reset; otherwise, the command is incomplete, and the buffer

2103

is left as it was after the line was appended. The return

2104

value is 1 if more input is required, 0 if the line was dealt

2105

with in some way (this is the same as runsource()).

2106

"""

2107

2108

# autoindent management should be done here, and not in the

2109

# interactive loop, since that one is only seen by keyboard input. We

2110

# need this done correctly even for code run via runlines (which uses

2111

# push).

2112

2113

#print 'push line: <%s>' % line # dbg

2114

for subline in line.splitlines():

2115

self.autoindent_update(subline)

2116

self.buffer.append(line)

2117

more = self.runsource('\n'.join(self.buffer), self.filename)

2118

if not more:

2119

self.resetbuffer()

2120

return more

2121

2122

def split_user_input(self, line):

2123

# This is really a hold-over to support ipapi and some extensions

2124

return prefilter.splitUserInput(line)

2125

2126

def resetbuffer(self):

2127

"""Reset the input buffer."""

2128

self.buffer[:] = []

2129

2130

def raw_input(self,prompt='',continue_prompt=False):

2131

"""Write a prompt and read a line.

2132

2133

The returned line does not include the trailing newline.

2134

When the user enters the EOF key sequence, EOFError is raised.

2135

2136

Optional inputs:

2137

2138

- prompt(''): a string to be printed to prompt the user.

2139

2140

- continue_prompt(False): whether this line is the first one or a

2141

continuation in a sequence of inputs.

2142

"""

2143

2144

# Code run by the user may have modified the readline completer state.

2145

# We must ensure that our completer is back in place.

2146

if self.has_readline:

2147

self.set_completer()

2148

2149

try:

2150

line = raw_input_original(prompt).decode(self.stdin_encoding)

2151

except ValueError:

2152

warn("\n********\nYou or a %run:ed script called sys.stdin.close()"

2153

" or sys.stdout.close()!\nExiting IPython!")

2154

self.exit_now = True

2155

return ""

2156

2157

# Try to be reasonably smart about not re-indenting pasted input more

2158

# than necessary. We do this by trimming out the auto-indent initial

2159

# spaces, if the user's actual input started itself with whitespace.

2160

#debugx('self.buffer[-1]')

2161

2162

if self.autoindent:

2163

if num_ini_spaces(line) > self.indent_current_nsp:

2164

line = line[self.indent_current_nsp:]

2165

self.indent_current_nsp = 0

2166

2167

# store the unfiltered input before the user has any chance to modify

2168

# it.

2169

if line.strip():

2170

if continue_prompt:

2171

self.input_hist_raw[-1] += '%s\n' % line

2172

if self.has_readline: # and some config option is set?

2173

try:

2174

histlen = self.readline.get_current_history_length()

2175

if histlen > 1:

2176

newhist = self.input_hist_raw[-1].rstrip()

2177

self.readline.remove_history_item(histlen-1)

2178

self.readline.replace_history_item(histlen-2,

2179

newhist.encode(self.stdin_encoding))

2180

except AttributeError:

2181

pass # re{move,place}_history_item are new in 2.4.

2182

else:

2183

self.input_hist_raw.append('%s\n' % line)

2184

# only entries starting at first column go to shadow history

2185

if line.lstrip() == line:

2186

self.shadowhist.add(line.strip())

2187

elif not continue_prompt:

2188

self.input_hist_raw.append('\n')

2189

try:

2190

lineout = self.prefilter(line,continue_prompt)

2191

except:

2192

# blanket except, in case a user-defined prefilter crashes, so it

2193

# can't take all of ipython with it.

2194

self.showtraceback()

2195

return ''

2196

else:

2197

return lineout

2198

2199

def _prefilter(self, line, continue_prompt):

2200

"""Calls different preprocessors, depending on the form of line."""

2201

2202

# All handlers *must* return a value, even if it's blank ('').

2203

2204

# Lines are NOT logged here. Handlers should process the line as

2205

# needed, update the cache AND log it (so that the input cache array

2206

# stays synced).

2207

2208

#.....................................................................

2209

# Code begins

2210

2211

#if line.startswith('%crash'): raise RuntimeError,'Crash now!' # dbg

2212

2213

# save the line away in case we crash, so the post-mortem handler can

2214

# record it

2215

self._last_input_line = line

2216

2217

#print '***line: <%s>' % line # dbg

2218

2219

if not line:

2220

# Return immediately on purely empty lines, so that if the user

2221

# previously typed some whitespace that started a continuation

2222

# prompt, he can break out of that loop with just an empty line.

2223

# This is how the default python prompt works.

2224

2225

# Only return if the accumulated input buffer was just whitespace!

2226

if ''.join(self.buffer).isspace():

2227

self.buffer[:] = []

2228

return ''

2229

2230

line_info = prefilter.LineInfo(line, continue_prompt)

2231

2232

# the input history needs to track even empty lines

2233

stripped = line.strip()

2234

2235

if not stripped:

2236

if not continue_prompt:

2237

self.outputcache.prompt_count -= 1

2238

return self.handle_normal(line_info)

2239

2240

# print '***cont',continue_prompt # dbg

2241

# special handlers are only allowed for single line statements

2242

if continue_prompt and not self.rc.multi_line_specials:

2243

return self.handle_normal(line_info)

2244

2245

2246

# See whether any pre-existing handler can take care of it

2247

rewritten = self.hooks.input_prefilter(stripped)

2248

if rewritten != stripped: # ok, some prefilter did something

2249

rewritten = line_info.pre + rewritten # add indentation

2250

return self.handle_normal(prefilter.LineInfo(rewritten,

2251

continue_prompt))

2252

2253

#print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg

2254

2255

return prefilter.prefilter(line_info, self)

2256

2257

2258

def _prefilter_dumb(self, line, continue_prompt):

2259

"""simple prefilter function, for debugging"""

2260

return self.handle_normal(line,continue_prompt)

2261

2262

2263

def multiline_prefilter(self, line, continue_prompt):

2264

""" Run _prefilter for each line of input

2265

2266

Covers cases where there are multiple lines in the user entry,

2267

which is the case when the user goes back to a multiline history

2268

entry and presses enter.

2269

2270

"""

2271

out = []

2272

for l in line.rstrip('\n').split('\n'):

2273

out.append(self._prefilter(l, continue_prompt))

2274

return '\n'.join(out)

2275

2276

# Set the default prefilter() function (this can be user-overridden)

2277

prefilter = multiline_prefilter

2278

2279

def handle_normal(self,line_info):

2280

"""Handle normal input lines. Use as a template for handlers."""

2281

2282

# With autoindent on, we need some way to exit the input loop, and I

2283

# don't want to force the user to have to backspace all the way to

2284

# clear the line. The rule will be in this case, that either two

2285

# lines of pure whitespace in a row, or a line of pure whitespace but

2286

# of a size different to the indent level, will exit the input loop.

2287

line = line_info.line

2288

continue_prompt = line_info.continue_prompt

2289

2290

if (continue_prompt and self.autoindent and line.isspace() and

2291

(0 < abs(len(line) - self.indent_current_nsp) <= 2 or

2292

(self.buffer[-1]).isspace() )):

2293

line = ''

2294

2295

self.log(line,line,continue_prompt)

2296

return line

2297

2298

def handle_alias(self,line_info):

2299

"""Handle alias input lines. """

2300

tgt = self.alias_table[line_info.iFun]

2301

# print "=>",tgt #dbg

2302

if callable(tgt):

2303

if '$' in line_info.line:

2304

call_meth = '(_ip, _ip.itpl(%s))'

2305

else:

2306

call_meth = '(_ip,%s)'

2307

line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,

2308

line_info.iFun,

2309

make_quoted_expr(line_info.line))

2310

else:

2311

transformed = self.expand_aliases(line_info.iFun,line_info.theRest)

2312

2313

# pre is needed, because it carries the leading whitespace. Otherwise

2314

# aliases won't work in indented sections.

2315

line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,

2316

make_quoted_expr( transformed ))

2317

2318

self.log(line_info.line,line_out,line_info.continue_prompt)

2319

#print 'line out:',line_out # dbg

2320

return line_out

2321

2322

def handle_shell_escape(self, line_info):

2323

"""Execute the line in a shell, empty return value"""

2324

#print 'line in :', `line` # dbg

2325

line = line_info.line

2326

if line.lstrip().startswith('!!'):

2327

# rewrite LineInfo's line, iFun and theRest to properly hold the

2328

# call to %sx and the actual command to be executed, so

2329

# handle_magic can work correctly. Note that this works even if

2330

# the line is indented, so it handles multi_line_specials

2331

# properly.

2332

new_rest = line.lstrip()[2:]

2333

line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)

2334

line_info.iFun = 'sx'

2335

line_info.theRest = new_rest

2336

return self.handle_magic(line_info)

2337

else:

2338

cmd = line.lstrip().lstrip('!')

2339

line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,

2340

make_quoted_expr(cmd))

2341

# update cache/log and return

2342

self.log(line,line_out,line_info.continue_prompt)

2343

return line_out

2344

2345

def handle_magic(self, line_info):

2346

"""Execute magic functions."""

2347

iFun = line_info.iFun

2348

theRest = line_info.theRest

2349

cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,

2350

make_quoted_expr(iFun + " " + theRest))

2351

self.log(line_info.line,cmd,line_info.continue_prompt)

2352

#print 'in handle_magic, cmd=<%s>' % cmd # dbg

2353

return cmd

2354

2355

def handle_auto(self, line_info):

2356

"""Hande lines which can be auto-executed, quoting if requested."""

2357

2358

#print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg

2359

line = line_info.line

2360

iFun = line_info.iFun

2361

theRest = line_info.theRest

2362

pre = line_info.pre

2363

continue_prompt = line_info.continue_prompt

2364

obj = line_info.ofind(self)['obj']

2365

2366

# This should only be active for single-line input!

2367

if continue_prompt:

2368

self.log(line,line,continue_prompt)

2369

return line

2370

2371

force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)

2372

auto_rewrite = True

2373

2374

if pre == self.ESC_QUOTE:

2375

# Auto-quote splitting on whitespace

2376

newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )

2377

elif pre == self.ESC_QUOTE2:

2378

# Auto-quote whole string

2379

newcmd = '%s("%s")' % (iFun,theRest)

2380

elif pre == self.ESC_PAREN:

2381

newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))

2382

else:

2383

# Auto-paren.

2384

# We only apply it to argument-less calls if the autocall

2385

# parameter is set to 2. We only need to check that autocall is <

2386

# 2, since this function isn't called unless it's at least 1.

2387

if not theRest and (self.rc.autocall < 2) and not force_auto:

2388

newcmd = '%s %s' % (iFun,theRest)

2389

auto_rewrite = False

2390

else:

2391

if not force_auto and theRest.startswith('['):

2392

if hasattr(obj,'__getitem__'):

2393

# Don't autocall in this case: item access for an object

2394

# which is BOTH callable and implements __getitem__.

2395

newcmd = '%s %s' % (iFun,theRest)

2396

auto_rewrite = False

2397

else:

2398

# if the object doesn't support [] access, go ahead and

2399

# autocall

2400

newcmd = '%s(%s)' % (iFun.rstrip(),theRest)

2401

elif theRest.endswith(';'):

2402

newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])

2403

else:

2404

newcmd = '%s(%s)' % (iFun.rstrip(), theRest)

2405

2406

if auto_rewrite:

2407

rw = self.outputcache.prompt1.auto_rewrite() + newcmd

2408

2409

try:

2410

# plain ascii works better w/ pyreadline, on some machines, so

2411

# we use it and only print uncolored rewrite if we have unicode

2412

rw = str(rw)

2413

print >>Term.cout, rw

2414

except UnicodeEncodeError:

2415

print "-------------->" + newcmd

2416

2417

# log what is now valid Python, not the actual user input (without the

2418

# final newline)

2419

self.log(line,newcmd,continue_prompt)

2420

return newcmd

2421

2422

def handle_help(self, line_info):

2423

"""Try to get some help for the object.

2424

2425

obj? or ?obj -> basic information.

2426

obj?? or ??obj -> more details.

2427

"""

2428

2429

line = line_info.line

2430

# We need to make sure that we don't process lines which would be

2431

# otherwise valid python, such as "x=1 # what?"

2432

try:

2433

codeop.compile_command(line)

2434

except SyntaxError:

2435

# We should only handle as help stuff which is NOT valid syntax

2436

if line[0]==self.ESC_HELP:

2437

line = line[1:]

2438

elif line[-1]==self.ESC_HELP:

2439

line = line[:-1]

2440

self.log(line,'#?'+line,line_info.continue_prompt)

2441

if line:

2442

#print 'line:<%r>' % line # dbg

2443

self.magic_pinfo(line)

2444

else:

2445

page(self.usage,screen_lines=self.rc.screen_length)

2446

return '' # Empty string is needed here!

2447

except:

2448

# Pass any other exceptions through to the normal handler

2449

return self.handle_normal(line_info)

2450

else:

2451

# If the code compiles ok, we should handle it normally

2452

return self.handle_normal(line_info)

2453

2454

def getapi(self):

2455

""" Get an IPApi object for this shell instance

2456

2457

Getting an IPApi object is always preferable to accessing the shell

2458

directly, but this holds true especially for extensions.

2459

2460

It should always be possible to implement an extension with IPApi

2461

alone. If not, contact maintainer to request an addition.

2462

2463

"""

2464

return self.api

2465

2466

def handle_emacs(self, line_info):

2467

"""Handle input lines marked by python-mode."""

2468

2469

# Currently, nothing is done. Later more functionality can be added

2470

# here if needed.

2471

2472

# The input cache shouldn't be updated

2473

return line_info.line

2474

2475

2476

def mktempfile(self,data=None):

2477

"""Make a new tempfile and return its filename.

2478

2479

This makes a call to tempfile.mktemp, but it registers the created

2480

filename internally so ipython cleans it up at exit time.

2481

2482

Optional inputs:

2483

2484

- data(None): if data is given, it gets written out to the temp file

2485

immediately, and the file is closed again."""

2486

2487

filename = tempfile.mktemp('.py','ipython_edit_')

2488

self.tempfiles.append(filename)

2489

2490

if data:

2491

tmp_file = open(filename,'w')

2492

tmp_file.write(data)

2493

tmp_file.close()

2494

return filename

2495

2496

def write(self,data):

2497

"""Write a string to the default output"""

2498

Term.cout.write(data)

2499

2500

def write_err(self,data):

2501

"""Write a string to the default error output"""

2502

Term.cerr.write(data)

2503

2504

def exit(self):

2505

"""Handle interactive exit.

2506

2507

This method sets the exit_now attribute."""

2508

2509

if self.rc.confirm_exit:

2510

if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):

2511

self.exit_now = True

2512

else:

2513

self.exit_now = True

2514

2515

def safe_execfile(self,fname,*where,**kw):

2516

"""A safe version of the builtin execfile().

2517

2518

This version will never throw an exception, and knows how to handle

2519

ipython logs as well.

2520

2521

:Parameters:

2522

fname : string

2523

Name of the file to be executed.

2524

2525

where : tuple

2526

One or two namespaces, passed to execfile() as (globals,locals).

2527

If only one is given, it is passed as both.

2528

2529

:Keywords:

2530

islog : boolean (False)

2531

2532

quiet : boolean (True)

2533

2534

exit_ignore : boolean (False)

2535

"""

2536

2537

def syspath_cleanup():

2538

"""Internal cleanup routine for sys.path."""

2539

if add_dname:

2540

try:

2541

sys.path.remove(dname)

2542

except ValueError:

2543

# For some reason the user has already removed it, ignore.

2544

pass

2545

2546

fname = os.path.expanduser(fname)

2547

2548

# Find things also in current directory. This is needed to mimic the

2549

# behavior of running a script from the system command line, where

2550

# Python inserts the script's directory into sys.path

2551

dname = os.path.dirname(os.path.abspath(fname))

2552

add_dname = False

2553

if dname not in sys.path:

2554

sys.path.insert(0,dname)

2555

add_dname = True

2556

2557

try:

2558

xfile = open(fname)

2559

except:

2560

print >> Term.cerr, \

2561

'Could not open file <%s> for safe execution.' % fname

2562

syspath_cleanup()

2563

return None

2564

2565

kw.setdefault('islog',0)

2566

kw.setdefault('quiet',1)

2567

kw.setdefault('exit_ignore',0)

2568

2569

first = xfile.readline()

2570

loghead = str(self.loghead_tpl).split('\n',1)[0].strip()

2571

xfile.close()

2572

# line by line execution

2573

if first.startswith(loghead) or kw['islog']:

2574

print 'Loading log file <%s> one line at a time...' % fname

2575

if kw['quiet']:

2576

stdout_save = sys.stdout

2577

sys.stdout = StringIO.StringIO()

2578

try:

2579

globs,locs = where[0:2]

2580

except:

2581

try:

2582

globs = locs = where[0]

2583

except:

2584

globs = locs = globals()

2585

badblocks = []

2586

2587

# we also need to identify indented blocks of code when replaying

2588

# logs and put them together before passing them to an exec

2589

# statement. This takes a bit of regexp and look-ahead work in the

2590

# file. It's easiest if we swallow the whole thing in memory

2591

# first, and manually walk through the lines list moving the

2592

# counter ourselves.

2593

indent_re = re.compile('\s+\S')

2594

xfile = open(fname)

2595

filelines = xfile.readlines()

2596

xfile.close()

2597

nlines = len(filelines)

2598

lnum = 0

2599

while lnum < nlines:

2600

line = filelines[lnum]

2601

lnum += 1

2602

# don't re-insert logger status info into cache

2603

if line.startswith('#log#'):

2604

continue

2605

else:

2606

# build a block of code (maybe a single line) for execution

2607

block = line

2608

try:

2609

next = filelines[lnum] # lnum has already incremented

2610

except:

2611

next = None

2612

while next and indent_re.match(next):

2613

block += next

2614

lnum += 1

2615

try:

2616

next = filelines[lnum]

2617

except:

2618

next = None

2619

# now execute the block of one or more lines

2620

try:

2621

exec block in globs,locs

2622

except SystemExit:

2623

pass

2624

except:

2625

badblocks.append(block.rstrip())

2626

if kw['quiet']: # restore stdout

2627

sys.stdout.close()

2628

sys.stdout = stdout_save

2629

print 'Finished replaying log file <%s>' % fname

2630

if badblocks:

2631

print >> sys.stderr, ('\nThe following lines/blocks in file '

2632

'<%s> reported errors:' % fname)

2633

2634

for badline in badblocks:

2635

print >> sys.stderr, badline

2636

else: # regular file execution

2637

try:

2638

if sys.platform == 'win32' and sys.version_info < (2,5,1):

2639

# Work around a bug in Python for Windows. The bug was

2640

# fixed in in Python 2.5 r54159 and 54158, but that's still

2641

# SVN Python as of March/07. For details, see:

2642

# http://projects.scipy.org/ipython/ipython/ticket/123

2643

try:

2644

globs,locs = where[0:2]

2645

except:

2646

try:

2647

globs = locs = where[0]

2648

except:

2649

globs = locs = globals()

2650

exec file(fname) in globs,locs

2651

else:

2652

execfile(fname,*where)

2653

except SyntaxError:

2654

self.showsyntaxerror()

2655

warn('Failure executing file: <%s>' % fname)

2656

except SystemExit,status:

2657

# Code that correctly sets the exit status flag to success (0)

2658

# shouldn't be bothered with a traceback. Note that a plain

2659

# sys.exit() does NOT set the message to 0 (it's empty) so that

2660

# will still get a traceback. Note that the structure of the

2661

# SystemExit exception changed between Python 2.4 and 2.5, so

2662

# the checks must be done in a version-dependent way.

2663

show = False

2664

2665

if sys.version_info[:2] > (2,5):

2666

if status.message!=0 and not kw['exit_ignore']:

2667

show = True

2668

else:

2669

if status.code and not kw['exit_ignore']:

2670

show = True

2671

if show:

2672

self.showtraceback()

2673

warn('Failure executing file: <%s>' % fname)

2674

except:

2675

self.showtraceback()

2676

warn('Failure executing file: <%s>' % fname)

2677

2678

syspath_cleanup()

2679

2680

#************************* end of file <iplib.py> *****************************

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages