cpython/Lib/idlelib/pyshell.py at 24f0aad7a89b28113bec9cb2ff61a6a450fc9335 · roseman/cpython

Repository navigation

History

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

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

#! /usr/bin/env python3

import sys

try:

from tkinter import *

except ImportError:

print("** IDLE can't import Tkinter.\n"

"Your Python may not be configured for Tk. **", file=sys.__stderr__)

raise SystemExit(1)

import tkinter.messagebox as tkMessageBox

if TkVersion < 8.5:

root = Tk() # otherwise create root in main

root.withdraw()

tkMessageBox.showerror("Idle Cannot Start",

"Idle requires tcl/tk 8.5+, not %s." % TkVersion,

parent=root)

raise SystemExit(1)

from code import InteractiveInterpreter

import linecache

import os

import os.path

from platform import python_version

import re

import socket

import subprocess

import threading

import time

import tokenize

import warnings

from idlelib.colorizer import ColorDelegator

from idlelib.config import idleConf

from idlelib import debugger

from idlelib import debugger_r

from idlelib.editor import EditorWindow, fixwordbreaks

from idlelib.filelist import FileList

from idlelib.outwin import OutputWindow

from idlelib import rpc

from idlelib.run import idle_formatwarning, PseudoInputFile, PseudoOutputFile

from idlelib.undo import UndoDelegator

HOST = '127.0.0.1' # python execution server on localhost loopback

PORT = 0 # someday pass in host, port for remote debug capability

# Override warnings module to write to warning_stream. Initialize to send IDLE

# internal warnings to the console. ScriptBinding.check_syntax() will

# temporarily redirect the stream to the shell window to display warnings when

# checking user's code.

warning_stream = sys.__stderr__ # None, at least on Windows, if no console.

def idle_showwarning(

message, category, filename, lineno, file=None, line=None):

"""Show Idle-format warning (after replacing warnings.showwarning).

The differences are the formatter called, the file=None replacement,

which can be None, the capture of the consequence AttributeError,

and the output of a hard-coded prompt.

"""

if file is None:

file = warning_stream

try:

file.write(idle_formatwarning(

message, category, filename, lineno, line=line))

file.write(">>> ")

except (AttributeError, OSError):

pass # if file (probably __stderr__) is invalid, skip warning.

_warnings_showwarning = None

def capture_warnings(capture):

"Replace warning.showwarning with idle_showwarning, or reverse."

global _warnings_showwarning

if capture:

if _warnings_showwarning is None:

_warnings_showwarning = warnings.showwarning

warnings.showwarning = idle_showwarning

else:

if _warnings_showwarning is not None:

warnings.showwarning = _warnings_showwarning

_warnings_showwarning = None

capture_warnings(True)

def extended_linecache_checkcache(filename=None,

orig_checkcache=linecache.checkcache):

"""Extend linecache.checkcache to preserve the <pyshell#...> entries

Rather than repeating the linecache code, patch it to save the

<pyshell#...> entries, call the original linecache.checkcache()

(skipping them), and then restore the saved entries.

orig_checkcache is bound at definition time to the original

method, allowing it to be patched.

"""

cache = linecache.cache

save = {}

for key in list(cache):

if key[:1] + key[-1:] == '<>':

save[key] = cache.pop(key)

orig_checkcache(filename)

cache.update(save)

# Patch linecache.checkcache():

linecache.checkcache = extended_linecache_checkcache

class PyShellEditorWindow(EditorWindow):

"Regular text edit window in IDLE, supports breakpoints"

def __init__(self, *args):

self.breakpoints = []

EditorWindow.__init__(self, *args)

self.text.bind("<<set-breakpoint-here>>", self.set_breakpoint_here)

self.text.bind("<<clear-breakpoint-here>>", self.clear_breakpoint_here)

self.text.bind("<<open-python-shell>>", self.flist.open_shell)

