| 1 |
#! /usr/bin/env python3 |
| 2 |
|
| 3 |
import sys |
| 4 |
if __name__ == "__main__": |
| 5 |
sys.modules['idlelib.pyshell'] = sys.modules['__main__'] |
| 6 |
|
| 7 |
try: |
| 8 |
from tkinter import * |
| 9 |
except ImportError: |
| 10 |
print("** IDLE can't import Tkinter.\n" |
| 11 |
"Your Python may not be configured for Tk. **", file=sys.__stderr__) |
| 12 |
raise SystemExit(1) |
| 13 |
|
| 14 |
if sys.platform == 'win32': |
| 15 |
from idlelib.util import fix_win_hidpi |
| 16 |
fix_win_hidpi() |
| 17 |
|
| 18 |
from tkinter import messagebox |
| 19 |
|
| 20 |
from code import InteractiveInterpreter |
| 21 |
import itertools |
| 22 |
import linecache |
| 23 |
import os |
| 24 |
import os.path |
| 25 |
import re |
| 26 |
import socket |
| 27 |
import subprocess |
| 28 |
from textwrap import TextWrapper |
| 29 |
import threading |
| 30 |
import time |
| 31 |
import tokenize |
| 32 |
import warnings |
| 33 |
|
| 34 |
from idlelib.colorizer import ColorDelegator |
| 35 |
from idlelib.config import idleConf |
| 36 |
from idlelib.delegator import Delegator |
| 37 |
from idlelib import debugger |
| 38 |
from idlelib import debugger_r |
| 39 |
from idlelib.editor import EditorWindow, fixwordbreaks |
| 40 |
from idlelib.filelist import FileList |
| 41 |
from idlelib.outwin import OutputWindow |
| 42 |
from idlelib import replace |
| 43 |
from idlelib import rpc |
| 44 |
from idlelib.run import idle_formatwarning, StdInputFile, StdOutputFile |
| 45 |
from idlelib.undo import UndoDelegator |
| 46 |
|
| 47 |
# Default for testing; defaults to True in main() for running. |
| 48 |
use_subprocess = False |
| 49 |
|
| 50 |
HOST = '127.0.0.1' # python execution server on localhost loopback |
| 51 |
PORT = 0 # someday pass in host, port for remote debug capability |
| 52 |
|
| 53 |
try: # In case IDLE started with -n. |
| 54 |
eof = 'Ctrl-D (end-of-file)' |
| 55 |
exit.eof = eof |
| 56 |
quit.eof = eof |
| 57 |
except NameError: # In case python started with -S. |
| 58 |
pass |
| 59 |
|
| 60 |
# Override warnings module to write to warning_stream. Initialize to send IDLE |
| 61 |
# internal warnings to the console. ScriptBinding.check_syntax() will |
| 62 |
# temporarily redirect the stream to the shell window to display warnings when |
| 63 |
# checking user's code. |
| 64 |
warning_stream = sys.__stderr__ # None, at least on Windows, if no console. |
| 65 |
|
| 66 |
def idle_showwarning( |
| 67 |
message, category, filename, lineno, file=None, line=None): |
| 68 |
"""Show Idle-format warning (after replacing warnings.showwarning). |
| 69 |
|
| 70 |
The differences are the formatter called, the file=None replacement, |
| 71 |
which can be None, the capture of the consequence AttributeError, |
| 72 |
and the output of a hard-coded prompt. |
| 73 |
""" |
| 74 |
if file is None: |
| 75 |
file = warning_stream |
| 76 |
try: |
| 77 |
file.write(idle_formatwarning( |
| 78 |
message, category, filename, lineno, line=line)) |
| 79 |
file.write(">>> ") |
| 80 |
except (AttributeError, OSError): |
| 81 |
pass # if file (probably __stderr__) is invalid, skip warning. |
| 82 |
|
| 83 |
_warnings_showwarning = None |
| 84 |
|
| 85 |
def capture_warnings(capture): |
| 86 |
"Replace warning.showwarning with idle_showwarning, or reverse." |
| 87 |
|
| 88 |
global _warnings_showwarning |
| 89 |
if capture: |
| 90 |
if _warnings_showwarning is None: |
| 91 |
_warnings_showwarning = warnings.showwarning |
| 92 |
warnings.showwarning = idle_showwarning |
| 93 |
else: |
| 94 |
if _warnings_showwarning is not None: |
| 95 |
warnings.showwarning = _warnings_showwarning |
| 96 |
_warnings_showwarning = None |
| 97 |
|
| 98 |
capture_warnings(True) |
| 99 |
|
| 100 |
def extended_linecache_checkcache(filename=None, |
| 101 |
orig_checkcache=linecache.checkcache): |
| 102 |
"""Extend linecache.checkcache to preserve the <pyshell#...> entries |
| 103 |
|
| 104 |
Rather than repeating the linecache code, patch it to save the |
| 105 |
<pyshell#...> entries, call the original linecache.checkcache() |
| 106 |
(skipping them), and then restore the saved entries. |
| 107 |
|
| 108 |
orig_checkcache is bound at definition time to the original |
| 109 |
method, allowing it to be patched. |
| 110 |
""" |
| 111 |
cache = linecache.cache |
| 112 |
save = {} |
| 113 |
for key in list(cache): |
| 114 |
if key[:1] + key[-1:] == '<>': |
| 115 |
save[key] = cache.pop(key) |
| 116 |
orig_checkcache(filename) |
| 117 |
cache.update(save) |
| 118 |
|
| 119 |
# Patch linecache.checkcache(): |
| 120 |
linecache.checkcache = extended_linecache_checkcache |
| 121 |
|
| 122 |
|
| 123 |
class PyShellEditorWindow(EditorWindow): |
| 124 |
"Regular text edit window in IDLE, supports breakpoints" |
| 125 |
|
| 126 |
def __init__(self, *args): |
| 127 |
self.breakpoints = [] |
| 128 |
EditorWindow.__init__(self, *args) |
| 129 |
self.text.bind("<<set-breakpoint>>", self.set_breakpoint_event) |
| 130 |
self.text.bind("<<clear-breakpoint>>", self.clear_breakpoint_event) |
| 131 |
self.text.bind("<<open-python-shell>>", self.flist.open_shell) |
| 132 |
|
| 133 |
#TODO: don't read/write this from/to .idlerc when testing |
| 134 |
self.breakpointPath = os.path.join( |
| 135 |
idleConf.userdir, 'breakpoints.lst') |
| 136 |
# whenever a file is changed, restore breakpoints |
| 137 |
def filename_changed_hook(old_hook=self.io.filename_change_hook, |
| 138 |
self=self): |
| 139 |
self.restore_file_breaks() |
| 140 |
old_hook() |
| 141 |
self.io.set_filename_change_hook(filename_changed_hook) |
| 142 |
if self.io.filename: |
| 143 |
self.restore_file_breaks() |
| 144 |
self.color_breakpoint_text() |
| 145 |
|
| 146 |
rmenu_specs = [ |
| 147 |
("Cut", "<<cut>>", "rmenu_check_cut"), |
| 148 |
("Copy", "<<copy>>", "rmenu_check_copy"), |
| 149 |
("Paste", "<<paste>>", "rmenu_check_paste"), |
| 150 |
(None, None, None), |
| 151 |
("Set Breakpoint", "<<set-breakpoint>>", None), |
| 152 |
("Clear Breakpoint", "<<clear-breakpoint>>", None) |
| 153 |
] |
| 154 |
|
| 155 |
def color_breakpoint_text(self, color=True): |
| 156 |
"Turn colorizing of breakpoint text on or off" |
| 157 |
if self.io is None: |
| 158 |
# possible due to update in restore_file_breaks |
| 159 |
return |
| 160 |
if color: |
| 161 |
theme = idleConf.CurrentTheme() |
| 162 |
cfg = idleConf.GetHighlight(theme, "break") |
| 163 |
else: |
| 164 |
cfg = {'foreground': '', 'background': ''} |
| 165 |
self.text.tag_config('BREAK', cfg) |
| 166 |
|
| 167 |
def set_breakpoint(self, lineno): |
| 168 |
text = self.text |
| 169 |
filename = self.io.filename |
| 170 |
text.tag_add("BREAK", "%d.0" % lineno, "%d.0" % (lineno+1)) |
| 171 |
try: |
| 172 |
self.breakpoints.index(lineno) |
| 173 |
except ValueError: # only add if missing, i.e. do once |
| 174 |
self.breakpoints.append(lineno) |
| 175 |
try: # update the subprocess debugger |
| 176 |
debug = self.flist.pyshell.interp.debugger |
| 177 |
debug.set_breakpoint(filename, lineno) |
| 178 |
except: # but debugger may not be active right now.... |
| 179 |
pass |
| 180 |
|
| 181 |
def set_breakpoint_event(self, event=None): |
| 182 |
text = self.text |
| 183 |
filename = self.io.filename |
| 184 |
if not filename: |
| 185 |
text.bell() |
| 186 |
return |
| 187 |
lineno = int(float(text.index("insert"))) |
| 188 |
self.set_breakpoint(lineno) |
| 189 |
|
| 190 |
def clear_breakpoint_event(self, event=None): |
| 191 |
text = self.text |
| 192 |
filename = self.io.filename |
| 193 |
if not filename: |
| 194 |
text.bell() |
| 195 |
return |
| 196 |
lineno = int(float(text.index("insert"))) |
| 197 |
try: |
| 198 |
self.breakpoints.remove(lineno) |
| 199 |
except: |
| 200 |
pass |
| 201 |
text.tag_remove("BREAK", "insert linestart",\ |
| 202 |
"insert lineend +1char") |
| 203 |
try: |
| 204 |
debug = self.flist.pyshell.interp.debugger |
| 205 |
debug.clear_breakpoint(filename, lineno) |
| 206 |
except: |
| 207 |
pass |
| 208 |
|
| 209 |
def clear_file_breaks(self): |
| 210 |
if self.breakpoints: |
| 211 |
text = self.text |
| 212 |
filename = self.io.filename |
| 213 |
if not filename: |
| 214 |
text.bell() |
| 215 |
return |
| 216 |
self.breakpoints = [] |
| 217 |
text.tag_remove("BREAK", "1.0", END) |
| 218 |
try: |
| 219 |
debug = self.flist.pyshell.interp.debugger |
| 220 |
debug.clear_file_breaks(filename) |
| 221 |
except: |
| 222 |
pass |
| 223 |
|
| 224 |
def store_file_breaks(self): |
| 225 |
"Save breakpoints when file is saved" |
| 226 |
# XXX 13 Dec 2002 KBK Currently the file must be saved before it can |
| 227 |
# be run. The breaks are saved at that time. If we introduce |
| 228 |
# a temporary file save feature the save breaks functionality |
| 229 |
# needs to be re-verified, since the breaks at the time the |
| 230 |
# temp file is created may differ from the breaks at the last |
| 231 |
# permanent save of the file. Currently, a break introduced |
| 232 |
# after a save will be effective, but not persistent. |
| 233 |
# This is necessary to keep the saved breaks synched with the |
| 234 |
# saved file. |
| 235 |
# |
| 236 |
# Breakpoints are set as tagged ranges in the text. |
| 237 |
# Since a modified file has to be saved before it is |
| 238 |
# run, and since self.breakpoints (from which the subprocess |
| 239 |
# debugger is loaded) is updated during the save, the visible |
| 240 |
# breaks stay synched with the subprocess even if one of these |
| 241 |
# unexpected breakpoint deletions occurs. |
| 242 |
breaks = self.breakpoints |
| 243 |
filename = self.io.filename |
| 244 |
try: |
| 245 |
with open(self.breakpointPath) as fp: |
| 246 |
lines = fp.readlines() |
| 247 |
except OSError: |
| 248 |
lines = [] |
| 249 |
try: |
| 250 |
with open(self.breakpointPath, "w") as new_file: |
| 251 |
for line in lines: |
| 252 |
if not line.startswith(filename + '='): |
| 253 |
new_file.write(line) |
| 254 |
self.update_breakpoints() |
| 255 |
breaks = self.breakpoints |
| 256 |
if breaks: |
| 257 |
new_file.write(filename + '=' + str(breaks) + '\n') |
| 258 |
except OSError as err: |
| 259 |
if not getattr(self.root, "breakpoint_error_displayed", False): |
| 260 |
self.root.breakpoint_error_displayed = True |
| 261 |
messagebox.showerror(title='IDLE Error', |
| 262 |
message='Unable to update breakpoint list:\n%s' |
| 263 |
% str(err), |
| 264 |
parent=self.text) |
| 265 |
|
| 266 |
def restore_file_breaks(self): |
| 267 |
self.text.update() # this enables setting "BREAK" tags to be visible |
| 268 |
if self.io is None: |
| 269 |
# can happen if IDLE closes due to the .update() call |
| 270 |
return |
| 271 |
filename = self.io.filename |
| 272 |
if filename is None: |
| 273 |
return |
| 274 |
if os.path.isfile(self.breakpointPath): |
| 275 |
with open(self.breakpointPath) as fp: |
| 276 |
lines = fp.readlines() |
| 277 |
for line in lines: |
| 278 |
if line.startswith(filename + '='): |
| 279 |
breakpoint_linenumbers = eval(line[len(filename)+1:]) |
| 280 |
for breakpoint_linenumber in breakpoint_linenumbers: |
| 281 |
self.set_breakpoint(breakpoint_linenumber) |
| 282 |
|
| 283 |
def update_breakpoints(self): |
| 284 |
"Retrieves all the breakpoints in the current window" |
| 285 |
text = self.text |
| 286 |
ranges = text.tag_ranges("BREAK") |
| 287 |
linenumber_list = self.ranges_to_linenumbers(ranges) |
| 288 |
self.breakpoints = linenumber_list |
| 289 |
|
| 290 |
def ranges_to_linenumbers(self, ranges): |
| 291 |
lines = [] |
| 292 |
for index in range(0, len(ranges), 2): |
| 293 |
lineno = int(float(ranges[index].string)) |
| 294 |
end = int(float(ranges[index+1].string)) |
| 295 |
while lineno < end: |
| 296 |
lines.append(lineno) |
| 297 |
lineno += 1 |
| 298 |
return lines |
| 299 |
|
| 300 |
# XXX 13 Dec 2002 KBK Not used currently |
| 301 |
# def saved_change_hook(self): |
| 302 |
# "Extend base method - clear breaks if module is modified" |
| 303 |
# if not self.get_saved(): |
| 304 |
# self.clear_file_breaks() |
| 305 |
# EditorWindow.saved_change_hook(self) |
| 306 |
|
| 307 |
def _close(self): |
| 308 |
"Extend base method - clear breaks when module is closed" |
| 309 |
self.clear_file_breaks() |
| 310 |
EditorWindow._close(self) |
| 311 |
|
| 312 |
|
| 313 |
class PyShellFileList(FileList): |
| 314 |
"Extend base class: IDLE supports a shell and breakpoints" |
| 315 |
|
| 316 |
# override FileList's class variable, instances return PyShellEditorWindow |
| 317 |
# instead of EditorWindow when new edit windows are created. |
| 318 |
EditorWindow = PyShellEditorWindow |
| 319 |
|
| 320 |
pyshell = None |
| 321 |
|
| 322 |
def open_shell(self, event=None): |
| 323 |
if self.pyshell: |
| 324 |
self.pyshell.top.wakeup() |
| 325 |
else: |
| 326 |
self.pyshell = PyShell(self) |
| 327 |
if self.pyshell: |
| 328 |
if not self.pyshell.begin(): |
| 329 |
return None |
| 330 |
return self.pyshell |
| 331 |
|
| 332 |
|
| 333 |
class ModifiedColorDelegator(ColorDelegator): |
| 334 |
"Extend base class: colorizer for the shell window itself" |
| 335 |
def recolorize_main(self): |
| 336 |
self.tag_remove("TODO", "1.0", "iomark") |
| 337 |
self.tag_add("SYNC", "1.0", "iomark") |
| 338 |
ColorDelegator.recolorize_main(self) |
| 339 |
|
| 340 |
def removecolors(self): |
| 341 |
# Don't remove shell color tags before "iomark" |
| 342 |
for tag in self.tagdefs: |
| 343 |
self.tag_remove(tag, "iomark", "end") |
| 344 |
|
| 345 |
|
| 346 |
class ModifiedUndoDelegator(UndoDelegator): |
| 347 |
"Extend base class: forbid insert/delete before the I/O mark" |
| 348 |
def insert(self, index, chars, tags=None): |
| 349 |
try: |
| 350 |
if self.delegate.compare(index, "<", "iomark"): |
| 351 |
self.delegate.bell() |
| 352 |
return |
| 353 |
except TclError: |
| 354 |
pass |
| 355 |
UndoDelegator.insert(self, index, chars, tags) |
| 356 |
|
| 357 |
def delete(self, index1, index2=None): |
| 358 |
try: |
| 359 |
if self.delegate.compare(index1, "<", "iomark"): |
| 360 |
self.delegate.bell() |
| 361 |
return |
| 362 |
except TclError: |
| 363 |
pass |
| 364 |
UndoDelegator.delete(self, index1, index2) |
| 365 |
|
| 366 |
def undo_event(self, event): |
| 367 |
# Temporarily monkey-patch the delegate's .insert() method to |
| 368 |
# always use the "stdin" tag. This is needed for undo-ing |
| 369 |
# deletions to preserve the "stdin" tag, because UndoDelegator |
| 370 |
# doesn't preserve tags for deleted text. |
| 371 |
orig_insert = self.delegate.insert |
| 372 |
self.delegate.insert = \ |
| 373 |
lambda index, chars: orig_insert(index, chars, "stdin") |
| 374 |
try: |
| 375 |
super().undo_event(event) |
| 376 |
finally: |
| 377 |
self.delegate.insert = orig_insert |
| 378 |
|
| 379 |
|
| 380 |
class UserInputTaggingDelegator(Delegator): |
| 381 |
"""Delegator used to tag user input with "stdin".""" |
| 382 |
def insert(self, index, chars, tags=None): |
| 383 |
if tags is None: |
| 384 |
tags = "stdin" |
| 385 |
self.delegate.insert(index, chars, tags) |
| 386 |
|
| 387 |
|
| 388 |
class MyRPCClient(rpc.RPCClient): |
| 389 |
|
| 390 |
def handle_EOF(self): |
| 391 |
"Override the base class - just re-raise EOFError" |
| 392 |
raise EOFError |
| 393 |
|
| 394 |
def restart_line(width, filename): # See bpo-38141. |
| 395 |
"""Return width long restart line formatted with filename. |
| 396 |
|
| 397 |
Fill line with balanced '='s, with any extras and at least one at |
| 398 |
the beginning. Do not end with a trailing space. |
| 399 |
""" |
| 400 |
tag = f"= RESTART: {filename or 'Shell'} =" |
| 401 |
if width >= len(tag): |
| 402 |
div, mod = divmod((width -len(tag)), 2) |
| 403 |
return f"{(div+mod)*'='}{tag}{div*'='}" |
| 404 |
else: |
| 405 |
return tag[:-2] # Remove ' ='. |
| 406 |
|
| 407 |
|
| 408 |
class ModifiedInterpreter(InteractiveInterpreter): |
| 409 |
|
| 410 |
def __init__(self, tkconsole): |
| 411 |
self.tkconsole = tkconsole |
| 412 |
locals = sys.modules['__main__'].__dict__ |
| 413 |
InteractiveInterpreter.__init__(self, locals=locals) |
| 414 |
self.restarting = False |
| 415 |
self.subprocess_arglist = None |
| 416 |
self.port = PORT |
| 417 |
self.original_compiler_flags = self.compile.compiler.flags |
| 418 |
|
| 419 |
_afterid = None |
| 420 |
rpcclt = None |
| 421 |
rpcsubproc = None |
| 422 |
|
| 423 |
def spawn_subprocess(self): |
| 424 |
if self.subprocess_arglist is None: |
| 425 |
self.subprocess_arglist = self.build_subprocess_arglist() |
| 426 |
# gh-127060: Disable traceback colors |
| 427 |
env = dict(os.environ, TERM='dumb') |
| 428 |
self.rpcsubproc = subprocess.Popen(self.subprocess_arglist, env=env) |
| 429 |
|
| 430 |
def build_subprocess_arglist(self): |
| 431 |
assert (self.port!=0), ( |
| 432 |
"Socket should have been assigned a port number.") |
| 433 |
w = ['-W' + s for s in sys.warnoptions] |
| 434 |
# Maybe IDLE is installed and is being accessed via sys.path, |
| 435 |
# or maybe it's not installed and the idle.py script is being |
| 436 |
# run from the IDLE source directory. |
| 437 |
del_exitf = idleConf.GetOption('main', 'General', 'delete-exitfunc', |
| 438 |
default=False, type='bool') |
| 439 |
command = f"__import__('idlelib.run').run.main({del_exitf!r})" |
| 440 |
return [sys.executable] + w + ["-c", command, str(self.port)] |
| 441 |
|
| 442 |
def start_subprocess(self): |
| 443 |
addr = (HOST, self.port) |
| 444 |
# GUI makes several attempts to acquire socket, listens for connection |
| 445 |
for i in range(3): |
| 446 |
time.sleep(i) |
| 447 |
try: |
| 448 |
self.rpcclt = MyRPCClient(addr) |
| 449 |
break |
| 450 |
except OSError: |
| 451 |
pass |
| 452 |
else: |
| 453 |
self.display_port_binding_error() |
| 454 |
return None |
| 455 |
# if PORT was 0, system will assign an 'ephemeral' port. Find it out: |
| 456 |
self.port = self.rpcclt.listening_sock.getsockname()[1] |
| 457 |
# if PORT was not 0, probably working with a remote execution server |
| 458 |
if PORT != 0: |
| 459 |
# To allow reconnection within the 2MSL wait (cf. Stevens TCP |
| 460 |
# V1, 18.6), set SO_REUSEADDR. Note that this can be problematic |
| 461 |
# on Windows since the implementation allows two active sockets on |
| 462 |
# the same address! |
| 463 |
self.rpcclt.listening_sock.setsockopt(socket.SOL_SOCKET, |
| 464 |
socket.SO_REUSEADDR, 1) |
| 465 |
self.spawn_subprocess() |
| 466 |
#time.sleep(20) # test to simulate GUI not accepting connection |
| 467 |
# Accept the connection from the Python execution server |
| 468 |
self.rpcclt.listening_sock.settimeout(10) |
| 469 |
try: |
| 470 |
self.rpcclt.accept() |
| 471 |
except TimeoutError: |
| 472 |
self.display_no_subprocess_error() |
| 473 |
return None |
| 474 |
self.rpcclt.register("console", self.tkconsole) |
| 475 |
self.rpcclt.register("stdin", self.tkconsole.stdin) |
| 476 |
self.rpcclt.register("stdout", self.tkconsole.stdout) |
| 477 |
self.rpcclt.register("stderr", self.tkconsole.stderr) |
| 478 |
self.rpcclt.register("flist", self.tkconsole.flist) |
| 479 |
self.rpcclt.register("linecache", linecache) |
| 480 |
self.rpcclt.register("interp", self) |
| 481 |
self.transfer_path(with_cwd=True) |
| 482 |
self.poll_subprocess() |
| 483 |
return self.rpcclt |
| 484 |
|
| 485 |
def restart_subprocess(self, with_cwd=False, filename=''): |
| 486 |
if self.restarting: |
| 487 |
return self.rpcclt |
| 488 |
self.restarting = True |
| 489 |
# close only the subprocess debugger |
| 490 |
debug = self.getdebugger() |
| 491 |
if debug: |
| 492 |
try: |
| 493 |
# Only close subprocess debugger, don't unregister gui_adap! |
| 494 |
debugger_r.close_subprocess_debugger(self.rpcclt) |
| 495 |
except: |
| 496 |
pass |
| 497 |
# Kill subprocess, spawn a new one, accept connection. |
| 498 |
self.rpcclt.close() |
| 499 |
self.terminate_subprocess() |
| 500 |
console = self.tkconsole |
| 501 |
was_executing = console.executing |
| 502 |
console.executing = False |
| 503 |
self.spawn_subprocess() |
| 504 |
try: |
| 505 |
self.rpcclt.accept() |
| 506 |
except TimeoutError: |
| 507 |
self.display_no_subprocess_error() |
| 508 |
return None |
| 509 |
self.transfer_path(with_cwd=with_cwd) |
| 510 |
console.stop_readline() |
| 511 |
# annotate restart in shell window and mark it |
| 512 |
console.text.delete("iomark", "end-1c") |
| 513 |
console.write('\n') |
| 514 |
console.write(restart_line(console.width, filename)) |
| 515 |
console.text.mark_set("restart", "end-1c") |
| 516 |
console.text.mark_gravity("restart", "left") |
| 517 |
if not filename: |
| 518 |
console.showprompt() |
| 519 |
# restart subprocess debugger |
| 520 |
if debug: |
| 521 |
# Restarted debugger connects to current instance of debug GUI |
| 522 |
debugger_r.restart_subprocess_debugger(self.rpcclt) |
| 523 |
# reload remote debugger breakpoints for all PyShellEditWindows |
| 524 |
debug.load_breakpoints() |
| 525 |
self.compile.compiler.flags = self.original_compiler_flags |
| 526 |
self.restarting = False |
| 527 |
return self.rpcclt |
| 528 |
|
| 529 |
def __request_interrupt(self): |
| 530 |
self.rpcclt.remotecall("exec", "interrupt_the_server", (), {}) |
| 531 |
|
| 532 |
def interrupt_subprocess(self): |
| 533 |
threading.Thread(target=self.__request_interrupt).start() |
| 534 |
|
| 535 |
def kill_subprocess(self): |
| 536 |
if self._afterid is not None: |
| 537 |
self.tkconsole.text.after_cancel(self._afterid) |
| 538 |
try: |
| 539 |
self.rpcclt.listening_sock.close() |
| 540 |
except AttributeError: # no socket |
| 541 |
pass |
| 542 |
try: |
| 543 |
self.rpcclt.close() |
| 544 |
except AttributeError: # no socket |
| 545 |
pass |
| 546 |
self.terminate_subprocess() |
| 547 |
self.tkconsole.executing = False |
| 548 |
self.rpcclt = None |
| 549 |
|
| 550 |
def terminate_subprocess(self): |
| 551 |
"Make sure subprocess is terminated" |
| 552 |
try: |
| 553 |
self.rpcsubproc.kill() |
| 554 |
except OSError: |
| 555 |
# process already terminated |
| 556 |
return |
| 557 |
else: |
| 558 |
try: |
| 559 |
self.rpcsubproc.wait() |
| 560 |
except OSError: |
| 561 |
return |
| 562 |
|
| 563 |
def transfer_path(self, with_cwd=False): |
| 564 |
if with_cwd: # Issue 13506 |
| 565 |
path = [''] # include Current Working Directory |
| 566 |
path.extend(sys.path) |
| 567 |
else: |
| 568 |
path = sys.path |
| 569 |
|
| 570 |
self.runcommand("""if 1: |
| 571 |
import sys as _sys |
| 572 |
_sys.path = {!r} |
| 573 |
del _sys |
| 574 |
\n""".format(path)) |
| 575 |
|
| 576 |
active_seq = None |
| 577 |
|
| 578 |
def poll_subprocess(self): |
| 579 |
clt = self.rpcclt |
| 580 |
if clt is None: |
| 581 |
return |
| 582 |
try: |
| 583 |
response = clt.pollresponse(self.active_seq, wait=0.05) |
| 584 |
except (EOFError, OSError, KeyboardInterrupt): |
| 585 |
# lost connection or subprocess terminated itself, restart |
| 586 |
# [the KBI is from rpc.SocketIO.handle_EOF()] |
| 587 |
if self.tkconsole.closing: |
| 588 |
return |
| 589 |
response = None |
| 590 |
self.restart_subprocess() |
| 591 |
if response: |
| 592 |
self.tkconsole.resetoutput() |
| 593 |
self.active_seq = None |
| 594 |
how, what = response |
| 595 |
console = self.tkconsole.console |
| 596 |
if how == "OK": |
| 597 |
if what is not None: |
| 598 |
print(repr(what), file=console) |
| 599 |
elif how == "EXCEPTION": |
| 600 |
if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"): |
| 601 |
self.remote_stack_viewer() |
| 602 |
elif how == "ERROR": |
| 603 |
errmsg = "pyshell.ModifiedInterpreter: Subprocess ERROR:\n" |
| 604 |
print(errmsg, what, file=sys.__stderr__) |
| 605 |
print(errmsg, what, file=console) |
| 606 |
# we received a response to the currently active seq number: |
| 607 |
try: |
| 608 |
self.tkconsole.endexecuting() |
| 609 |
except AttributeError: # shell may have closed |
| 610 |
pass |
| 611 |
# Reschedule myself |
| 612 |
if not self.tkconsole.closing: |
| 613 |
self._afterid = self.tkconsole.text.after( |
| 614 |
self.tkconsole.pollinterval, self.poll_subprocess) |
| 615 |
|
| 616 |
debugger = None |
| 617 |
|
| 618 |
def setdebugger(self, debugger): |
| 619 |
self.debugger = debugger |
| 620 |
|
| 621 |
def getdebugger(self): |
| 622 |
return self.debugger |
| 623 |
|
| 624 |
def open_remote_stack_viewer(self): |
| 625 |
"""Initiate the remote stack viewer from a separate thread. |
| 626 |
|
| 627 |
This method is called from the subprocess, and by returning from this |
| 628 |
method we allow the subprocess to unblock. After a bit the shell |
| 629 |
requests the subprocess to open the remote stack viewer which returns a |
| 630 |
static object looking at the last exception. It is queried through |
| 631 |
the RPC mechanism. |
| 632 |
|
| 633 |
""" |
| 634 |
self.tkconsole.text.after(300, self.remote_stack_viewer) |
| 635 |
return |
| 636 |
|
| 637 |
def remote_stack_viewer(self): |
| 638 |
from idlelib import debugobj_r |
| 639 |
oid = self.rpcclt.remotequeue("exec", "stackviewer", ("flist",), {}) |
| 640 |
if oid is None: |
| 641 |
self.tkconsole.root.bell() |
| 642 |
return |
| 643 |
item = debugobj_r.StubObjectTreeItem(self.rpcclt, oid) |
| 644 |
from idlelib.tree import ScrolledCanvas, TreeNode |
| 645 |
top = Toplevel(self.tkconsole.root) |
| 646 |
theme = idleConf.CurrentTheme() |
| 647 |
background = idleConf.GetHighlight(theme, 'normal')['background'] |
| 648 |
sc = ScrolledCanvas(top, bg=background, highlightthickness=0) |
| 649 |
sc.frame.pack(expand=1, fill="both") |
| 650 |
node = TreeNode(sc.canvas, None, item) |
| 651 |
node.expand() |
| 652 |
# XXX Should GC the remote tree when closing the window |
| 653 |
|
| 654 |
gid = 0 |
| 655 |
|
| 656 |
def execsource(self, source): |
| 657 |
"Like runsource() but assumes complete exec source" |
| 658 |
filename = self.stuffsource(source) |
| 659 |
self.execfile(filename, source) |
| 660 |
|
| 661 |
def execfile(self, filename, source=None): |
| 662 |
"Execute an existing file" |
| 663 |
if source is None: |
| 664 |
with tokenize.open(filename) as fp: |
| 665 |
source = fp.read() |
| 666 |
if use_subprocess: |
| 667 |
source = (f"__file__ = r'''{os.path.abspath(filename)}'''\n" |
| 668 |
+ source + "\ndel __file__") |
| 669 |
try: |
| 670 |
code = compile(source, filename, "exec") |
| 671 |
except (OverflowError, SyntaxError): |
| 672 |
self.tkconsole.resetoutput() |
| 673 |
print('*** Error in script or command!\n' |
| 674 |
'Traceback (most recent call last):', |
| 675 |
file=self.tkconsole.stderr) |
| 676 |
InteractiveInterpreter.showsyntaxerror(self, filename) |
| 677 |
self.tkconsole.showprompt() |
| 678 |
else: |
| 679 |
self.runcode(code) |
| 680 |
|
| 681 |
def runsource(self, source): |
| 682 |
"Extend base class method: Stuff the source in the line cache first" |
| 683 |
filename = self.stuffsource(source) |
| 684 |
# at the moment, InteractiveInterpreter expects str |
| 685 |
assert isinstance(source, str) |
| 686 |
# InteractiveInterpreter.runsource() calls its runcode() method, |
| 687 |
# which is overridden (see below) |
| 688 |
return InteractiveInterpreter.runsource(self, source, filename) |
| 689 |
|
| 690 |
def stuffsource(self, source): |
| 691 |
"Stuff source in the filename cache" |
| 692 |
filename = "<pyshell#%d>" % self.gid |
| 693 |
self.gid = self.gid + 1 |
| 694 |
lines = source.split("\n") |
| 695 |
linecache.cache[filename] = len(source)+1, 0, lines, filename |
| 696 |
return filename |
| 697 |
|
| 698 |
def prepend_syspath(self, filename): |
| 699 |
"Prepend sys.path with file's directory if not already included" |
| 700 |
self.runcommand("""if 1: |
| 701 |
_filename = {!r} |
| 702 |
import sys as _sys |
| 703 |
from os.path import dirname as _dirname |
| 704 |
_dir = _dirname(_filename) |
| 705 |
if not _dir in _sys.path: |
| 706 |
_sys.path.insert(0, _dir) |
| 707 |
del _filename, _sys, _dirname, _dir |
| 708 |
\n""".format(filename)) |
| 709 |
|
| 710 |
def showsyntaxerror(self, filename=None, **kwargs): |
| 711 |
"""Override Interactive Interpreter method: Use Colorizing |
| 712 |
|
| 713 |
Color the offending position instead of printing it and pointing at it |
| 714 |
with a caret. |
| 715 |
|
| 716 |
""" |
| 717 |
tkconsole = self.tkconsole |
| 718 |
text = tkconsole.text |
| 719 |
text.tag_remove("ERROR", "1.0", "end") |
| 720 |
type, value, tb = sys.exc_info() |
| 721 |
msg = getattr(value, 'msg', '') or value or "<no detail available>" |
| 722 |
lineno = getattr(value, 'lineno', '') or 1 |
| 723 |
offset = getattr(value, 'offset', '') or 0 |
| 724 |
if offset == 0: |
| 725 |
lineno += 1 #mark end of offending line |
| 726 |
if lineno == 1: |
| 727 |
pos = "iomark + %d chars" % (offset-1) |
| 728 |
else: |
| 729 |
pos = "iomark linestart + %d lines + %d chars" % \ |
| 730 |
(lineno-1, offset-1) |
| 731 |
tkconsole.colorize_syntax_error(text, pos) |
| 732 |
tkconsole.resetoutput() |
| 733 |
self.write("SyntaxError: %s\n" % msg) |
| 734 |
tkconsole.showprompt() |
| 735 |
|
| 736 |
def showtraceback(self): |
| 737 |
"Extend base class method to reset output properly" |
| 738 |
self.tkconsole.resetoutput() |
| 739 |
self.checklinecache() |
| 740 |
InteractiveInterpreter.showtraceback(self) |
| 741 |
if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"): |
| 742 |
self.tkconsole.open_stack_viewer() |
| 743 |
|
| 744 |
def checklinecache(self): |
| 745 |
"Remove keys other than '<pyshell#n>'." |
| 746 |
cache = linecache.cache |
| 747 |
for key in list(cache): # Iterate list because mutate cache. |
| 748 |
if key[:1] + key[-1:] != "<>": |
| 749 |
del cache[key] |
| 750 |
|
| 751 |
def runcommand(self, code): |
| 752 |
"Run the code without invoking the debugger" |
| 753 |
# The code better not raise an exception! |
| 754 |
if self.tkconsole.executing: |
| 755 |
self.display_executing_dialog() |
| 756 |
return 0 |
| 757 |
if self.rpcclt: |
| 758 |
self.rpcclt.remotequeue("exec", "runcode", (code,), {}) |
| 759 |
else: |
| 760 |
exec(code, self.locals) |
| 761 |
return 1 |
| 762 |
|
| 763 |
def runcode(self, code): |
| 764 |
"Override base class method" |
| 765 |
if self.tkconsole.executing: |
| 766 |
self.restart_subprocess() |
| 767 |
self.checklinecache() |
| 768 |
debugger = self.debugger |
| 769 |
try: |
| 770 |
self.tkconsole.beginexecuting() |
| 771 |
if not debugger and self.rpcclt is not None: |
| 772 |
self.active_seq = self.rpcclt.asyncqueue("exec", "runcode", |
| 773 |
(code,), {}) |
| 774 |
elif debugger: |
| 775 |
debugger.run(code, self.locals) |
| 776 |
else: |
| 777 |
exec(code, self.locals) |
| 778 |
except SystemExit: |
| 779 |
if not self.tkconsole.closing: |
| 780 |
if messagebox.askyesno( |
| 781 |
"Exit?", |
| 782 |
"Do you want to exit altogether?", |
| 783 |
default="yes", |
| 784 |
parent=self.tkconsole.text): |
| 785 |
raise |
| 786 |
else: |
| 787 |
self.showtraceback() |
| 788 |
else: |
| 789 |
raise |
| 790 |
except: |
| 791 |
if use_subprocess: |
| 792 |
print("IDLE internal error in runcode()", |
| 793 |
file=self.tkconsole.stderr) |
| 794 |
self.showtraceback() |
| 795 |
self.tkconsole.endexecuting() |
| 796 |
else: |
| 797 |
if self.tkconsole.canceled: |
| 798 |
self.tkconsole.canceled = False |
| 799 |
print("KeyboardInterrupt", file=self.tkconsole.stderr) |
| 800 |
else: |
| 801 |
self.showtraceback() |
| 802 |
finally: |
| 803 |
if not use_subprocess: |
| 804 |
try: |
| 805 |
self.tkconsole.endexecuting() |
| 806 |
except AttributeError: # shell may have closed |
| 807 |
pass |
| 808 |
|
| 809 |
def write(self, s): |
| 810 |
"Override base class method" |
| 811 |
return self.tkconsole.stderr.write(s) |
| 812 |
|
| 813 |
def display_port_binding_error(self): |
| 814 |
messagebox.showerror( |
| 815 |
"Port Binding Error", |
| 816 |
"IDLE can't bind to a TCP/IP port, which is necessary to " |
| 817 |
"communicate with its Python execution server. This might be " |
| 818 |
"because no networking is installed on this computer. " |
| 819 |
"Run IDLE with the -n command line switch to start without a " |
| 820 |
"subprocess and refer to Help/IDLE Help 'Running without a " |
| 821 |
"subprocess' for further details.", |
| 822 |
parent=self.tkconsole.text) |
| 823 |
|
| 824 |
def display_no_subprocess_error(self): |
| 825 |
messagebox.showerror( |
| 826 |
"Subprocess Connection Error", |
| 827 |
"IDLE's subprocess didn't make connection.\n" |
| 828 |
"See the 'Startup failure' section of the IDLE doc, online at\n" |
| 829 |
"https://docs.python.org/3/library/idle.html#startup-failure", |
| 830 |
parent=self.tkconsole.text) |
| 831 |
|
| 832 |
def display_executing_dialog(self): |
| 833 |
messagebox.showerror( |
| 834 |
"Already executing", |
| 835 |
"The Python Shell window is already executing a command; " |
| 836 |
"please wait until it is finished.", |
| 837 |
parent=self.tkconsole.text) |
| 838 |
|
| 839 |
|
| 840 |
class PyShell(OutputWindow): |
| 841 |
from idlelib.squeezer import Squeezer |
| 842 |
|
| 843 |
shell_title = "IDLE Shell" |
| 844 |
|
| 845 |
# Override classes |
| 846 |
ColorDelegator = ModifiedColorDelegator |
| 847 |
UndoDelegator = ModifiedUndoDelegator |
| 848 |
|
| 849 |
# Override menus |
| 850 |
menu_specs = [ |
| 851 |
("file", "_File"), |
| 852 |
("edit", "_Edit"), |
| 853 |
("debug", "_Debug"), |
| 854 |
("options", "_Options"), |
| 855 |
("window", "_Window"), |
| 856 |
("help", "_Help"), |
| 857 |
] |
| 858 |
|
| 859 |
# Extend right-click context menu |
| 860 |
rmenu_specs = OutputWindow.rmenu_specs + [ |
| 861 |
("Squeeze", "<<squeeze-current-text>>"), |
| 862 |
] |
| 863 |
_idx = 1 + len(list(itertools.takewhile( |
| 864 |
lambda rmenu_item: rmenu_item[0] != "Copy", rmenu_specs) |
| 865 |
)) |
| 866 |
rmenu_specs.insert(_idx, ("Copy with prompts", |
| 867 |
"<<copy-with-prompts>>", |
| 868 |
"rmenu_check_copy")) |
| 869 |
del _idx |
| 870 |
|
| 871 |
allow_line_numbers = False |
| 872 |
user_input_insert_tags = "stdin" |
| 873 |
|
| 874 |
# New classes |
| 875 |
from idlelib.history import History |
| 876 |
from idlelib.sidebar import ShellSidebar |
| 877 |
|
| 878 |
def __init__(self, flist=None): |
| 879 |
ms = self.menu_specs |
| 880 |
if ms[2][0] != "shell": |
| 881 |
ms.insert(2, ("shell", "She_ll")) |
| 882 |
self.interp = ModifiedInterpreter(self) |
| 883 |
if flist is None: |
| 884 |
root = Tk() |
| 885 |
fixwordbreaks(root) |
| 886 |
root.withdraw() |
| 887 |
flist = PyShellFileList(root) |
| 888 |
|
| 889 |
self.shell_sidebar = None # initialized below |
| 890 |
|
| 891 |
OutputWindow.__init__(self, flist, None, None) |
| 892 |
|
| 893 |
self.usetabs = False |
| 894 |
# indentwidth must be 8 when using tabs. See note in EditorWindow: |
| 895 |
self.indentwidth = 4 |
| 896 |
|
| 897 |
self.sys_ps1 = sys.ps1 if hasattr(sys, 'ps1') else '>>>\n' |
| 898 |
self.prompt_last_line = self.sys_ps1.split('\n')[-1] |
| 899 |
self.prompt = self.sys_ps1 # Changes when debug active |
| 900 |
|
| 901 |
text = self.text |
| 902 |
text.configure(wrap="char") |
| 903 |
text.bind("<<newline-and-indent>>", self.enter_callback) |
| 904 |
text.bind("<<plain-newline-and-indent>>", self.linefeed_callback) |
| 905 |
text.bind("<<interrupt-execution>>", self.cancel_callback) |
| 906 |
text.bind("<<end-of-file>>", self.eof_callback) |
| 907 |
text.bind("<<open-stack-viewer>>", self.open_stack_viewer) |
| 908 |
text.bind("<<toggle-debugger>>", self.toggle_debugger) |
| 909 |
text.bind("<<toggle-jit-stack-viewer>>", self.toggle_jit_stack_viewer) |
| 910 |
text.bind("<<copy-with-prompts>>", self.copy_with_prompts_callback) |
| 911 |
if use_subprocess: |
| 912 |
text.bind("<<view-restart>>", self.view_restart_mark) |
| 913 |
text.bind("<<restart-shell>>", self.restart_shell) |
| 914 |
self.squeezer = self.Squeezer(self) |
| 915 |
text.bind("<<squeeze-current-text>>", |
| 916 |
self.squeeze_current_text_event) |
| 917 |
|
| 918 |
self.save_stdout = sys.stdout |
| 919 |
self.save_stderr = sys.stderr |
| 920 |
self.save_stdin = sys.stdin |
| 921 |
from idlelib import iomenu |
| 922 |
self.stdin = StdInputFile(self, "stdin", |
| 923 |
iomenu.encoding, iomenu.errors) |
| 924 |
self.stdout = StdOutputFile(self, "stdout", |
| 925 |
iomenu.encoding, iomenu.errors) |
| 926 |
self.stderr = StdOutputFile(self, "stderr", |
| 927 |
iomenu.encoding, "backslashreplace") |
| 928 |
self.console = StdOutputFile(self, "console", |
| 929 |
iomenu.encoding, iomenu.errors) |
| 930 |
if not use_subprocess: |
| 931 |
sys.stdout = self.stdout |
| 932 |
sys.stderr = self.stderr |
| 933 |
sys.stdin = self.stdin |
| 934 |
try: |
| 935 |
# page help() text to shell. |
| 936 |
import pydoc # import must be done here to capture i/o rebinding. |
| 937 |
# XXX KBK 27Dec07 use text viewer someday, but must work w/o subproc |
| 938 |
pydoc.pager = pydoc.plainpager |
| 939 |
except: |
| 940 |
sys.stderr = sys.__stderr__ |
| 941 |
raise |
| 942 |
# |
| 943 |
self.history = self.History(self.text) |
| 944 |
# |
| 945 |
self.pollinterval = 50 # millisec |
| 946 |
|
| 947 |
self.shell_sidebar = self.ShellSidebar(self) |
| 948 |
|
| 949 |
# Insert UserInputTaggingDelegator at the top of the percolator, |
| 950 |
# but make calls to text.insert() skip it. This causes only insert |
| 951 |
# events generated in Tcl/Tk to go through this delegator. |
| 952 |
self.text.insert = self.per.top.insert |
| 953 |
self.per.insertfilter(UserInputTaggingDelegator()) |
| 954 |
|
| 955 |
if not use_subprocess: |
| 956 |
# Menu options "View Last Restart" and "Restart Shell" are disabled |
| 957 |
self.update_menu_state("shell", 0, "disabled") |
| 958 |
self.update_menu_state("shell", 1, "disabled") |
| 959 |
|
| 960 |
def ResetFont(self): |
| 961 |
super().ResetFont() |
| 962 |
|
| 963 |
if self.shell_sidebar is not None: |
| 964 |
self.shell_sidebar.update_font() |
| 965 |
|
| 966 |
def ResetColorizer(self): |
| 967 |
super().ResetColorizer() |
| 968 |
|
| 969 |
theme = idleConf.CurrentTheme() |
| 970 |
tag_colors = { |
| 971 |
"stdin": {'background': None, 'foreground': None}, |
| 972 |
"stdout": idleConf.GetHighlight(theme, "stdout"), |
| 973 |
"stderr": idleConf.GetHighlight(theme, "stderr"), |
| 974 |
"console": idleConf.GetHighlight(theme, "normal"), |
| 975 |
} |
| 976 |
for tag, tag_colors_config in tag_colors.items(): |
| 977 |
self.text.tag_configure(tag, **tag_colors_config) |
| 978 |
|
| 979 |
if self.shell_sidebar is not None: |
| 980 |
self.shell_sidebar.update_colors() |
| 981 |
|
| 982 |
def replace_event(self, event): |
| 983 |
replace.replace(self.text, insert_tags="stdin") |
| 984 |
return "break" |
| 985 |
|
| 986 |
def get_standard_extension_names(self): |
| 987 |
return idleConf.GetExtensions(shell_only=True) |
| 988 |
|
| 989 |
def get_prompt_text(self, first, last): |
| 990 |
"""Return text between first and last with prompts added.""" |
| 991 |
text = self.text.get(first, last) |
| 992 |
lineno_range = range( |
| 993 |
int(float(first)), |
| 994 |
int(float(last)) |
| 995 |
) |
| 996 |
prompts = [ |
| 997 |
self.shell_sidebar.line_prompts.get(lineno) |
| 998 |
for lineno in lineno_range |
| 999 |
] |
| 1000 |
return "\n".join( |
| 1001 |
line if prompt is None else f"{prompt} {line}" |
| 1002 |
for prompt, line in zip(prompts, text.splitlines()) |
| 1003 |
) + "\n" |
| 1004 |
|
| 1005 |
|
| 1006 |
def copy_with_prompts_callback(self, event=None): |
| 1007 |
"""Copy selected lines to the clipboard, with prompts. |
| 1008 |
|
| 1009 |
This makes the copied text useful for doc-tests and interactive |
| 1010 |
shell code examples. |
| 1011 |
|
| 1012 |
This always copies entire lines, even if only part of the first |
| 1013 |
and/or last lines is selected. |
| 1014 |
""" |
| 1015 |
text = self.text |
| 1016 |
selfirst = text.index('sel.first linestart') |
| 1017 |
if selfirst is None: # Should not be possible. |
| 1018 |
return # No selection, do nothing. |
| 1019 |
sellast = text.index('sel.last') |
| 1020 |
if sellast[-1] != '0': |
| 1021 |
sellast = text.index("sel.last+1line linestart") |
| 1022 |
text.clipboard_clear() |
| 1023 |
prompt_text = self.get_prompt_text(selfirst, sellast) |
| 1024 |
text.clipboard_append(prompt_text) |
| 1025 |
|
| 1026 |
reading = False |
| 1027 |
executing = False |
| 1028 |
canceled = False |
| 1029 |
endoffile = False |
| 1030 |
closing = False |
| 1031 |
_stop_readline_flag = False |
| 1032 |
|
| 1033 |
def set_warning_stream(self, stream): |
| 1034 |
global warning_stream |
| 1035 |
warning_stream = stream |
| 1036 |
|
| 1037 |
def get_warning_stream(self): |
| 1038 |
return warning_stream |
| 1039 |
|
| 1040 |
def toggle_debugger(self, event=None): |
| 1041 |
if self.executing: |
| 1042 |
messagebox.showerror("Don't debug now", |
| 1043 |
"You can only toggle the debugger when idle", |
| 1044 |
parent=self.text) |
| 1045 |
self.set_debugger_indicator() |
| 1046 |
return "break" |
| 1047 |
else: |
| 1048 |
db = self.interp.getdebugger() |
| 1049 |
if db: |
| 1050 |
self.close_debugger() |
| 1051 |
else: |
| 1052 |
self.open_debugger() |
| 1053 |
|
| 1054 |
def set_debugger_indicator(self): |
| 1055 |
db = self.interp.getdebugger() |
| 1056 |
self.setvar("<<toggle-debugger>>", not not db) |
| 1057 |
|
| 1058 |
def toggle_jit_stack_viewer(self, event=None): |
| 1059 |
pass # All we need is the variable |
| 1060 |
|
| 1061 |
def close_debugger(self): |
| 1062 |
db = self.interp.getdebugger() |
| 1063 |
if db: |
| 1064 |
self.interp.setdebugger(None) |
| 1065 |
db.close() |
| 1066 |
if self.interp.rpcclt: |
| 1067 |
debugger_r.close_remote_debugger(self.interp.rpcclt) |
| 1068 |
self.resetoutput() |
| 1069 |
self.console.write("[DEBUG OFF]\n") |
| 1070 |
self.prompt = self.sys_ps1 |
| 1071 |
self.showprompt() |
| 1072 |
self.set_debugger_indicator() |
| 1073 |
|
| 1074 |
def open_debugger(self): |
| 1075 |
if self.interp.rpcclt: |
| 1076 |
dbg_gui = debugger_r.start_remote_debugger(self.interp.rpcclt, |
| 1077 |
self) |
| 1078 |
else: |
| 1079 |
dbg_gui = debugger.Debugger(self) |
| 1080 |
self.interp.setdebugger(dbg_gui) |
| 1081 |
dbg_gui.load_breakpoints() |
| 1082 |
self.prompt = "[DEBUG ON]\n" + self.sys_ps1 |
| 1083 |
self.showprompt() |
| 1084 |
self.set_debugger_indicator() |
| 1085 |
|
| 1086 |
def debug_menu_postcommand(self): |
| 1087 |
state = 'disabled' if self.executing else 'normal' |
| 1088 |
self.update_menu_state('debug', '*tack*iewer', state) |
| 1089 |
|
| 1090 |
def beginexecuting(self): |
| 1091 |
"Helper for ModifiedInterpreter" |
| 1092 |
self.resetoutput() |
| 1093 |
self.executing = True |
| 1094 |
|
| 1095 |
def endexecuting(self): |
| 1096 |
"Helper for ModifiedInterpreter" |
| 1097 |
self.executing = False |
| 1098 |
self.canceled = False |
| 1099 |
self.showprompt() |
| 1100 |
|
| 1101 |
def close(self): |
| 1102 |
"Extend EditorWindow.close()" |
| 1103 |
if self.executing: |
| 1104 |
response = messagebox.askokcancel( |
| 1105 |
"Kill?", |
| 1106 |
"Your program is still running!\n Do you want to kill it?", |
| 1107 |
default="ok", |
| 1108 |
parent=self.text) |
| 1109 |
if response is False: |
| 1110 |
return "cancel" |
| 1111 |
self.stop_readline() |
| 1112 |
self.canceled = True |
| 1113 |
self.closing = True |
| 1114 |
return EditorWindow.close(self) |
| 1115 |
|
| 1116 |
def _close(self): |
| 1117 |
"Extend EditorWindow._close(), shut down debugger and execution server" |
| 1118 |
self.close_debugger() |
| 1119 |
if use_subprocess: |
| 1120 |
self.interp.kill_subprocess() |
| 1121 |
# Restore std streams |
| 1122 |
sys.stdout = self.save_stdout |
| 1123 |
sys.stderr = self.save_stderr |
| 1124 |
sys.stdin = self.save_stdin |
| 1125 |
# Break cycles |
| 1126 |
self.interp = None |
| 1127 |
self.console = None |
| 1128 |
self.flist.pyshell = None |
| 1129 |
self.history = None |
| 1130 |
EditorWindow._close(self) |
| 1131 |
|
| 1132 |
def ispythonsource(self, filename): |
| 1133 |
"Override EditorWindow method: never remove the colorizer" |
| 1134 |
return True |
| 1135 |
|
| 1136 |
def short_title(self): |
| 1137 |
return self.shell_title |
| 1138 |
|
| 1139 |
SPLASHLINE = 'Enter "help" below or click "Help" above for more information.' |
| 1140 |
|
| 1141 |
def begin(self): |
| 1142 |
self.text.mark_set("iomark", "insert") |
| 1143 |
self.resetoutput() |
| 1144 |
if use_subprocess: |
| 1145 |
nosub = '' |
| 1146 |
client = self.interp.start_subprocess() |
| 1147 |
if not client: |
| 1148 |
self.close() |
| 1149 |
return False |
| 1150 |
else: |
| 1151 |
nosub = ("==== No Subprocess ====\n\n" + |
| 1152 |
"WARNING: Running IDLE without a Subprocess is deprecated\n" + |
| 1153 |
"and will be removed in a later version. See Help/IDLE Help\n" + |
| 1154 |
"for details.\n\n") |
| 1155 |
sys.displayhook = rpc.displayhook |
| 1156 |
|
| 1157 |
self.write("Python %s on %s\n%s\n%s" % |
| 1158 |
(sys.version, sys.platform, self.SPLASHLINE, nosub)) |
| 1159 |
self.text.focus_force() |
| 1160 |
self.showprompt() |
| 1161 |
# User code should use separate default Tk root window |
| 1162 |
import tkinter |
| 1163 |
tkinter._support_default_root = True |
| 1164 |
tkinter._default_root = None |
| 1165 |
return True |
| 1166 |
|
| 1167 |
def stop_readline(self): |
| 1168 |
if not self.reading: # no nested mainloop to exit. |
| 1169 |
return |
| 1170 |
self._stop_readline_flag = True |
| 1171 |
self.top.quit() |
| 1172 |
|
| 1173 |
def readline(self): |
| 1174 |
save = self.reading |
| 1175 |
try: |
| 1176 |
self.reading = True |
| 1177 |
self.top.mainloop() # nested mainloop() |
| 1178 |
finally: |
| 1179 |
self.reading = save |
| 1180 |
if self._stop_readline_flag: |
| 1181 |
self._stop_readline_flag = False |
| 1182 |
return "" |
| 1183 |
line = self.text.get("iomark", "end-1c") |
| 1184 |
if len(line) == 0: # may be EOF if we quit our mainloop with Ctrl-C |
| 1185 |
line = "\n" |
| 1186 |
self.resetoutput() |
| 1187 |
if self.canceled: |
| 1188 |
self.canceled = False |
| 1189 |
if not use_subprocess: |
| 1190 |
raise KeyboardInterrupt |
| 1191 |
if self.endoffile: |
| 1192 |
self.endoffile = False |
| 1193 |
line = "" |
| 1194 |
return line |
| 1195 |
|
| 1196 |
def isatty(self): |
| 1197 |
return True |
| 1198 |
|
| 1199 |
def cancel_callback(self, event=None): |
| 1200 |
try: |
| 1201 |
if self.text.compare("sel.first", "!=", "sel.last"): |
| 1202 |
return # Active selection -- always use default binding |
| 1203 |
except: |
| 1204 |
pass |
| 1205 |
if not (self.executing or self.reading): |
| 1206 |
self.resetoutput() |
| 1207 |
self.interp.write("KeyboardInterrupt\n") |
| 1208 |
self.showprompt() |
| 1209 |
return "break" |
| 1210 |
self.endoffile = False |
| 1211 |
self.canceled = True |
| 1212 |
if (self.executing and self.interp.rpcclt): |
| 1213 |
if self.interp.getdebugger(): |
| 1214 |
self.interp.restart_subprocess() |
| 1215 |
else: |
| 1216 |
self.interp.interrupt_subprocess() |
| 1217 |
if self.reading: |
| 1218 |
self.top.quit() # exit the nested mainloop() in readline() |
| 1219 |
return "break" |
| 1220 |
|
| 1221 |
def eof_callback(self, event): |
| 1222 |
if self.executing and not self.reading: |
| 1223 |
return # Let the default binding (delete next char) take over |
| 1224 |
if not (self.text.compare("iomark", "==", "insert") and |
| 1225 |
self.text.compare("insert", "==", "end-1c")): |
| 1226 |
return # Let the default binding (delete next char) take over |
| 1227 |
if not self.executing: |
| 1228 |
self.resetoutput() |
| 1229 |
self.close() |
| 1230 |
else: |
| 1231 |
self.canceled = False |
| 1232 |
self.endoffile = True |
| 1233 |
self.top.quit() |
| 1234 |
return "break" |
| 1235 |
|
| 1236 |
def linefeed_callback(self, event): |
| 1237 |
# Insert a linefeed without entering anything (still autoindented) |
| 1238 |
if self.reading: |
| 1239 |
self.text.insert("insert", "\n") |
| 1240 |
self.text.see("insert") |
| 1241 |
else: |
| 1242 |
self.newline_and_indent_event(event) |
| 1243 |
return "break" |
| 1244 |
|
| 1245 |
def enter_callback(self, event): |
| 1246 |
if self.executing and not self.reading: |
| 1247 |
return # Let the default binding (insert '\n') take over |
| 1248 |
# If some text is selected, recall the selection |
| 1249 |
# (but only if this before the I/O mark) |
| 1250 |
try: |
| 1251 |
sel = self.text.get("sel.first", "sel.last") |
| 1252 |
if sel: |
| 1253 |
if self.text.compare("sel.last", "<=", "iomark"): |
| 1254 |
self.recall(sel, event) |
| 1255 |
return "break" |
| 1256 |
except: |
| 1257 |
pass |
| 1258 |
# If we're strictly before the line containing iomark, recall |
| 1259 |
# the current line, less a leading prompt, less leading or |
| 1260 |
# trailing whitespace |
| 1261 |
if self.text.compare("insert", "<", "iomark linestart"): |
| 1262 |
# Check if there's a relevant stdin range -- if so, use it. |
| 1263 |
# Note: "stdin" blocks may include several successive statements, |
| 1264 |
# so look for "console" tags on the newline before each statement |
| 1265 |
# (and possibly on prompts). |
| 1266 |
prev = self.text.tag_prevrange("stdin", "insert") |
| 1267 |
if ( |
| 1268 |
prev and |
| 1269 |
self.text.compare("insert", "<", prev[1]) and |
| 1270 |
# The following is needed to handle empty statements. |
| 1271 |
"console" not in self.text.tag_names("insert") |
| 1272 |
): |
| 1273 |
prev_cons = self.text.tag_prevrange("console", "insert") |
| 1274 |
if prev_cons and self.text.compare(prev_cons[1], ">=", prev[0]): |
| 1275 |
prev = (prev_cons[1], prev[1]) |
| 1276 |
next_cons = self.text.tag_nextrange("console", "insert") |
| 1277 |
if next_cons and self.text.compare(next_cons[0], "<", prev[1]): |
| 1278 |
prev = (prev[0], self.text.index(next_cons[0] + "+1c")) |
| 1279 |
self.recall(self.text.get(prev[0], prev[1]), event) |
| 1280 |
return "break" |
| 1281 |
next = self.text.tag_nextrange("stdin", "insert") |
| 1282 |
if next and self.text.compare("insert lineend", ">=", next[0]): |
| 1283 |
next_cons = self.text.tag_nextrange("console", "insert lineend") |
| 1284 |
if next_cons and self.text.compare(next_cons[0], "<", next[1]): |
| 1285 |
next = (next[0], self.text.index(next_cons[0] + "+1c")) |
| 1286 |
self.recall(self.text.get(next[0], next[1]), event) |
| 1287 |
return "break" |
| 1288 |
# No stdin mark -- just get the current line, less any prompt |
| 1289 |
indices = self.text.tag_nextrange("console", "insert linestart") |
| 1290 |
if indices and \ |
| 1291 |
self.text.compare(indices[0], "<=", "insert linestart"): |
| 1292 |
self.recall(self.text.get(indices[1], "insert lineend"), event) |
| 1293 |
else: |
| 1294 |
self.recall(self.text.get("insert linestart", "insert lineend"), event) |
| 1295 |
return "break" |
| 1296 |
# If we're between the beginning of the line and the iomark, i.e. |
| 1297 |
# in the prompt area, move to the end of the prompt |
| 1298 |
if self.text.compare("insert", "<", "iomark"): |
| 1299 |
self.text.mark_set("insert", "iomark") |
| 1300 |
# If we're in the current input and there's only whitespace |
| 1301 |
# beyond the cursor, erase that whitespace first |
| 1302 |
s = self.text.get("insert", "end-1c") |
| 1303 |
if s and not s.strip(): |
| 1304 |
self.text.delete("insert", "end-1c") |
| 1305 |
# If we're in the current input before its last line, |
| 1306 |
# insert a newline right at the insert point |
| 1307 |
if self.text.compare("insert", "<", "end-1c linestart"): |
| 1308 |
self.newline_and_indent_event(event) |
| 1309 |
return "break" |
| 1310 |
# We're in the last line; append a newline and submit it |
| 1311 |
self.text.mark_set("insert", "end-1c") |
| 1312 |
if self.reading: |
| 1313 |
self.text.insert("insert", "\n") |
| 1314 |
self.text.see("insert") |
| 1315 |
else: |
| 1316 |
self.newline_and_indent_event(event) |
| 1317 |
self.text.update_idletasks() |
| 1318 |
if self.reading: |
| 1319 |
self.top.quit() # Break out of recursive mainloop() |
| 1320 |
else: |
| 1321 |
self.runit() |
| 1322 |
return "break" |
| 1323 |
|
| 1324 |
def recall(self, s, event): |
| 1325 |
# remove leading and trailing empty or whitespace lines |
| 1326 |
s = re.sub(r'^\s*\n', '', s) |
| 1327 |
s = re.sub(r'\n\s*$', '', s) |
| 1328 |
lines = s.split('\n') |
| 1329 |
self.text.undo_block_start() |
| 1330 |
try: |
| 1331 |
self.text.tag_remove("sel", "1.0", "end") |
| 1332 |
self.text.mark_set("insert", "end-1c") |
| 1333 |
prefix = self.text.get("insert linestart", "insert") |
| 1334 |
if prefix.rstrip().endswith(':'): |
| 1335 |
self.newline_and_indent_event(event) |
| 1336 |
prefix = self.text.get("insert linestart", "insert") |
| 1337 |
self.text.insert("insert", lines[0].strip(), |
| 1338 |
self.user_input_insert_tags) |
| 1339 |
if len(lines) > 1: |
| 1340 |
orig_base_indent = re.search(r'^([ \t]*)', lines[0]).group(0) |
| 1341 |
new_base_indent = re.search(r'^([ \t]*)', prefix).group(0) |
| 1342 |
for line in lines[1:]: |
| 1343 |
if line.startswith(orig_base_indent): |
| 1344 |
# replace orig base indentation with new indentation |
| 1345 |
line = new_base_indent + line[len(orig_base_indent):] |
| 1346 |
self.text.insert('insert', '\n' + line.rstrip(), |
| 1347 |
self.user_input_insert_tags) |
| 1348 |
finally: |
| 1349 |
self.text.see("insert") |
| 1350 |
self.text.undo_block_stop() |
| 1351 |
|
| 1352 |
_last_newline_re = re.compile(r"[ \t]*(\n[ \t]*)?\z") |
| 1353 |
def runit(self): |
| 1354 |
index_before = self.text.index("end-2c") |
| 1355 |
line = self.text.get("iomark", "end-1c") |
| 1356 |
# Strip off last newline and surrounding whitespace. |
| 1357 |
# (To allow you to hit return twice to end a statement.) |
| 1358 |
line = self._last_newline_re.sub("", line) |
| 1359 |
input_is_complete = self.interp.runsource(line) |
| 1360 |
if not input_is_complete: |
| 1361 |
if self.text.get(index_before) == '\n': |
| 1362 |
self.text.tag_remove(self.user_input_insert_tags, index_before) |
| 1363 |
self.shell_sidebar.update_sidebar() |
| 1364 |
|
| 1365 |
def open_stack_viewer(self, event=None): # -n mode only |
| 1366 |
if self.interp.rpcclt: |
| 1367 |
return self.interp.remote_stack_viewer() |
| 1368 |
|
| 1369 |
from idlelib.stackviewer import StackBrowser |
| 1370 |
try: |
| 1371 |
StackBrowser(self.root, sys.last_exc, self.flist) |
| 1372 |
except: |
| 1373 |
messagebox.showerror("No stack trace", |
| 1374 |
"There is no stack trace yet.\n" |
| 1375 |
"(sys.last_exc is not defined)", |
| 1376 |
parent=self.text) |
| 1377 |
return None |
| 1378 |
|
| 1379 |
def view_restart_mark(self, event=None): |
| 1380 |
self.text.see("iomark") |
| 1381 |
self.text.see("restart") |
| 1382 |
|
| 1383 |
def restart_shell(self, event=None): |
| 1384 |
"Callback for Run/Restart Shell Cntl-F6" |
| 1385 |
self.interp.restart_subprocess(with_cwd=True) |
| 1386 |
|
| 1387 |
def showprompt(self): |
| 1388 |
self.resetoutput() |
| 1389 |
|
| 1390 |
prompt = self.prompt |
| 1391 |
if self.sys_ps1 and prompt.endswith(self.sys_ps1): |
| 1392 |
prompt = prompt[:-len(self.sys_ps1)] |
| 1393 |
self.text.tag_add("console", "iomark-1c") |
| 1394 |
self.console.write(prompt) |
| 1395 |
|
| 1396 |
self.shell_sidebar.update_sidebar() |
| 1397 |
self.text.mark_set("insert", "end-1c") |
| 1398 |
self.set_line_and_column() |
| 1399 |
self.io.reset_undo() |
| 1400 |
|
| 1401 |
def show_warning(self, msg): |
| 1402 |
width = self.interp.tkconsole.width |
| 1403 |
wrapper = TextWrapper(width=width, tabsize=8, expand_tabs=True) |
| 1404 |
wrapped_msg = '\n'.join(wrapper.wrap(msg)) |
| 1405 |
if not wrapped_msg.endswith('\n'): |
| 1406 |
wrapped_msg += '\n' |
| 1407 |
self.per.bottom.insert("iomark linestart", wrapped_msg, "stderr") |
| 1408 |
|
| 1409 |
def resetoutput(self): |
| 1410 |
source = self.text.get("iomark", "end-1c") |
| 1411 |
if self.history: |
| 1412 |
self.history.store(source) |
| 1413 |
if self.text.get("end-2c") != "\n": |
| 1414 |
self.text.insert("end-1c", "\n") |
| 1415 |
self.text.mark_set("iomark", "end-1c") |
| 1416 |
self.set_line_and_column() |
| 1417 |
self.ctip.remove_calltip_window() |
| 1418 |
|
| 1419 |
def write(self, s, tags=()): |
| 1420 |
try: |
| 1421 |
self.text.mark_gravity("iomark", "right") |
| 1422 |
count = OutputWindow.write(self, s, tags, "iomark") |
| 1423 |
self.text.mark_gravity("iomark", "left") |
| 1424 |
except: |
| 1425 |
raise ###pass # ### 11Aug07 KBK if we are expecting exceptions |
| 1426 |
# let's find out what they are and be specific. |
| 1427 |
if self.canceled: |
| 1428 |
self.canceled = False |
| 1429 |
if not use_subprocess: |
| 1430 |
raise KeyboardInterrupt |
| 1431 |
return count |
| 1432 |
|
| 1433 |
def rmenu_check_cut(self): |
| 1434 |
try: |
| 1435 |
if self.text.compare('sel.first', '<', 'iomark'): |
| 1436 |
return 'disabled' |
| 1437 |
except TclError: # no selection, so the index 'sel.first' doesn't exist |
| 1438 |
return 'disabled' |
| 1439 |
return super().rmenu_check_cut() |
| 1440 |
|
| 1441 |
def rmenu_check_paste(self): |
| 1442 |
if self.text.compare('insert','<','iomark'): |
| 1443 |
return 'disabled' |
| 1444 |
return super().rmenu_check_paste() |
| 1445 |
|
| 1446 |
def squeeze_current_text_event(self, event=None): |
| 1447 |
self.squeezer.squeeze_current_text() |
| 1448 |
self.shell_sidebar.update_sidebar() |
| 1449 |
|
| 1450 |
def on_squeezed_expand(self, index, text, tags): |
| 1451 |
self.shell_sidebar.update_sidebar() |
| 1452 |
|
| 1453 |
|
| 1454 |
def fix_x11_paste(root): |
| 1455 |
"Make paste replace selection on x11. See issue #5124." |
| 1456 |
if root._windowingsystem == 'x11': |
| 1457 |
for cls in 'Text', 'Entry', 'Spinbox': |
| 1458 |
root.bind_class( |
| 1459 |
cls, |
| 1460 |
'<<Paste>>', |
| 1461 |
'catch {%W delete sel.first sel.last}\n' + |
| 1462 |
root.bind_class(cls, '<<Paste>>')) |
| 1463 |
|
| 1464 |
|
| 1465 |
usage_msg = """\ |
| 1466 |
|
| 1467 |
USAGE: idle [-deins] [-t title] [file]* |
| 1468 |
idle [-dns] [-t title] (-c cmd | -r file) [arg]* |
| 1469 |
idle [-dns] [-t title] - [arg]* |
| 1470 |
|
| 1471 |
-h print this help message and exit |
| 1472 |
-n run IDLE without a subprocess (DEPRECATED, |
| 1473 |
see Help/IDLE Help for details) |
| 1474 |
|
| 1475 |
The following options will override the IDLE 'settings' configuration: |
| 1476 |
|
| 1477 |
-e open an edit window |
| 1478 |
-i open a shell window |
| 1479 |
|
| 1480 |
The following options imply -i and will open a shell: |
| 1481 |
|
| 1482 |
-c cmd run the command in a shell, or |
| 1483 |
-r file run script from file |
| 1484 |
|
| 1485 |
-d enable the debugger |
| 1486 |
-s run $IDLESTARTUP or $PYTHONSTARTUP before anything else |
| 1487 |
-t title set title of shell window |
| 1488 |
|
| 1489 |
A default edit window will be bypassed when -c, -r, or - are used. |
| 1490 |
|
| 1491 |
[arg]* are passed to the command (-c) or script (-r) in sys.argv[1:]. |
| 1492 |
|
| 1493 |
Examples: |
| 1494 |
|
| 1495 |
idle |
| 1496 |
Open an edit window or shell depending on IDLE's configuration. |
| 1497 |
|
| 1498 |
idle foo.py foobar.py |
| 1499 |
Edit the files, also open a shell if configured to start with shell. |
| 1500 |
|
| 1501 |
idle -est "Baz" foo.py |
| 1502 |
Run $IDLESTARTUP or $PYTHONSTARTUP, edit foo.py, and open a shell |
| 1503 |
window with the title "Baz". |
| 1504 |
|
| 1505 |
idle -c "import sys; print(sys.argv)" "foo" |
| 1506 |
Open a shell window and run the command, passing "-c" in sys.argv[0] |
| 1507 |
and "foo" in sys.argv[1]. |
| 1508 |
|
| 1509 |
idle -d -s -r foo.py "Hello World" |
| 1510 |
Open a shell window, run a startup script, enable the debugger, and |
| 1511 |
run foo.py, passing "foo.py" in sys.argv[0] and "Hello World" in |
| 1512 |
sys.argv[1]. |
| 1513 |
|
| 1514 |
echo "import sys; print(sys.argv)" | idle - "foobar" |
| 1515 |
Open a shell window, run the script piped in, passing '' in sys.argv[0] |
| 1516 |
and "foobar" in sys.argv[1]. |
| 1517 |
""" |
| 1518 |
|
| 1519 |
def main(): |
| 1520 |
import getopt |
| 1521 |
from platform import system |
| 1522 |
from idlelib import testing # bool value |
| 1523 |
from idlelib import macosx |
| 1524 |
|
| 1525 |
global flist, root, use_subprocess |
| 1526 |
|
| 1527 |
capture_warnings(True) |
| 1528 |
use_subprocess = True |
| 1529 |
enable_shell = False |
| 1530 |
enable_edit = False |
| 1531 |
debug = False |
| 1532 |
cmd = None |
| 1533 |
script = None |
| 1534 |
startup = False |
| 1535 |
try: |
| 1536 |
opts, args = getopt.getopt(sys.argv[1:], "c:deihnr:st:") |
| 1537 |
except getopt.error as msg: |
| 1538 |
print(f"Error: {msg}\n{usage_msg}", file=sys.stderr) |
| 1539 |
sys.exit(2) |
| 1540 |
for o, a in opts: |
| 1541 |
if o == '-c': |
| 1542 |
cmd = a |
| 1543 |
enable_shell = True |
| 1544 |
if o == '-d': |
| 1545 |
debug = True |
| 1546 |
enable_shell = True |
| 1547 |
if o == '-e': |
| 1548 |
enable_edit = True |
| 1549 |
if o == '-h': |
| 1550 |
sys.stdout.write(usage_msg) |
| 1551 |
sys.exit() |
| 1552 |
if o == '-i': |
| 1553 |
enable_shell = True |
| 1554 |
if o == '-n': |
| 1555 |
print(" Warning: running IDLE without a subprocess is deprecated.", |
| 1556 |
file=sys.stderr) |
| 1557 |
use_subprocess = False |
| 1558 |
if o == '-r': |
| 1559 |
script = a |
| 1560 |
if os.path.isfile(script): |
| 1561 |
pass |
| 1562 |
else: |
| 1563 |
print("No script file: ", script) |
| 1564 |
sys.exit() |
| 1565 |
enable_shell = True |
| 1566 |
if o == '-s': |
| 1567 |
startup = True |
| 1568 |
enable_shell = True |
| 1569 |
if o == '-t': |
| 1570 |
PyShell.shell_title = a |
| 1571 |
enable_shell = True |
| 1572 |
if args and args[0] == '-': |
| 1573 |
cmd = sys.stdin.read() |
| 1574 |
enable_shell = True |
| 1575 |
# process sys.argv and sys.path: |
| 1576 |
for i in range(len(sys.path)): |
| 1577 |
sys.path[i] = os.path.abspath(sys.path[i]) |
| 1578 |
if args and args[0] == '-': |
| 1579 |
sys.argv = [''] + args[1:] |
| 1580 |
elif cmd: |
| 1581 |
sys.argv = ['-c'] + args |
| 1582 |
elif script: |
| 1583 |
sys.argv = [script] + args |
| 1584 |
elif args: |
| 1585 |
enable_edit = True |
| 1586 |
pathx = [] |
| 1587 |
for filename in args: |
| 1588 |
pathx.append(os.path.dirname(filename)) |
| 1589 |
for dir in pathx: |
| 1590 |
dir = os.path.abspath(dir) |
| 1591 |
if not dir in sys.path: |
| 1592 |
sys.path.insert(0, dir) |
| 1593 |
else: |
| 1594 |
dir = os.getcwd() |
| 1595 |
if dir not in sys.path: |
| 1596 |
sys.path.insert(0, dir) |
| 1597 |
# check the IDLE settings configuration (but command line overrides) |
| 1598 |
edit_start = idleConf.GetOption('main', 'General', |
| 1599 |
'editor-on-startup', type='bool') |
| 1600 |
enable_edit = enable_edit or edit_start |
| 1601 |
enable_shell = enable_shell or not enable_edit |
| 1602 |
|
| 1603 |
# Setup root. Don't break user code run in IDLE process. |
| 1604 |
# Don't change environment when testing. |
| 1605 |
if use_subprocess and not testing: |
| 1606 |
NoDefaultRoot() |
| 1607 |
root = Tk(className="Idle") |
| 1608 |
root.withdraw() |
| 1609 |
from idlelib.run import fix_scaling |
| 1610 |
fix_scaling(root) |
| 1611 |
|
| 1612 |
# set application icon |
| 1613 |
icondir = os.path.join(os.path.dirname(__file__), 'Icons') |
| 1614 |
if system() == 'Windows': |
| 1615 |
iconfile = os.path.join(icondir, 'idle.ico') |
| 1616 |
root.wm_iconbitmap(default=iconfile) |
| 1617 |
elif not macosx.isAquaTk(): |
| 1618 |
if TkVersion >= 8.6: |
| 1619 |
ext = '.png' |
| 1620 |
sizes = (16, 32, 48, 256) |
| 1621 |
else: |
| 1622 |
ext = '.gif' |
| 1623 |
sizes = (16, 32, 48) |
| 1624 |
iconfiles = [os.path.join(icondir, 'idle_%d%s' % (size, ext)) |
| 1625 |
for size in sizes] |
| 1626 |
icons = [PhotoImage(master=root, file=iconfile) |
| 1627 |
for iconfile in iconfiles] |
| 1628 |
root.wm_iconphoto(True, *icons) |
| 1629 |
|
| 1630 |
# start editor and/or shell windows: |
| 1631 |
fixwordbreaks(root) |
| 1632 |
fix_x11_paste(root) |
| 1633 |
flist = PyShellFileList(root) |
| 1634 |
macosx.setupApp(root, flist) |
| 1635 |
|
| 1636 |
if enable_edit: |
| 1637 |
if not (cmd or script): |
| 1638 |
for filename in args[:]: |
| 1639 |
if flist.open(filename) is None: |
| 1640 |
# filename is a directory actually, disconsider it |
| 1641 |
args.remove(filename) |
| 1642 |
if not args: |
| 1643 |
flist.new() |
| 1644 |
|
| 1645 |
if enable_shell: |
| 1646 |
shell = flist.open_shell() |
| 1647 |
if not shell: |
| 1648 |
return # couldn't open shell |
| 1649 |
if macosx.isAquaTk() and flist.dict: |
| 1650 |
# On OSX: when the user has double-clicked on a file that causes |
| 1651 |
# IDLE to be launched the shell window will open just in front of |
| 1652 |
# the file she wants to see. Lower the interpreter window when |
| 1653 |
# there are open files. |
| 1654 |
shell.top.lower() |
| 1655 |
else: |
| 1656 |
shell = flist.pyshell |
| 1657 |
|
| 1658 |
# Handle remaining options. If any of these are set, enable_shell |
| 1659 |
# was set also, so shell must be true to reach here. |
| 1660 |
if debug: |
| 1661 |
shell.open_debugger() |
| 1662 |
if startup: |
| 1663 |
filename = os.environ.get("IDLESTARTUP") or \ |
| 1664 |
os.environ.get("PYTHONSTARTUP") |
| 1665 |
if filename and os.path.isfile(filename): |
| 1666 |
shell.interp.execfile(filename) |
| 1667 |
if cmd or script: |
| 1668 |
shell.interp.runcommand("""if 1: |
| 1669 |
import sys as _sys |
| 1670 |
_sys.argv = {!r} |
| 1671 |
del _sys |
| 1672 |
\n""".format(sys.argv)) |
| 1673 |
if cmd: |
| 1674 |
shell.interp.execsource(cmd) |
| 1675 |
elif script: |
| 1676 |
shell.interp.prepend_syspath(script) |
| 1677 |
shell.interp.execfile(script) |
| 1678 |
elif shell: |
| 1679 |
# If there is a shell window and no cmd or script in progress, |
| 1680 |
# check for problematic issues and print warning message(s) in |
| 1681 |
# the IDLE shell window; this is less intrusive than always |
| 1682 |
# opening a separate window. |
| 1683 |
|
| 1684 |
# Warn if the "Prefer tabs when opening documents" system |
| 1685 |
# preference is set to "Always". |
| 1686 |
prefer_tabs_preference_warning = macosx.preferTabsPreferenceWarning() |
| 1687 |
if prefer_tabs_preference_warning: |
| 1688 |
shell.show_warning(prefer_tabs_preference_warning) |
| 1689 |
|
| 1690 |
while flist.inversedict: # keep IDLE running while files are open. |
| 1691 |
root.mainloop() |
| 1692 |
root.destroy() |
| 1693 |
capture_warnings(False) |
| 1694 |
|
| 1695 |
|
| 1696 |
if __name__ == "__main__": |
| 1697 |
main() |
| 1698 |
|
| 1699 |
capture_warnings(False) # Make sure turned off; see issue 18081 |