| """ idlelib.run | |
| Simplified: pyshell.ModifiedInterpreter spawns a subprocess with | |
| f'''{sys.executable} -c "__import__('idlelib.run').run.main()"''' | |
| '.run' is needed because __import__ returns idlelib, not idlelib.run. | |
| """ | |
| import functools | |
| import io | |
| import linecache | |
| import queue | |
| import signal | |
| import sys | |
| import textwrap | |
| import time | |
| import traceback | |
| import _thread as thread | |
| import threading | |
| import warnings | |
| import idlelib # testing | |
| from idlelib import autocomplete # AutoComplete, fetch_encodings | |
| from idlelib import calltip # Calltip | |
| from idlelib import debugger_r # start_debugger | |
| from idlelib import debugobj_r # remote_object_tree_item | |
| from idlelib import iomenu # encoding | |
| from idlelib import rpc # multiple objects | |
| from idlelib import stackviewer # StackTreeItem | |
| from idlelib import util # fix_scaling | |
| import __main__ # self.locals in Executive.__init__. | |
| import tkinter # Use tcl and, if startup fails, messagebox. | |
| def scrub_tkinter_submodules(): # Call in main when starting user process. | |
| # Undo modifications of tkinter by idlelib imports; see gh-69693. | |
| # Which of these submodules got imported (and thus added as a tkinter | |
| # attribute) depends on what idlelib pulled in, so tolerate missing | |
| # ones rather than assuming a fixed set; see gh-59396. | |
| for mod in ('simpledialog', 'messagebox', 'font', | |
| 'dialog', 'filedialog', 'commondialog', | |
| 'ttk'): | |
| try: | |
| delattr(tkinter, mod) | |
| del sys.modules['tkinter.' + mod] | |
| except (AttributeError, KeyError): | |
| pass | |
| LOCALHOST = '127.0.0.1' | |
| try: | |
| eof = 'Ctrl-D (end-of-file)' | |
| exit.eof = eof | |
| quit.eof = eof | |
| except NameError: # In case subprocess started with -S (maybe in future). | |
| pass | |
| def idle_formatwarning(message, category, filename, lineno, line=None): | |
| """Format warnings the IDLE way.""" | |
| s = "\nWarning (from warnings module):\n" | |
| s += f' File \"{filename}\", line {lineno}\n' | |
| if line is None: | |
| line = linecache.getline(filename, lineno) | |
| line = line.strip() | |
| if line: | |
| s += " %s\n" % line | |
| s += f"{category.__name__}: {message}\n" | |
| return s | |
| def idle_showwarning_subproc( | |
| message, category, filename, lineno, file=None, line=None): | |
| """Show Idle-format warning after replacing warnings.showwarning. | |
| The only difference is the formatter called. | |
| """ | |
| if file is None: | |
| file = sys.stderr | |
| try: | |
| file.write(idle_formatwarning( | |
| message, category, filename, lineno, line)) | |
| except OSError: | |
| pass # the file (probably stderr) is invalid - this warning gets lost. | |
| _warnings_showwarning = None | |
| def capture_warnings(capture): | |
| "Replace warning.showwarning with idle_showwarning_subproc, or reverse." | |
| global _warnings_showwarning | |
| if capture: | |
| if _warnings_showwarning is None: | |
| _warnings_showwarning = warnings.showwarning | |
| warnings.showwarning = idle_showwarning_subproc | |
| else: | |
| if _warnings_showwarning is not None: | |
| warnings.showwarning = _warnings_showwarning | |
| _warnings_showwarning = None | |
| capture_warnings(True) | |
| if idlelib.testing: | |
| # gh-121008: When testing IDLE, don't create a Tk object to avoid side | |
| # effects such as installing a PyOS_InputHook hook. | |
| def handle_tk_events(): | |
| pass | |
| else: | |
| tcl = tkinter.Tcl() | |
| def handle_tk_events(tcl=tcl): | |
| """Process any tk events that are ready to be dispatched if tkinter | |
| has been imported, a tcl interpreter has been created and tk has been | |
| loaded.""" | |
| tcl.eval("update") | |
| # Thread shared globals: Establish a queue between a subthread (which handles | |
| # the socket) and the main thread (which runs user code), plus global | |
| # completion, exit and interruptible (the main thread) flags: | |
| exit_now = False | |
| quitting = False | |
| interruptible = False | |
| def main(del_exitfunc=False): | |
| """Start the Python execution server in a subprocess | |
| In the Python subprocess, RPCServer is instantiated with handlerclass | |
| MyHandler, which inherits register/unregister methods from RPCHandler via | |
| the mix-in class SocketIO. | |
| When the RPCServer 'server' is instantiated, the TCPServer initialization | |
| creates an instance of run.MyHandler and calls its handle() method. | |
| handle() instantiates a run.Executive object, passing it a reference to the | |
| MyHandler object. That reference is saved as attribute rpchandler of the | |
| Executive instance. The Executive methods have access to the reference and | |
| can pass it on to entities that they command | |
| (e.g. debugger_r.Debugger.start_debugger()). The latter, in turn, can | |
| call MyHandler(SocketIO) register/unregister methods via the reference to | |
| register and unregister themselves. | |
| """ | |
| scrub_tkinter_submodules() | |
| global exit_now | |
| global quitting | |
| global no_exitfunc | |
| no_exitfunc = del_exitfunc | |
| #time.sleep(15) # test subprocess not responding | |
| try: | |
| assert(len(sys.argv) > 1) | |
| port = int(sys.argv[-1]) | |
| except: | |
| print("IDLE Subprocess: no IP port passed in sys.argv.", | |
| file=sys.__stderr__) | |
| return | |
| capture_warnings(True) | |
| sys.argv[:] = [""] | |
| threading.Thread(target=manage_socket, | |
| name='SockThread', | |
| args=((LOCALHOST, port),), | |
| daemon=True, | |
| ).start() | |
| while True: | |
| request = None | |
| try: | |
| if exit_now: | |
| try: | |
| exit() | |
| except KeyboardInterrupt: | |
| # exiting but got an extra KBI? Try again! | |
| continue | |
| try: | |
| request = rpc.request_queue.get(block=True, timeout=0.05) | |
| except queue.Empty: | |
| # Issue 32207: calling handle_tk_events here adds spurious | |
| # queue.Empty traceback to event handling exceptions. | |
| pass | |
| if request: | |
| seq, (method, args, kwargs) = request | |
| ret = method(*args, **kwargs) | |
| rpc.response_queue.put((seq, ret)) | |
| else: | |
| handle_tk_events() | |
| except KeyboardInterrupt: | |
| if quitting: | |
| exit_now = True | |
| elif request: | |
| # Interrupted while executing a request, as when debugging. | |
| print_exception() | |
| rpc.response_queue.put((seq, None)) | |
| continue | |
| except SystemExit: | |
| capture_warnings(False) | |
| raise | |
| except: | |
| type, value, tb = sys.exc_info() | |
| try: | |
| print_exception() | |
| rpc.response_queue.put((seq, None)) | |
| except: | |
| # Link didn't work, print same exception to __stderr__ | |
| traceback.print_exception(type, value, tb, file=sys.__stderr__) | |
| exit() | |
| else: | |
| continue | |
| def manage_socket(address): | |
| for i in range(3): | |
| time.sleep(i) | |
| try: | |
| server = MyRPCServer(address, MyHandler) | |
| break | |
| except OSError as err: | |
| print("IDLE Subprocess: OSError: " + err.args[1] + | |
| ", retrying....", file=sys.__stderr__) | |
| socket_error = err | |
| else: | |
| print("IDLE Subprocess: Connection to " | |
| "IDLE GUI failed, exiting.", file=sys.__stderr__) | |
| show_socket_error(socket_error, address) | |
| global exit_now | |
| exit_now = True | |
| return | |
| server.handle_request() # A single request only | |
| def show_socket_error(err, address): | |
| "Display socket error from manage_socket." | |
| import tkinter | |
| from tkinter.messagebox import showerror | |
| root = tkinter.Tk() | |
| util.fix_scaling(root) | |
| root.withdraw() | |
| showerror( | |
| "Subprocess Connection Error", | |
| f"IDLE's subprocess can't connect to {address[0]}:{address[1]}.\n" | |
| f"Fatal OSError #{err.errno}: {err.strerror}.\n" | |
| "See the 'Startup failure' section of the IDLE doc, online at\n" | |
| "https://docs.python.org/3/library/idle.html#startup-failure", | |
| parent=root) | |
| root.destroy() | |
| def get_message_lines(typ, exc, tb): | |
| "Return lines of the exception message, with any suggestion." | |
| return list(traceback.TracebackException(typ, exc, tb).format_exception_only()) | |
| def print_exception(): | |
| import linecache | |
| linecache.checkcache() | |
| flush_stdout() | |
| efile = sys.stderr | |
| typ, val, tb = excinfo = sys.exc_info() | |
| sys.last_type, sys.last_value, sys.last_traceback = excinfo | |
| sys.last_exc = val | |
| seen = set() | |
| exclude = ("run.py", "rpc.py", "threading.py", "queue.py", | |
| "debugger_r.py", "bdb.py") | |
| max_group_width = 15 | |
| max_group_depth = 10 | |
| group_depth = 0 | |
| def print_exc_group(typ, exc, tb, prefix=""): | |
| nonlocal group_depth | |
| group_depth += 1 | |
| prefix2 = prefix or " " | |
| if group_depth > max_group_depth: | |
| print(f"{prefix2}| ... (max_group_depth is {max_group_depth})", | |
| file=efile) | |
| group_depth -= 1 | |
| return | |
| if tb: | |
| if not prefix: | |
| print(" + Exception Group Traceback (most recent call last):", file=efile) | |
| else: | |
| print(f"{prefix}| Exception Group Traceback (most recent call last):", file=efile) | |
| tbe = traceback.extract_tb(tb) | |
| cleanup_traceback(tbe, exclude) | |
| for line in traceback.format_list(tbe): | |
| for subline in line.rstrip().splitlines(): | |
| print(f"{prefix2}| {subline}", file=efile) | |
| lines = get_message_lines(typ, exc, tb) | |
| for line in lines: | |
| print(f"{prefix2}| {line}", end="", file=efile) | |
| num_excs = len(exc.exceptions) | |
| if num_excs <= max_group_width: | |
| n = num_excs | |
| else: | |
| n = max_group_width + 1 | |
| for i, sub in enumerate(exc.exceptions[:n], 1): | |
| truncated = (i > max_group_width) | |
| first_line_pre = "+-" if i == 1 else " " | |
| title = str(i) if not truncated else '...' | |
| print(f"{prefix2}{first_line_pre}+---------------- {title} ----------------", file=efile) | |
| if truncated: | |
| remaining = num_excs - max_group_width | |
| plural = 's' if remaining > 1 else '' | |
| print(f"{prefix2} | and {remaining} more exception{plural}", | |
| file=efile) | |
| need_print_underline = True | |
| elif id(sub) not in seen: | |
| if not prefix: | |
| print_exc(type(sub), sub, sub.__traceback__, " ") | |
| else: | |
| print_exc(type(sub), sub, sub.__traceback__, prefix + " ") | |
| need_print_underline = not isinstance(sub, BaseExceptionGroup) | |
| else: | |
| print(f"{prefix2} | <exception {type(sub).__name__} has printed>", file=efile) | |
| need_print_underline = True | |
| if need_print_underline and i == n: | |
| print(f"{prefix2} +------------------------------------", file=efile) | |
| group_depth -= 1 | |
| def print_exc(typ, exc, tb, prefix=""): | |
| seen.add(id(exc)) | |
| context = exc.__context__ | |
| cause = exc.__cause__ | |
| prefix2 = f"{prefix}| " if prefix else "" | |
| if cause is not None and id(cause) not in seen: | |
| print_exc(type(cause), cause, cause.__traceback__, prefix) | |
| print(f"{prefix2}\n{prefix2}The above exception was the direct cause " | |
| f"of the following exception:\n{prefix2}", file=efile) | |
| elif (context is not None and | |
| not exc.__suppress_context__ and | |
| id(context) not in seen): | |
| print_exc(type(context), context, context.__traceback__, prefix) | |
| print(f"{prefix2}\n{prefix2}During handling of the above exception, " | |
| f"another exception occurred:\n{prefix2}", file=efile) | |
| if isinstance(exc, BaseExceptionGroup): | |
| print_exc_group(typ, exc, tb, prefix=prefix) | |
| else: | |
| if tb: | |
| print(f"{prefix2}Traceback (most recent call last):", file=efile) | |
| tbe = traceback.extract_tb(tb) | |
| cleanup_traceback(tbe, exclude) | |
| if prefix: | |
| for line in traceback.format_list(tbe): | |
| for subline in line.rstrip().splitlines(): | |
| print(f"{prefix}| {subline}", file=efile) | |
| else: | |
| traceback.print_list(tbe, file=efile) | |
| lines = get_message_lines(typ, exc, tb) | |
| for line in lines: | |
| print(f"{prefix2}{line}", end="", file=efile) | |
| print_exc(typ, val, tb) | |
| def cleanup_traceback(tb, exclude): | |
| "Remove excluded traces from beginning/end of tb; get cached lines" | |
| orig_tb = tb[:] | |
| while tb: | |
| for rpcfile in exclude: | |
| if tb[0][0].count(rpcfile): | |
| break # found an exclude, break for: and delete tb[0] | |
| else: | |
| break # no excludes, have left RPC code, break while: | |
| del tb[0] | |
| while tb: | |
| for rpcfile in exclude: | |
| if tb[-1][0].count(rpcfile): | |
| break | |
| else: | |
| break | |
| del tb[-1] | |
| if len(tb) == 0: | |
| # exception was in IDLE internals, don't prune! | |
| tb[:] = orig_tb[:] | |
| print("** IDLE Internal Exception: ", file=sys.stderr) | |
| rpchandler = rpc.objecttable['exec'].rpchandler | |
| for i in range(len(tb)): | |
| fn, ln, nm, line = tb[i] | |
| if nm == '?': | |
| nm = "-toplevel-" | |
| if not line and fn.startswith("<pyshell#"): | |
| line = rpchandler.remotecall('linecache', 'getline', | |
| (fn, ln), {}) | |
| tb[i] = fn, ln, nm, line | |
| def flush_stdout(): | |
| """XXX How to do this now?""" | |
| def exit(): | |
| """Exit subprocess, possibly after first clearing exit functions. | |
| If config-main.cfg/.def 'General' 'delete-exitfunc' is True, then any | |
| functions registered with atexit will be removed before exiting. | |
| (VPython support) | |
| """ | |
| if no_exitfunc: | |
| import atexit | |
| atexit._clear() | |
| capture_warnings(False) | |
| sys.exit(0) | |
| def fixdoc(fun, text): | |
| tem = (fun.__doc__ + '\n\n') if fun.__doc__ is not None else '' | |
| fun.__doc__ = tem + textwrap.fill(textwrap.dedent(text)) | |
| RECURSIONLIMIT_DELTA = 30 | |
| def install_recursionlimit_wrappers(): | |
| """Install wrappers to always add 30 to the recursion limit.""" | |
| # see: bpo-26806 | |
| @functools.wraps(sys.setrecursionlimit) | |
| def setrecursionlimit(*args, **kwargs): | |
| # mimic the original sys.setrecursionlimit()'s input handling | |
| if kwargs: | |
| raise TypeError( | |
| "setrecursionlimit() takes no keyword arguments") | |
| try: | |
| limit, = args | |
| except ValueError: | |
| raise TypeError(f"setrecursionlimit() takes exactly one " | |
| f"argument ({len(args)} given)") | |
| if not limit > 0: | |
| raise ValueError( | |
| "recursion limit must be greater or equal than 1") | |
| return setrecursionlimit.__wrapped__(limit + RECURSIONLIMIT_DELTA) | |
| fixdoc(setrecursionlimit, f"""\ | |
| This IDLE wrapper adds {RECURSIONLIMIT_DELTA} to prevent possible | |
| uninterruptible loops.""") | |
| @functools.wraps(sys.getrecursionlimit) | |
| def getrecursionlimit(): | |
| return getrecursionlimit.__wrapped__() - RECURSIONLIMIT_DELTA | |
| fixdoc(getrecursionlimit, f"""\ | |
| This IDLE wrapper subtracts {RECURSIONLIMIT_DELTA} to compensate | |
| for the {RECURSIONLIMIT_DELTA} IDLE adds when setting the limit.""") | |
| # add the delta to the default recursion limit, to compensate | |
| sys.setrecursionlimit(sys.getrecursionlimit() + RECURSIONLIMIT_DELTA) | |
| sys.setrecursionlimit = setrecursionlimit | |
| sys.getrecursionlimit = getrecursionlimit | |
| def uninstall_recursionlimit_wrappers(): | |
| """Uninstall the recursion limit wrappers from the sys module. | |
| IDLE only uses this for tests. Users can import run and call | |
| this to remove the wrapping. | |
| """ | |
| if ( | |
| getattr(sys.setrecursionlimit, '__wrapped__', None) and | |
| getattr(sys.getrecursionlimit, '__wrapped__', None) | |
| ): | |
| sys.setrecursionlimit = sys.setrecursionlimit.__wrapped__ | |
| sys.getrecursionlimit = sys.getrecursionlimit.__wrapped__ | |
| sys.setrecursionlimit(sys.getrecursionlimit() - RECURSIONLIMIT_DELTA) | |
| class MyRPCServer(rpc.RPCServer): | |
| def handle_error(self, request, client_address): | |
| """Override RPCServer method for IDLE | |
| Interrupt the MainThread and exit server if link is dropped. | |
| """ | |
| global quitting | |
| try: | |
| raise | |
| except SystemExit: | |
| raise | |
| except EOFError: | |
| global exit_now | |
| exit_now = True | |
| thread.interrupt_main() | |
| except: | |
| erf = sys.__stderr__ | |
| print(textwrap.dedent(f""" | |
| {'-'*40} | |
| Unhandled exception in user code execution server!' | |
| Thread: {threading.current_thread().name} | |
| IDLE Client Address: {client_address} | |
| Request: {request!r} | |
| """), file=erf) | |
| traceback.print_exc(limit=-20, file=erf) | |
| print(textwrap.dedent(f""" | |
| *** Unrecoverable, server exiting! | |
| Users should never see this message; it is likely transient. | |
| If this recurs, report this with a copy of the message | |
| and an explanation of how to make it repeat. | |
| {'-'*40}"""), file=erf) | |
| quitting = True | |
| thread.interrupt_main() | |
| # Pseudofiles for shell-remote communication (also used in pyshell) | |
| class StdioFile(io.TextIOBase): | |
| def __init__(self, shell, tags, encoding='utf-8', errors='strict'): | |
| self.shell = shell | |
| # GH-78889: accessing unpickleable attributes freezes Shell. | |
| # IDLE only needs methods; allow 'width' for possible use. | |
| self.shell._RPCProxy__attributes = {'width': 1} | |
| self.tags = tags | |
| self._encoding = encoding | |
| self._errors = errors | |
| @property | |
| def encoding(self): | |
| return self._encoding | |
| @property | |
| def errors(self): | |
| return self._errors | |
| @property | |
| def name(self): | |
| return '<%s>' % self.tags | |
| def isatty(self): | |
| return True | |
| class StdOutputFile(StdioFile): | |
| def writable(self): | |
| return True | |
| def write(self, s): | |
| if self.closed: | |
| raise ValueError("write to closed file") | |
| s = str.encode(s, self.encoding, self.errors).decode(self.encoding, self.errors) | |
| return self.shell.write(s, self.tags) | |
| class StdInputFile(StdioFile): | |
| _line_buffer = '' | |
| def readable(self): | |
| return True | |
| def read(self, size=-1): | |
| if self.closed: | |
| raise ValueError("read from closed file") | |
| if size is None: | |
| size = -1 | |
| elif not isinstance(size, int): | |
| raise TypeError('must be int, not ' + type(size).__name__) | |
| result = self._line_buffer | |
| self._line_buffer = '' | |
| if size < 0: | |
| while line := self.shell.readline(): | |
| result += line | |
| else: | |
| while len(result) < size: | |
| line = self.shell.readline() | |
| if not line: break | |
| result += line | |
| self._line_buffer = result[size:] | |
| result = result[:size] | |
| return result | |
| def readline(self, size=-1): | |
| if self.closed: | |
| raise ValueError("read from closed file") | |
| if size is None: | |
| size = -1 | |
| elif not isinstance(size, int): | |
| raise TypeError('must be int, not ' + type(size).__name__) | |
| line = self._line_buffer or self.shell.readline() | |
| if size < 0: | |
| size = len(line) | |
| eol = line.find('\n', 0, size) | |
| if eol >= 0: | |
| size = eol + 1 | |
| self._line_buffer = line[size:] | |
| return line[:size] | |
| def close(self): | |
| self.shell.close() | |
| class MyHandler(rpc.RPCHandler): | |
| def handle(self): | |
| """Override base method""" | |
| executive = Executive(self) | |
| self.register("exec", executive) | |
| self.console = self.get_remote_proxy("console") | |
| sys.stdin = StdInputFile(self.console, "stdin", | |
| iomenu.encoding, iomenu.errors) | |
| sys.stdout = StdOutputFile(self.console, "stdout", | |
| iomenu.encoding, iomenu.errors) | |
| sys.stderr = StdOutputFile(self.console, "stderr", | |
| iomenu.encoding, "backslashreplace") | |
| sys.displayhook = rpc.displayhook | |
| # page help() text to shell. | |
| import pydoc # import must be done here to capture i/o binding | |
| pydoc.pager = pydoc.plainpager | |
| # Keep a reference to stdin so that it won't try to exit IDLE if | |
| # sys.stdin gets changed from within IDLE's shell. See issue17838. | |
| self._keep_stdin = sys.stdin | |
| install_recursionlimit_wrappers() | |
| self.interp = self.get_remote_proxy("interp") | |
| rpc.RPCHandler.getresponse(self, myseq=None, wait=0.05) | |
| def exithook(self): | |
| "override SocketIO method - wait for MainThread to shut us down" | |
| time.sleep(10) | |
| def EOFhook(self): | |
| "Override SocketIO method - terminate wait on callback and exit thread" | |
| global quitting | |
| quitting = True | |
| thread.interrupt_main() | |
| def decode_interrupthook(self): | |
| "interrupt awakened thread" | |
| global quitting | |
| quitting = True | |
| thread.interrupt_main() | |
| class Executive: | |
| def __init__(self, rpchandler): | |
| self.rpchandler = rpchandler | |
| if idlelib.testing is False: | |
| self.locals = __main__.__dict__ | |
| self.calltip = calltip.Calltip() | |
| self.autocomplete = autocomplete.AutoComplete() | |
| else: | |
| self.locals = {} | |
| def runcode(self, code): | |
| global interruptible | |
| try: | |
| self.user_exc_info = None | |
| interruptible = True | |
| try: | |
| exec(code, self.locals) | |
| finally: | |
| interruptible = False | |
| except SystemExit as e: | |
| if e.args: # SystemExit called with an argument. | |
| ob = e.args[0] | |
| if not isinstance(ob, (type(None), int)): | |
| print('SystemExit: ' + str(ob), file=sys.stderr) | |
| # Return to the interactive prompt. | |
| except: | |
| self.user_exc_info = sys.exc_info() # For testing, hook, viewer. | |
| if quitting: | |
| exit() | |
| if sys.excepthook is sys.__excepthook__: | |
| print_exception() | |
| else: | |
| try: | |
| sys.excepthook(*self.user_exc_info) | |
| except: | |
| self.user_exc_info = sys.exc_info() # For testing. | |
| print_exception() | |
| jit = self.rpchandler.console.getvar("<<toggle-jit-stack-viewer>>") | |
| if jit: | |
| self.rpchandler.interp.open_remote_stack_viewer() | |
| else: | |
| flush_stdout() | |
| def interrupt_the_server(self): | |
| if interruptible: | |
| handler = signal.getsignal(signal.SIGINT) | |
| if handler not in (signal.SIG_DFL, signal.SIG_IGN, None): | |
| # A real signal interrupts blocking calls such as | |
| # time.sleep() (gh-74112). The lock prevents interrupting | |
| # the main thread in the middle of sending a message. | |
| with self.rpchandler.sendlock: | |
| if hasattr(signal, 'pthread_kill'): | |
| signal.pthread_kill(threading.main_thread().ident, | |
| signal.SIGINT) | |
| else: | |
| signal.raise_signal(signal.SIGINT) | |
| else: | |
| thread.interrupt_main() | |
| def start_the_debugger(self, gui_adap_oid): | |
| return debugger_r.start_debugger(self.rpchandler, gui_adap_oid) | |
| def stop_the_debugger(self, idb_adap_oid): | |
| "Unregister the Idb Adapter. Link objects and Idb then subject to GC" | |
| self.rpchandler.unregister(idb_adap_oid) | |
| def get_the_calltip(self, name): | |
| return self.calltip.fetch_tip(name) | |
| def get_the_completion_list(self, what, mode): | |
| return self.autocomplete.fetch_completions(what, mode) | |
| def stackviewer(self, flist_oid=None): | |
| if self.user_exc_info: | |
| _, exc, tb = self.user_exc_info | |
| else: | |
| return None | |
| flist = None | |
| if flist_oid is not None: | |
| flist = self.rpchandler.get_remote_proxy(flist_oid) | |
| while tb and tb.tb_frame.f_globals["__name__"] in ["rpc", "run"]: | |
| tb = tb.tb_next | |
| exc.__traceback__ = tb | |
| item = stackviewer.StackTreeItem(exc, flist) | |
| return debugobj_r.remote_object_tree_item(item) | |
| if __name__ == '__main__': # __name__ is 'idlelib.run' in user subprocess. | |
| from unittest import main | |
| main('idlelib.idle_test.test_run', verbosity=2) | |
| capture_warnings(False) # Make sure turned off; see bpo-18081. |