self.breakpointPath = os.path.join(idleConf.GetUserCfgDir(),

'breakpoints.lst')

# whenever a file is changed, restore breakpoints

def filename_changed_hook(old_hook=self.io.filename_change_hook,

self=self):

self.restore_file_breaks()

old_hook()

self.io.set_filename_change_hook(filename_changed_hook)

if self.io.filename:

self.restore_file_breaks()

self.color_breakpoint_text()

rmenu_specs = [

("Cut", "<<cut>>", "rmenu_check_cut"),

("Copy", "<<copy>>", "rmenu_check_copy"),

("Paste", "<<paste>>", "rmenu_check_paste"),

(None, None, None),

("Set Breakpoint", "<<set-breakpoint-here>>", None),

("Clear Breakpoint", "<<clear-breakpoint-here>>", None)

]

def color_breakpoint_text(self, color=True):

"Turn colorizing of breakpoint text on or off"

if self.io is None:

# possible due to update in restore_file_breaks

return

if color:

theme = idleConf.CurrentTheme()

cfg = idleConf.GetHighlight(theme, "break")

else:

cfg = {'foreground': '', 'background': ''}

self.text.tag_config('BREAK', cfg)

def set_breakpoint(self, lineno):

text = self.text

filename = self.io.filename

text.tag_add("BREAK", "%d.0" % lineno, "%d.0" % (lineno+1))

try:

self.breakpoints.index(lineno)

except ValueError: # only add if missing, i.e. do once

self.breakpoints.append(lineno)

try: # update the subprocess debugger

debug = self.flist.pyshell.interp.debugger

debug.set_breakpoint_here(filename, lineno)

except: # but debugger may not be active right now....

pass

def set_breakpoint_here(self, event=None):

text = self.text

filename = self.io.filename

if not filename:

text.bell()

return

lineno = int(float(text.index("insert")))

self.set_breakpoint(lineno)

def clear_breakpoint_here(self, event=None):

text = self.text

filename = self.io.filename

if not filename:

text.bell()

return

lineno = int(float(text.index("insert")))

try:

self.breakpoints.remove(lineno)

except:

pass

text.tag_remove("BREAK", "insert linestart",\

"insert lineend +1char")

try:

debug = self.flist.pyshell.interp.debugger

debug.clear_breakpoint_here(filename, lineno)

except:

pass

def clear_file_breaks(self):

if self.breakpoints:

text = self.text

filename = self.io.filename

if not filename:

text.bell()

return

self.breakpoints = []

text.tag_remove("BREAK", "1.0", END)

try:

debug = self.flist.pyshell.interp.debugger

debug.clear_file_breaks(filename)

except:

pass

def store_file_breaks(self):

"Save breakpoints when file is saved"

# XXX 13 Dec 2002 KBK Currently the file must be saved before it can

# be run. The breaks are saved at that time. If we introduce

# a temporary file save feature the save breaks functionality

# needs to be re-verified, since the breaks at the time the

# temp file is created may differ from the breaks at the last

# permanent save of the file. Currently, a break introduced

# after a save will be effective, but not persistent.

# This is necessary to keep the saved breaks synched with the

# saved file.

# Breakpoints are set as tagged ranges in the text.

# Since a modified file has to be saved before it is

# run, and since self.breakpoints (from which the subprocess

# debugger is loaded) is updated during the save, the visible

# breaks stay synched with the subprocess even if one of these

# unexpected breakpoint deletions occurs.

breaks = self.breakpoints

filename = self.io.filename

try:

with open(self.breakpointPath, "r") as fp:

lines = fp.readlines()

except OSError:

lines = []

try:

with open(self.breakpointPath, "w") as new_file:

for line in lines:

if not line.startswith(filename + '='):

new_file.write(line)

self.update_breakpoints()

breaks = self.breakpoints

if breaks:

new_file.write(filename + '=' + str(breaks) + '\n')

