ipython/IPython/core/debugger.py at master · rcgray/ipython · GitHub

History

591 lines (476 loc) · 20.8 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

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

"""

Pdb debugger class.

Modified from the standard pdb.Pdb class to avoid including readline, so that

the command line completion of other programs which include this isn't

damaged.

In the future, this class will be expanded with improvements over the standard

pdb.

The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor

changes. Licensing should therefore be under the standard Python terms. For

details on the PSF (Python Software Foundation) standard license, see:

http://www.python.org/2.2.3/license.html"""

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

# This file is licensed under the PSF license.

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

from __future__ import print_function

import bdb

import functools

import linecache

import sys

from IPython import get_ipython

from IPython.utils import PyColorize, ulinecache

from IPython.utils import coloransi, io, py3compat

from IPython.core.excolors import exception_colors

from IPython.testing.skipdoctest import skip_doctest

# See if we can use pydb.

has_pydb = False

prompt = 'ipdb> '

#We have to check this directly from sys.argv, config struct not yet available

if '--pydb' in sys.argv:

try:

import pydb

if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':

# Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we

# better protect against it.

has_pydb = True

except ImportError:

print("Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available")

if has_pydb:

from pydb import Pdb as OldPdb

#print "Using pydb for %run -d and post-mortem" #dbg

prompt = 'ipydb> '

else:

from pdb import Pdb as OldPdb

# Allow the set_trace code to operate outside of an ipython instance, even if

# it does so with some limitations. The rest of this support is implemented in

# the Tracer constructor.

def BdbQuit_excepthook(et, ev, tb, excepthook=None):

"""Exception hook which handles `BdbQuit` exceptions.

All other exceptions are processed using the `excepthook`

parameter.

"""

if et==bdb.BdbQuit:

print('Exiting Debugger.')

elif excepthook is not None:

excepthook(et, ev, tb)

else:

# Backwards compatibility. Raise deprecation warning?

BdbQuit_excepthook.excepthook_ori(et,ev,tb)

def BdbQuit_IPython_excepthook(self,et,ev,tb,tb_offset=None):

print('Exiting Debugger.')

class Tracer(object):

"""Class for local debugging, similar to pdb.set_trace.

Instances of this class, when called, behave like pdb.set_trace, but

providing IPython's enhanced capabilities.

This is implemented as a class which must be initialized in your own code

and not as a standalone function because we need to detect at runtime

whether IPython is already active or not. That detection is done in the

constructor, ensuring that this code plays nicely with a running IPython,

while functioning acceptably (though with limitations) if outside of it.

"""

@skip_doctest

def __init__(self,colors=None):

"""Create a local debugger instance.

Parameters

----------

colors : str, optional

The name of the color scheme to use, it must be one of IPython's

valid color schemes. If not given, the function will default to

the current IPython scheme when running inside IPython, and to

'NoColor' otherwise.

Examples

--------

from IPython.core.debugger import Tracer; debug_here = Tracer()

Later in your code::

debug_here() # -> will open up the debugger at that point.

Once the debugger activates, you can use all of its regular commands to

step through code, set breakpoints, etc. See the pdb documentation

from the Python standard library for usage details.

"""

ip = get_ipython()

if ip is None:

# Outside of ipython, we set our own exception hook manually

sys.excepthook = functools.partial(BdbQuit_excepthook,

excepthook=sys.excepthook)

def_colors = 'NoColor'

try:

# Limited tab completion support

import readline

readline.parse_and_bind('tab: complete')

except ImportError:

pass

else:

# In ipython, we use its custom exception handler mechanism

def_colors = ip.colors

ip.set_custom_exc((bdb.BdbQuit,), BdbQuit_IPython_excepthook)

if colors is None:

colors = def_colors

# The stdlib debugger internally uses a modified repr from the `repr`

# module, that limits the length of printed strings to a hardcoded

# limit of 30 characters. That much trimming is too aggressive, let's

# at least raise that limit to 80 chars, which should be enough for

# most interactive uses.

try:

from reprlib import aRepr # Py 3

except ImportError:

from repr import aRepr # Py 2

aRepr.maxstring = 80

except:

# This is only a user-facing convenience, so any error we encounter

# here can be warned about but can be otherwise ignored. These

