Debian Codegraph @

Lib/idlelib/pyshell.py

raw
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