except OSError as err:

if not getattr(self.root, "breakpoint_error_displayed", False):

self.root.breakpoint_error_displayed = True

tkMessageBox.showerror(title='IDLE Error',

message='Unable to update breakpoint list:\n%s'

% str(err),

parent=self.text)

def restore_file_breaks(self):

self.text.update() # this enables setting "BREAK" tags to be visible

if self.io is None:

# can happen if IDLE closes due to the .update() call

return

filename = self.io.filename

if filename is None:

return

if os.path.isfile(self.breakpointPath):

with open(self.breakpointPath, "r") as fp:

lines = fp.readlines()

for line in lines:

if line.startswith(filename + '='):

breakpoint_linenumbers = eval(line[len(filename)+1:])

for breakpoint_linenumber in breakpoint_linenumbers:

self.set_breakpoint(breakpoint_linenumber)

def update_breakpoints(self):

"Retrieves all the breakpoints in the current window"

text = self.text

ranges = text.tag_ranges("BREAK")

linenumber_list = self.ranges_to_linenumbers(ranges)

self.breakpoints = linenumber_list

def ranges_to_linenumbers(self, ranges):

lines = []

for index in range(0, len(ranges), 2):

lineno = int(float(ranges[index].string))

end = int(float(ranges[index+1].string))

while lineno < end:

lines.append(lineno)

lineno += 1

return lines

# XXX 13 Dec 2002 KBK Not used currently

# def saved_change_hook(self):

# "Extend base method - clear breaks if module is modified"

# if not self.get_saved():

# self.clear_file_breaks()

# EditorWindow.saved_change_hook(self)

def _close(self):

"Extend base method - clear breaks when module is closed"

self.clear_file_breaks()

EditorWindow._close(self)

class PyShellFileList(FileList):

"Extend base class: IDLE supports a shell and breakpoints"

# override FileList's class variable, instances return PyShellEditorWindow

# instead of EditorWindow when new edit windows are created.

EditorWindow = PyShellEditorWindow

pyshell = None

def open_shell(self, event=None):

if self.pyshell:

self.pyshell.top.wakeup()

else:

self.pyshell = PyShell(self)

if self.pyshell:

if not self.pyshell.begin():

return None

return self.pyshell

class ModifiedColorDelegator(ColorDelegator):

"Extend base class: colorizer for the shell window itself"

def __init__(self):

ColorDelegator.__init__(self)

self.LoadTagDefs()

def recolorize_main(self):

self.tag_remove("TODO", "1.0", "iomark")

self.tag_add("SYNC", "1.0", "iomark")

ColorDelegator.recolorize_main(self)

def LoadTagDefs(self):

ColorDelegator.LoadTagDefs(self)

theme = idleConf.CurrentTheme()

self.tagdefs.update({

"stdin": {'background':None,'foreground':None},

"stdout": idleConf.GetHighlight(theme, "stdout"),

"stderr": idleConf.GetHighlight(theme, "stderr"),

"console": idleConf.GetHighlight(theme, "console"),

})

def removecolors(self):

# Don't remove shell color tags before "iomark"

for tag in self.tagdefs:

self.tag_remove(tag, "iomark", "end")

class ModifiedUndoDelegator(UndoDelegator):

"Extend base class: forbid insert/delete before the I/O mark"

def insert(self, index, chars, tags=None):

try:

if self.delegate.compare(index, "<", "iomark"):

self.delegate.bell()

return

except TclError:

pass

UndoDelegator.insert(self, index, chars, tags)

def delete(self, index1, index2=None):

try:

if self.delegate.compare(index1, "<", "iomark"):

self.delegate.bell()

return

except TclError:

pass

UndoDelegator.delete(self, index1, index2)

class MyRPCClient(rpc.RPCClient):

def handle_EOF(self):

"Override the base class - just re-raise EOFError"

raise EOFError