# printouts will tell us about problems if this API changes

import traceback

traceback.print_exc()

self.debugger = Pdb(colors)

def __call__(self):

"""Starts an interactive debugger at the point where called.

This is similar to the pdb.set_trace() function from the std lib, but

using IPython's enhanced debugger."""

self.debugger.set_trace(sys._getframe().f_back)

def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):

"""Make new_fn have old_fn's doc string. This is particularly useful

for the ``do_...`` commands that hook into the help system.

Adapted from from a comp.lang.python posting

by Duncan Booth."""

def wrapper(*args, **kw):

return new_fn(*args, **kw)

if old_fn.__doc__:

wrapper.__doc__ = old_fn.__doc__ + additional_text

return wrapper

def _file_lines(fname):

"""Return the contents of a named file as a list of lines.

This function never raises an IOError exception: if the file can't be

read, it simply returns an empty list."""

try:

outfile = open(fname)

except IOError:

return []

else:

out = outfile.readlines()

outfile.close()

return out

class Pdb(OldPdb):

"""Modified Pdb class, does not load readline."""

def __init__(self,color_scheme='NoColor',completekey=None,

stdin=None, stdout=None):

# Parent constructor:

if has_pydb and completekey is None:

OldPdb.__init__(self,stdin=stdin,stdout=io.stdout)

else:

OldPdb.__init__(self,completekey,stdin,stdout)

self.prompt = prompt # The default prompt is '(Pdb)'

# IPython changes...

self.is_pydb = has_pydb

self.shell = get_ipython()

if self.shell is None:

# No IPython instance running, we must create one

from IPython.terminal.interactiveshell import \

TerminalInteractiveShell

self.shell = TerminalInteractiveShell.instance()

if self.is_pydb:

# interactiveshell.py's ipalias seems to want pdb's checkline

# which located in pydb.fn

import pydb.fns

self.checkline = lambda filename, lineno: \

pydb.fns.checkline(self, filename, lineno)

self.curframe = None

self.do_restart = self.new_do_restart

self.old_all_completions = self.shell.Completer.all_completions

self.shell.Completer.all_completions=self.all_completions

self.do_list = decorate_fn_with_doc(self.list_command_pydb,

OldPdb.do_list)

self.do_l = self.do_list

self.do_frame = decorate_fn_with_doc(self.new_do_frame,

OldPdb.do_frame)

self.aliases = {}

# Create color table: we copy the default one from the traceback

# module and add a few attributes needed for debugging

self.color_scheme_table = exception_colors()

# shorthands

C = coloransi.TermColors

cst = self.color_scheme_table

cst['NoColor'].colors.breakpoint_enabled = C.NoColor

cst['NoColor'].colors.breakpoint_disabled = C.NoColor

cst['Linux'].colors.breakpoint_enabled = C.LightRed

cst['Linux'].colors.breakpoint_disabled = C.Red

cst['LightBG'].colors.breakpoint_enabled = C.LightRed

cst['LightBG'].colors.breakpoint_disabled = C.Red

self.set_colors(color_scheme)

# Add a python parser so we can syntax highlight source while

# debugging.

self.parser = PyColorize.Parser()

def set_colors(self, scheme):

"""Shorthand access to the color table scheme selector method."""

self.color_scheme_table.set_active_scheme(scheme)

def interaction(self, frame, traceback):

self.shell.set_completer_frame(frame)

while True:

try:

OldPdb.interaction(self, frame, traceback)

except KeyboardInterrupt:

self.shell.write("\nKeyboardInterrupt\n")

break

else:

break

def new_do_up(self, arg):

OldPdb.do_up(self, arg)

self.shell.set_completer_frame(self.curframe)

do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)

def new_do_down(self, arg):

OldPdb.do_down(self, arg)

self.shell.set_completer_frame(self.curframe)

do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)

def new_do_frame(self, arg):

OldPdb.do_frame(self, arg)

self.shell.set_completer_frame(self.curframe)

def new_do_quit(self, arg):

if hasattr(self, 'old_all_completions'):

self.shell.Completer.all_completions=self.old_all_completions

return OldPdb.do_quit(self, arg)

do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)

def new_do_restart(self, arg):