class ModifiedInterpreter(InteractiveInterpreter):

def __init__(self, tkconsole):

self.tkconsole = tkconsole

locals = sys.modules['__main__'].__dict__

InteractiveInterpreter.__init__(self, locals=locals)

self.save_warnings_filters = None

self.restarting = False

self.subprocess_arglist = None

self.port = PORT

self.original_compiler_flags = self.compile.compiler.flags

_afterid = None

rpcclt = None

rpcsubproc = None

def spawn_subprocess(self):

if self.subprocess_arglist is None:

self.subprocess_arglist = self.build_subprocess_arglist()

self.rpcsubproc = subprocess.Popen(self.subprocess_arglist)

def build_subprocess_arglist(self):

assert (self.port!=0), (

"Socket should have been assigned a port number.")

w = ['-W' + s for s in sys.warnoptions]

# Maybe IDLE is installed and is being accessed via sys.path,

# or maybe it's not installed and the idle.py script is being

# run from the IDLE source directory.

del_exitf = idleConf.GetOption('main', 'General', 'delete-exitfunc',

default=False, type='bool')

if __name__ == 'idlelib.pyshell':

command = "__import__('idlelib.run').run.main(%r)" % (del_exitf,)

else:

command = "__import__('run').main(%r)" % (del_exitf,)

return [sys.executable] + w + ["-c", command, str(self.port)]

def start_subprocess(self):

addr = (HOST, self.port)

# GUI makes several attempts to acquire socket, listens for connection

for i in range(3):

time.sleep(i)

try:

self.rpcclt = MyRPCClient(addr)

break

except OSError:

pass

else:

self.display_port_binding_error()

return None

# if PORT was 0, system will assign an 'ephemeral' port. Find it out:

self.port = self.rpcclt.listening_sock.getsockname()[1]

# if PORT was not 0, probably working with a remote execution server

if PORT != 0:

# To allow reconnection within the 2MSL wait (cf. Stevens TCP

# V1, 18.6), set SO_REUSEADDR. Note that this can be problematic

# on Windows since the implementation allows two active sockets on

# the same address!

self.rpcclt.listening_sock.setsockopt(socket.SOL_SOCKET,

socket.SO_REUSEADDR, 1)

self.spawn_subprocess()

#time.sleep(20) # test to simulate GUI not accepting connection

# Accept the connection from the Python execution server

self.rpcclt.listening_sock.settimeout(10)

try:

self.rpcclt.accept()

except socket.timeout:

self.display_no_subprocess_error()

return None

self.rpcclt.register("console", self.tkconsole)

self.rpcclt.register("stdin", self.tkconsole.stdin)

self.rpcclt.register("stdout", self.tkconsole.stdout)

self.rpcclt.register("stderr", self.tkconsole.stderr)

self.rpcclt.register("flist", self.tkconsole.flist)

self.rpcclt.register("linecache", linecache)

self.rpcclt.register("interp", self)

self.transfer_path(with_cwd=True)

self.poll_subprocess()

return self.rpcclt

def restart_subprocess(self, with_cwd=False, filename=''):

if self.restarting:

return self.rpcclt

self.restarting = True

# close only the subprocess debugger

debug = self.getdebugger()

if debug:

try:

# Only close subprocess debugger, don't unregister gui_adap!

debugger_r.close_subprocess_debugger(self.rpcclt)

except:

pass

debug.endexecuting()

# Kill subprocess, spawn a new one, accept connection.

self.rpcclt.close()

self.terminate_subprocess()

console = self.tkconsole

was_executing = console.executing

console.executing = False

self.spawn_subprocess()

try:

self.rpcclt.accept()

except socket.timeout:

self.display_no_subprocess_error()

return None

self.transfer_path(with_cwd=with_cwd)

console.stop_readline()

# annotate restart in shell window and mark it

console.text.delete("iomark", "end-1c")

tag = 'RESTART: ' + (filename if filename else 'Shell')

halfbar = ((int(console.width) -len(tag) - 4) // 2) * '='

console.write("\n{0} {1} {0}".format(halfbar, tag))

console.text.mark_set("restart", "end-1c")

console.text.mark_gravity("restart", "left")

if not filename:

console.showprompt()

# restart subprocess debugger

if debug:

# Restarted debugger connects to current instance of debug GUI

debugger_r.restart_subprocess_debugger(self.rpcclt)

# reload remote debugger breakpoints for all PyShellEditWindows

debug.load_breakpoints()

self.compile.compiler.flags = self.original_compiler_flags

self.restarting = False

return self.rpcclt

def __request_interrupt(self):

self.rpcclt.remotecall("exec", "interrupt_the_server", (), {})

def interrupt_subprocess(self):

threading.Thread(target=self.__request_interrupt).start()

def kill_subprocess(self):

if self._afterid is not None:

self.tkconsole.text.after_cancel(self._afterid)

try:

self.rpcclt.listening_sock.close()

except AttributeError: # no socket

pass

try:

self.rpcclt.close()

except AttributeError: # no socket

pass

self.terminate_subprocess()

self.tkconsole.executing = False

self.rpcclt = None

def terminate_subprocess(self):

"Make sure subprocess is terminated"

try:

self.rpcsubproc.kill()

except OSError:

# process already terminated

return

else:

try:

self.rpcsubproc.wait()

except OSError:

return

def transfer_path(self, with_cwd=False):

if with_cwd: # Issue 13506

path = [''] # include Current Working Directory

path.extend(sys.path)

else:

path = sys.path

self.runcommand("""if 1:

import sys as _sys

_sys.path = %r

del _sys

\n""" % (path,))

active_seq = None

def poll_subprocess(self):

clt = self.rpcclt

if clt is None:

return

try:

response = clt.pollresponse(self.active_seq, wait=0.05)

except (EOFError, OSError, KeyboardInterrupt):

# lost connection or subprocess terminated itself, restart

# [the KBI is from rpc.SocketIO.handle_EOF()]

if self.tkconsole.closing:

return

response = None

self.restart_subprocess()

if response:

self.tkconsole.resetoutput()

self.active_seq = None

how, what = response

console = self.tkconsole.console

if how == "OK":

if what is not None:

print(repr(what), file=console)

elif how == "EXCEPTION":

if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):

self.remote_stack_viewer()

elif how == "ERROR":

errmsg = "pyshell.ModifiedInterpreter: Subprocess ERROR:\n"

print(errmsg, what, file=sys.__stderr__)

print(errmsg, what, file=console)

# we received a response to the currently active seq number:

try:

self.tkconsole.endexecuting()

except AttributeError: # shell may have closed

pass

# Reschedule myself

if not self.tkconsole.closing:

self._afterid = self.tkconsole.text.after(

self.tkconsole.pollinterval, self.poll_subprocess)

debugger = None

def setdebugger(self, debugger):

self.debugger = debugger

def getdebugger(self):

return self.debugger

def open_remote_stack_viewer(self):

"""Initiate the remote stack viewer from a separate thread.

This method is called from the subprocess, and by returning from this

method we allow the subprocess to unblock. After a bit the shell

requests the subprocess to open the remote stack viewer which returns a

static object looking at the last exception. It is queried through

the RPC mechanism.

"""

self.tkconsole.text.after(300, self.remote_stack_viewer)

return

def remote_stack_viewer(self):

from idlelib import debugobj_r

oid = self.rpcclt.remotequeue("exec", "stackviewer", ("flist",), {})

if oid is None:

self.tkconsole.root.bell()

return

item = debugobj_r.StubObjectTreeItem(self.rpcclt, oid)

from idlelib.tree import ScrolledCanvas, TreeNode

top = Toplevel(self.tkconsole.root)

theme = idleConf.CurrentTheme()