"""Restart command. In the context of ipython this is exactly the same

thing as 'quit'."""

self.msg("Restart doesn't make sense here. Using 'quit' instead.")

return self.do_quit(arg)

def postloop(self):

self.shell.set_completer_frame(None)

def print_stack_trace(self):

try:

for frame_lineno in self.stack:

self.print_stack_entry(frame_lineno, context = 5)

except KeyboardInterrupt:

pass

def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',

context = 3):

#frame, lineno = frame_lineno

print(self.format_stack_entry(frame_lineno, '', context), file=io.stdout)

# vds: >>

frame, lineno = frame_lineno

filename = frame.f_code.co_filename

self.shell.hooks.synchronize_with_editor(filename, lineno, 0)

# vds: <<

def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):

try:

import reprlib # Py 3

except ImportError:

import repr as reprlib # Py 2

ret = []

Colors = self.color_scheme_table.active_colors

ColorsNormal = Colors.Normal

tpl_link = u'%s%%s%s' % (Colors.filenameEm, ColorsNormal)

tpl_call = u'%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)

tpl_line = u'%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)

tpl_line_em = u'%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,

ColorsNormal)

frame, lineno = frame_lineno

return_value = ''

if '__return__' in frame.f_locals:

rv = frame.f_locals['__return__']

#return_value += '->'

return_value += reprlib.repr(rv) + '\n'

ret.append(return_value)

#s = filename + '(' + `lineno` + ')'

filename = self.canonic(frame.f_code.co_filename)

link = tpl_link % py3compat.cast_unicode(filename)

if frame.f_code.co_name:

func = frame.f_code.co_name

else:

func = "<lambda>"

call = ''

if func != '?':

if '__args__' in frame.f_locals:

args = reprlib.repr(frame.f_locals['__args__'])

else:

args = '()'

call = tpl_call % (func, args)

# The level info should be generated in the same format pdb uses, to

# avoid breaking the pdbtrack functionality of python-mode in *emacs.

if frame is self.curframe:

ret.append('> ')

else:

ret.append(' ')

ret.append(u'%s(%s)%s\n' % (link,lineno,call))

start = lineno - 1 - context//2

lines = ulinecache.getlines(filename)

start = min(start, len(lines) - context)

start = max(start, 0)

lines = lines[start : start + context]

for i,line in enumerate(lines):

show_arrow = (start + 1 + i == lineno)

linetpl = (frame is self.curframe or show_arrow) \

and tpl_line_em \

or tpl_line

ret.append(self.__format_line(linetpl, filename,

start + 1 + i, line,

arrow = show_arrow) )

return ''.join(ret)

def __format_line(self, tpl_line, filename, lineno, line, arrow = False):

bp_mark = ""

bp_mark_color = ""

scheme = self.color_scheme_table.active_scheme_name

new_line, err = self.parser.format2(line, 'str', scheme)

if not err: line = new_line

bp = None

if lineno in self.get_file_breaks(filename):

bps = self.get_breaks(filename, lineno)

bp = bps[-1]

if bp:

Colors = self.color_scheme_table.active_colors

bp_mark = str(bp.number)

bp_mark_color = Colors.breakpoint_enabled

if not bp.enabled:

bp_mark_color = Colors.breakpoint_disabled

numbers_width = 7

if arrow:

# This is the line with the error

pad = numbers_width - len(str(lineno)) - len(bp_mark)

if pad >= 3:

marker = '-'*(pad-3) + '-> '

elif pad == 2:

marker = '> '

elif pad == 1:

marker = '>'

else:

marker = ''

num = '%s%s' % (marker, str(lineno))

line = tpl_line % (bp_mark_color + bp_mark, num, line)

else:

num = '%*s' % (numbers_width - len(bp_mark), str(lineno))

line = tpl_line % (bp_mark_color + bp_mark, num, line)

return line

def list_command_pydb(self, arg):

"""List command to use if we have a newer pydb installed"""

filename, first, last = OldPdb.parse_list_cmd(self, arg)

if filename is not None:

self.print_list_lines(filename, first, last)

def print_list_lines(self, filename, first, last):

"""The printing (as opposed to the parsing part of a 'list'

command."""

try:

Colors = self.color_scheme_table.active_colors