background = idleConf.GetHighlight(theme, 'normal')['background']

sc = ScrolledCanvas(top, bg=background, highlightthickness=0)

sc.frame.pack(expand=1, fill="both")

node = TreeNode(sc.canvas, None, item)

node.expand()

# XXX Should GC the remote tree when closing the window

gid = 0

def execsource(self, source):

"Like runsource() but assumes complete exec source"

filename = self.stuffsource(source)

self.execfile(filename, source)

def execfile(self, filename, source=None):

"Execute an existing file"

if source is None:

with tokenize.open(filename) as fp:

source = fp.read()

try:

code = compile(source, filename, "exec")

except (OverflowError, SyntaxError):

self.tkconsole.resetoutput()

print('*** Error in script or command!\n'

'Traceback (most recent call last):',

file=self.tkconsole.stderr)

InteractiveInterpreter.showsyntaxerror(self, filename)

self.tkconsole.showprompt()

else:

self.runcode(code)

def runsource(self, source):

"Extend base class method: Stuff the source in the line cache first"

filename = self.stuffsource(source)

self.more = 0

self.save_warnings_filters = warnings.filters[:]

warnings.filterwarnings(action="error", category=SyntaxWarning)

# at the moment, InteractiveInterpreter expects str

assert isinstance(source, str)

#if isinstance(source, str):

# from idlelib import iomenu

# try:

# source = source.encode(iomenu.encoding)

# except UnicodeError:

# self.tkconsole.resetoutput()

# self.write("Unsupported characters in input\n")

# return

try:

# InteractiveInterpreter.runsource() calls its runcode() method,

# which is overridden (see below)

return InteractiveInterpreter.runsource(self, source, filename)

finally:

if self.save_warnings_filters is not None:

warnings.filters[:] = self.save_warnings_filters

self.save_warnings_filters = None

def stuffsource(self, source):

"Stuff source in the filename cache"

filename = "<pyshell#%d>" % self.gid

self.gid = self.gid + 1

lines = source.split("\n")

linecache.cache[filename] = len(source)+1, 0, lines, filename

return filename

def prepend_syspath(self, filename):

"Prepend sys.path with file's directory if not already included"

self.runcommand("""if 1:

_filename = %r

import sys as _sys

from os.path import dirname as _dirname

_dir = _dirname(_filename)

if not _dir in _sys.path:

_sys.path.insert(0, _dir)

del _filename, _sys, _dirname, _dir

\n""" % (filename,))

def showsyntaxerror(self, filename=None):

"""Override Interactive Interpreter method: Use Colorizing

Color the offending position instead of printing it and pointing at it

with a caret.

"""

tkconsole = self.tkconsole

text = tkconsole.text

text.tag_remove("ERROR", "1.0", "end")

type, value, tb = sys.exc_info()

msg = getattr(value, 'msg', '') or value or "<no detail available>"

lineno = getattr(value, 'lineno', '') or 1

offset = getattr(value, 'offset', '') or 0

if offset == 0:

lineno += 1 #mark end of offending line

if lineno == 1:

pos = "iomark + %d chars" % (offset-1)

else:

pos = "iomark linestart + %d lines + %d chars" % \

(lineno-1, offset-1)

tkconsole.colorize_syntax_error(text, pos)

tkconsole.resetoutput()

self.write("SyntaxError: %s\n" % msg)

tkconsole.showprompt()

def showtraceback(self):

"Extend base class method to reset output properly"

self.tkconsole.resetoutput()

self.checklinecache()

InteractiveInterpreter.showtraceback(self)

if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):

self.tkconsole.open_stack_viewer()

def checklinecache(self):

c = linecache.cache

for key in list(c.keys()):

if key[:1] + key[-1:] != "<>":

del c[key]

def runcommand(self, code):

"Run the code without invoking the debugger"

# The code better not raise an exception!

if self.tkconsole.executing:

self.display_executing_dialog()

return 0

if self.rpcclt:

self.rpcclt.remotequeue("exec", "runcode", (code,), {})

else:

exec(code, self.locals)

return 1

def runcode(self, code):

"Override base class method"

if self.tkconsole.executing:

self.interp.restart_subprocess()

self.checklinecache()

if self.save_warnings_filters is not None:

warnings.filters[:] = self.save_warnings_filters

self.save_warnings_filters = None

debugger = self.debugger

try:

self.tkconsole.beginexecuting()

if not debugger and self.rpcclt is not None:

self.active_seq = self.rpcclt.asyncqueue("exec", "runcode",

(code,), {})

elif debugger:

debugger.run(code, self.locals)

else:

exec(code, self.locals)

except SystemExit:

if not self.tkconsole.closing:

if tkMessageBox.askyesno(

"Exit?",

"Do you want to exit altogether?",

default="yes",

parent=self.tkconsole.text):

raise

else:

self.showtraceback()

else:

raise

except:

if use_subprocess:

print("IDLE internal error in runcode()",

file=self.tkconsole.stderr)

self.showtraceback()

self.tkconsole.endexecuting()

else:

if self.tkconsole.canceled:

self.tkconsole.canceled = False

print("KeyboardInterrupt", file=self.tkconsole.stderr)

if self.interp.debugger:

self.interp.debugger.endexecuting()

else:

self.showtraceback()

finally:

if not use_subprocess:

try:

self.tkconsole.endexecuting()

except AttributeError: # shell may have closed

pass

def write(self, s):

"Override base class method"

return self.tkconsole.stderr.write(s)

def display_port_binding_error(self):

tkMessageBox.showerror(

"Port Binding Error",

"IDLE can't bind to a TCP/IP port, which is necessary to "

"communicate with its Python execution server. This might be "

"because no networking is installed on this computer. "

"Run IDLE with the -n command line switch to start without a "

"subprocess and refer to Help/IDLE Help 'Running without a "

"subprocess' for further details.",

parent=self.tkconsole.text)

def display_no_subprocess_error(self):

tkMessageBox.showerror(

"Subprocess Startup Error",

"IDLE's subprocess didn't make connection. Either IDLE can't "

"start a subprocess or personal firewall software is blocking "

"the connection.",

parent=self.tkconsole.text)

def display_executing_dialog(self):

tkMessageBox.showerror(

"Already executing",

"The Python Shell window is already executing a command; "

"please wait until it is finished.",

parent=self.tkconsole.text)

class PyShell(OutputWindow):

shell_title = "Python " + python_version() + " Shell"

# Override classes

ColorDelegator = ModifiedColorDelegator

UndoDelegator = ModifiedUndoDelegator

# Override menus

menu_specs = [

("file", "_File"),

("edit", "_Edit"),

("debug", "_Debug"),

("options", "_Options"),

("windows", "_Window"),

("help", "_Help"),

]

# New classes

from idlelib.history import History

def __init__(self, flist=None):

if use_subprocess:

ms = self.menu_specs

if ms[2][0] != "shell":

ms.insert(2, ("shell", "She_ll"))

self.interp = ModifiedInterpreter(self)

if flist is None:

root = Tk()

fixwordbreaks(root)

root.withdraw()

flist = PyShellFileList(root)

OutputWindow.__init__(self, flist, None, None)

## self.config(usetabs=1, indentwidth=8, context_use_ps1=1)

self.usetabs = True

# indentwidth must be 8 when using tabs. See note in EditorWindow:

self.indentwidth = 8

self.context_use_ps1 = True

text = self.text

text.configure(wrap="char")

text.bind("<<newline-and-indent>>", self.enter_callback)

text.bind("<<plain-newline-and-indent>>", self.linefeed_callback)

text.bind("<<interrupt-execution>>", self.cancel_callback)