ColorsNormal = Colors.Normal

tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)

tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)

src = []

if filename == "<string>" and hasattr(self, "_exec_filename"):

filename = self._exec_filename

for lineno in range(first, last+1):

line = ulinecache.getline(filename, lineno)

if not line:

break

if lineno == self.curframe.f_lineno:

line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)

else:

line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)

src.append(line)

self.lineno = lineno

print(''.join(src), file=io.stdout)

except KeyboardInterrupt:

pass

def do_list(self, arg):

self.lastcmd = 'list'

last = None

if arg:

try:

x = eval(arg, {}, {})

if type(x) == type(()):

first, last = x

first = int(first)

last = int(last)

if last < first:

# Assume it's a count

last = first + last

else:

first = max(1, int(x) - 5)

except:

print('*** Error in argument:', repr(arg))

return

elif self.lineno is None:

first = max(1, self.curframe.f_lineno - 5)

else:

first = self.lineno + 1

if last is None:

last = first + 10

self.print_list_lines(self.curframe.f_code.co_filename, first, last)

# vds: >>

lineno = first

filename = self.curframe.f_code.co_filename

self.shell.hooks.synchronize_with_editor(filename, lineno, 0)

# vds: <<

do_l = do_list

def do_pdef(self, arg):

"""Print the call signature for any callable object.

The debugger interface to %pdef"""

namespaces = [('Locals', self.curframe.f_locals),

('Globals', self.curframe.f_globals)]

self.shell.find_line_magic('pdef')(arg, namespaces=namespaces)

def do_pdoc(self, arg):

"""Print the docstring for an object.

The debugger interface to %pdoc."""

namespaces = [('Locals', self.curframe.f_locals),

('Globals', self.curframe.f_globals)]

self.shell.find_line_magic('pdoc')(arg, namespaces=namespaces)

def do_pfile(self, arg):

"""Print (or run through pager) the file where an object is defined.

The debugger interface to %pfile.

"""

namespaces = [('Locals', self.curframe.f_locals),

('Globals', self.curframe.f_globals)]

self.shell.find_line_magic('pfile')(arg, namespaces=namespaces)

def do_pinfo(self, arg):

"""Provide detailed information about an object.

The debugger interface to %pinfo, i.e., obj?."""

namespaces = [('Locals', self.curframe.f_locals),

('Globals', self.curframe.f_globals)]

self.shell.find_line_magic('pinfo')(arg, namespaces=namespaces)

def do_pinfo2(self, arg):

"""Provide extra detailed information about an object.

The debugger interface to %pinfo2, i.e., obj??."""

namespaces = [('Locals', self.curframe.f_locals),

('Globals', self.curframe.f_globals)]

self.shell.find_line_magic('pinfo2')(arg, namespaces=namespaces)

def do_psource(self, arg):

"""Print (or run through pager) the source code for an object."""

namespaces = [('Locals', self.curframe.f_locals),

('Globals', self.curframe.f_globals)]

self.shell.find_line_magic('psource')(arg, namespaces=namespaces)

def checkline(self, filename, lineno):

"""Check whether specified line seems to be executable.

Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank

line or EOF). Warning: testing is not comprehensive.

"""

#######################################################################

# XXX Hack! Use python-2.5 compatible code for this call, because with

# all of our changes, we've drifted from the pdb api in 2.6. For now,

# changing:

#line = linecache.getline(filename, lineno, self.curframe.f_globals)

# to:

line = linecache.getline(filename, lineno)

# does the trick. But in reality, we need to fix this by reconciling

# our updates with the new Pdb APIs in Python 2.6.

# End hack. The rest of this method is copied verbatim from 2.6 pdb.py

#######################################################################

if not line:

print('End of file', file=self.stdout)

return 0

line = line.strip()

# Don't allow setting breakpoint at a blank line

if (not line or (line[0] == '#') or

(line[:3] == '"""') or line[:3] == "'''"):

print('*** Blank or comment', file=self.stdout)

return 0

return lineno

ipython/IPython/core/debugger.py at master · rcgray/ipython · GitHub

Expand file tree

Breadcrumbs

debugger.py

Latest commit

History

Breadcrumbs

debugger.py

File metadata and controls