text.bind("<<end-of-file>>", self.eof_callback)

text.bind("<<open-stack-viewer>>", self.open_stack_viewer)

text.bind("<<toggle-debugger>>", self.toggle_debugger)

text.bind("<<toggle-jit-stack-viewer>>", self.toggle_jit_stack_viewer)

if use_subprocess:

text.bind("<<view-restart>>", self.view_restart_mark)

text.bind("<<restart-shell>>", self.restart_shell)

self.save_stdout = sys.stdout

self.save_stderr = sys.stderr

self.save_stdin = sys.stdin

from idlelib import iomenu

self.stdin = PseudoInputFile(self, "stdin", iomenu.encoding)

self.stdout = PseudoOutputFile(self, "stdout", iomenu.encoding)

self.stderr = PseudoOutputFile(self, "stderr", iomenu.encoding)

self.console = PseudoOutputFile(self, "console", iomenu.encoding)

if not use_subprocess:

sys.stdout = self.stdout

sys.stderr = self.stderr

sys.stdin = self.stdin

try:

# page help() text to shell.

import pydoc # import must be done here to capture i/o rebinding.

# XXX KBK 27Dec07 use TextViewer someday, but must work w/o subproc

pydoc.pager = pydoc.plainpager

except:

sys.stderr = sys.__stderr__

raise

self.history = self.History(self.text)

self.pollinterval = 50 # millisec

def get_standard_extension_names(self):

return idleConf.GetExtensions(shell_only=True)

reading = False

executing = False

canceled = False

endoffile = False

closing = False

_stop_readline_flag = False

def set_warning_stream(self, stream):

global warning_stream

warning_stream = stream

def get_warning_stream(self):

return warning_stream

def toggle_debugger(self, event=None):

if self.executing:

tkMessageBox.showerror("Don't debug now",

"You can only toggle the debugger when idle",

parent=self.text)

self.set_debugger_indicator()

return "break"

else:

db = self.interp.getdebugger()

if db:

self.close_debugger()

else:

self.open_debugger()

def set_debugger_indicator(self):

db = self.interp.getdebugger()

self.setvar("<<toggle-debugger>>", not not db)

def toggle_jit_stack_viewer(self, event=None):

pass # All we need is the variable

def close_debugger(self):

db = self.interp.getdebugger()

if db:

self.interp.setdebugger(None)

db.close()

if self.interp.rpcclt:

debugger_r.close_remote_debugger(self.interp.rpcclt)

self.resetoutput()

self.console.write("[DEBUG OFF]\n")

sys.ps1 = ">>> "

self.showprompt()

self.set_debugger_indicator()

def open_debugger(self):

if self.interp.rpcclt:

dbg_gui = debugger_r.start_remote_debugger(self.interp.rpcclt,

self)

else:

dbg_gui = debugger.Debugger(self)

self.interp.setdebugger(dbg_gui)

dbg_gui.load_breakpoints()

sys.ps1 = "[DEBUG ON]\n>>> "

self.showprompt()

self.set_debugger_indicator()

def beginexecuting(self):

"Helper for ModifiedInterpreter"

if self.interp.debugger:

self.interp.debugger.beginexecuting()

self.resetoutput()

self.executing = 1

def endexecuting(self):

"Helper for ModifiedInterpreter"

if self.interp.debugger:

self.interp.debugger.endexecuting()

self.executing = 0

self.canceled = 0

self.showprompt()

def close(self):

"Extend EditorWindow.close()"

if self.executing:

response = tkMessageBox.askokcancel(

"Kill?",

"Your program is still running!\n Do you want to kill it?",

default="ok",

parent=self.text)

if response is False:

return "cancel"

self.stop_readline()

self.canceled = True

self.closing = True

return EditorWindow.close(self)

View remainder of file in raw view

FilesExpand file tree

pyshell.py

Latest commit

History

pyshell.py

File metadata and controls