run.py

""" 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.
"""
importcontextlib
importfunctools
importio
importlinecache
importqueue
importsys
importtextwrap
importtime
importtraceback
import_threadasthread
importthreading
importwarnings

importidlelib# testing
fromidlelibimportautocomplete# AutoComplete, fetch_encodings
fromidlelibimportcalltip# Calltip
fromidlelibimportdebugger_r# start_debugger
fromidlelibimportdebugobj_r# remote_object_tree_item
fromidlelibimportiomenu# encoding
fromidlelibimportrpc# multiple objects
fromidlelibimportstackviewer# StackTreeItem
import__main__

importtkinter# Use tcl and, if startup fails, messagebox.
ifnothasattr(sys.modules['idlelib.run'], 'firstrun'):
# Undo modifications of tkinter by idlelib imports; see bpo-25507.
formodin ('simpledialog', 'messagebox', 'font',
'dialog', 'filedialog', 'commondialog',
'ttk'):
delattr(tkinter, mod)
delsys.modules['tkinter.'+mod]
# Avoid AttributeError if run again; see bpo-37038.
sys.modules['idlelib.run'].firstrun=False

LOCALHOST='127.0.0.1'

try:
eof='Ctrl-D (end-of-file)'
exit.eof=eof
quit.eof=eof
exceptNameError: # In case subprocess started with -S (maybe in future).
pass


defidle_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'
iflineisNone:
line=linecache.getline(filename, lineno)
line=line.strip()
ifline:
s+=" %s\n"%line
s+=f"{category.__name__}: {message}\n"
returns

defidle_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.
 """
iffileisNone:
file=sys.stderr
try:
file.write(idle_formatwarning(
message, category, filename, lineno, line))
exceptOSError:
pass# the file (probably stderr) is invalid - this warning gets lost.

_warnings_showwarning=None

defcapture_warnings(capture):
"Replace warning.showwarning with idle_showwarning_subproc, or reverse."

global_warnings_showwarning
ifcapture:
if_warnings_showwarningisNone:
_warnings_showwarning=warnings.showwarning
warnings.showwarning=idle_showwarning_subproc
else:
if_warnings_showwarningisnotNone:
warnings.showwarning=_warnings_showwarning
_warnings_showwarning=None

capture_warnings(True)

ifidlelib.testing:
# gh-121008: When testing IDLE, don't create a Tk object to avoid side
# effects such as installing a PyOS_InputHook hook.
defhandle_tk_events():
pass
else:
tcl=tkinter.Tcl()

defhandle_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

defmain(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.

 """
globalexit_now
globalquitting
globalno_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()

whileTrue:
try:
ifexit_now:
try:
exit()
exceptKeyboardInterrupt:
# exiting but got an extra KBI? Try again!
continue
try:
request=rpc.request_queue.get(block=True, timeout=0.05)
exceptqueue.Empty:
request=None
# Issue 32207: calling handle_tk_events here adds spurious
# queue.Empty traceback to event handling exceptions.
ifrequest:
seq, (method, args, kwargs) =request
ret=method(*args, **kwargs)
rpc.response_queue.put((seq, ret))
else:
handle_tk_events()
exceptKeyboardInterrupt:
ifquitting:
exit_now=True
continue
exceptSystemExit:
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

defmanage_socket(address):
foriinrange(3):
time.sleep(i)
try:
server=MyRPCServer(address, MyHandler)
break
exceptOSErroraserr:
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)
globalexit_now
exit_now=True
return
server.handle_request() # A single request only

defshow_socket_error(err, address):
"Display socket error from manage_socket."
importtkinter
fromtkinter.messageboximportshowerror
root=tkinter.Tk()
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()


defget_message_lines(typ, exc, tb):
"Return line composing the exception message."
iftypin (AttributeError, NameError):
# 3.10+ hints are not directly accessible from python (#44026).
err=io.StringIO()
withcontextlib.redirect_stderr(err):
sys.__excepthook__(typ, exc, tb)
return [err.getvalue().split("\n")[-2] +"\n"]
else:
returntraceback.format_exception_only(typ, exc)


defprint_exception():
importlinecache
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()

defprint_exc(typ, exc, tb):
seen.add(id(exc))
context=exc.__context__
cause=exc.__cause__
ifcauseisnotNoneandid(cause) notinseen:
print_exc(type(cause), cause, cause.__traceback__)
print("\nThe above exception was the direct cause "
"of the following exception:\n", file=efile)
elif (contextisnotNoneand
notexc.__suppress_context__and
id(context) notinseen):
print_exc(type(context), context, context.__traceback__)
print("\nDuring handling of the above exception, "
"another exception occurred:\n", file=efile)
iftb:
tbe=traceback.extract_tb(tb)
print('Traceback (most recent call last):', file=efile)
exclude= ("run.py", "rpc.py", "threading.py", "queue.py",
"debugger_r.py", "bdb.py")
cleanup_traceback(tbe, exclude)
traceback.print_list(tbe, file=efile)
lines=get_message_lines(typ, exc, tb)
forlineinlines:
print(line, end='', file=efile)

print_exc(typ, val, tb)

defcleanup_traceback(tb, exclude):
"Remove excluded traces from beginning/end of tb; get cached lines"
orig_tb=tb[:]
whiletb:
forrpcfileinexclude:
iftb[0][0].count(rpcfile):
break# found an exclude, break for: and delete tb[0]
else:
break# no excludes, have left RPC code, break while:
deltb[0]
whiletb:
forrpcfileinexclude:
iftb[-1][0].count(rpcfile):
break
else:
break
deltb[-1]
iflen(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
foriinrange(len(tb)):
fn, ln, nm, line=tb[i]
ifnm=='?':
nm="-toplevel-"
ifnotlineandfn.startswith("<pyshell#"):
line=rpchandler.remotecall('linecache', 'getline',
 (fn, ln), {})
tb[i] =fn, ln, nm, line

defflush_stdout():
"""XXX How to do this now?"""

defexit():
"""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)

 """
ifno_exitfunc:
importatexit
atexit._clear()
capture_warnings(False)
sys.exit(0)


deffix_scaling(root):
"""Scale fonts on HiDPI displays."""
importtkinter.font
scaling=float(root.tk.call('tk', 'scaling'))
ifscaling>1.4:
fornameintkinter.font.names(root):
font=tkinter.font.Font(root=root, name=name, exists=True)
size=int(font['size'])
ifsize<0:
font['size'] =round(-0.75*size)


deffixdoc(fun, text):
tem= (fun.__doc__+'\n\n') iffun.__doc__isnotNoneelse''
fun.__doc__=tem+textwrap.fill(textwrap.dedent(text))

RECURSIONLIMIT_DELTA=30

definstall_recursionlimit_wrappers():
"""Install wrappers to always add 30 to the recursion limit."""
# see: bpo-26806

@functools.wraps(sys.setrecursionlimit)
defsetrecursionlimit(*args, **kwargs):
# mimic the original sys.setrecursionlimit()'s input handling
ifkwargs:
raiseTypeError(
"setrecursionlimit() takes no keyword arguments")
try:
limit, =args
exceptValueError:
raiseTypeError(f"setrecursionlimit() takes exactly one "
f"argument ({len(args)} given)")
ifnotlimit>0:
raiseValueError(
"recursion limit must be greater or equal than 1")

returnsetrecursionlimit.__wrapped__(limit+RECURSIONLIMIT_DELTA)

fixdoc(setrecursionlimit, f"""\
 This IDLE wrapper adds {RECURSIONLIMIT_DELTA} to prevent possible
 uninterruptible loops.""")

@functools.wraps(sys.getrecursionlimit)
defgetrecursionlimit():
returngetrecursionlimit.__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


defuninstall_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)


classMyRPCServer(rpc.RPCServer):

defhandle_error(self, request, client_address):
"""Override RPCServer method for IDLE

 Interrupt the MainThread and exit server if link is dropped.

 """
globalquitting
try:
raise
exceptSystemExit:
raise
exceptEOFError:
globalexit_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)

classStdioFile(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
defencoding(self):
returnself._encoding

@property
deferrors(self):
returnself._errors

@property
defname(self):
return'<%s>'%self.tags

defisatty(self):
returnTrue


classStdOutputFile(StdioFile):

defwritable(self):
returnTrue

defwrite(self, s):
ifself.closed:
raiseValueError("write to closed file")
s=str.encode(s, self.encoding, self.errors).decode(self.encoding, self.errors)
returnself.shell.write(s, self.tags)


classStdInputFile(StdioFile):
_line_buffer=''

defreadable(self):
returnTrue

defread(self, size=-1):
ifself.closed:
raiseValueError("read from closed file")
ifsizeisNone:
size=-1
elifnotisinstance(size, int):
raiseTypeError('must be int, not '+type(size).__name__)
result=self._line_buffer
self._line_buffer=''
ifsize<0:
whileline:=self.shell.readline():
result+=line
else:
whilelen(result) <size:
line=self.shell.readline()
ifnotline: break
result+=line
self._line_buffer=result[size:]
result=result[:size]
returnresult

defreadline(self, size=-1):
ifself.closed:
raiseValueError("read from closed file")
ifsizeisNone:
size=-1
elifnotisinstance(size, int):
raiseTypeError('must be int, not '+type(size).__name__)
line=self._line_bufferorself.shell.readline()
ifsize<0:
size=len(line)
eol=line.find('\n', 0, size)
ifeol>=0:
size=eol+1
self._line_buffer=line[size:]
returnline[:size]

defclose(self):
self.shell.close()


classMyHandler(rpc.RPCHandler):

defhandle(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.
importpydoc# 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)

defexithook(self):
"override SocketIO method - wait for MainThread to shut us down"
time.sleep(10)

defEOFhook(self):
"Override SocketIO method - terminate wait on callback and exit thread"
globalquitting
quitting=True
thread.interrupt_main()

defdecode_interrupthook(self):
"interrupt awakened thread"
globalquitting
quitting=True
thread.interrupt_main()


classExecutive:

def__init__(self, rpchandler):
self.rpchandler=rpchandler
ifidlelib.testingisFalse:
self.locals=__main__.__dict__
self.calltip=calltip.Calltip()
self.autocomplete=autocomplete.AutoComplete()
else:
self.locals= {}

defruncode(self, code):
globalinterruptible
try:
self.user_exc_info=None
interruptible=True
try:
exec(code, self.locals)
finally:
interruptible=False
exceptSystemExitase:
ife.args: # SystemExit called with an argument.
ob=e.args[0]
ifnotisinstance(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.
ifquitting:
exit()
ifsys.excepthookissys.__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>>")
ifjit:
self.rpchandler.interp.open_remote_stack_viewer()
else:
flush_stdout()

definterrupt_the_server(self):
ifinterruptible:
thread.interrupt_main()

defstart_the_debugger(self, gui_adap_oid):
returndebugger_r.start_debugger(self.rpchandler, gui_adap_oid)

defstop_the_debugger(self, idb_adap_oid):
"Unregister the Idb Adapter. Link objects and Idb then subject to GC"
self.rpchandler.unregister(idb_adap_oid)

defget_the_calltip(self, name):
returnself.calltip.fetch_tip(name)

defget_the_completion_list(self, what, mode):
returnself.autocomplete.fetch_completions(what, mode)

defstackviewer(self, flist_oid=None):
ifself.user_exc_info:
_, exc, tb=self.user_exc_info
else:
returnNone
flist=None
ifflist_oidisnotNone:
flist=self.rpchandler.get_remote_proxy(flist_oid)
whiletbandtb.tb_frame.f_globals["__name__"] in ["rpc", "run"]:
tb=tb.tb_next
exc.__traceback__=tb
item=stackviewer.StackTreeItem(exc, flist)
returndebugobj_r.remote_object_tree_item(item)


if__name__=='__main__':
fromunittestimportmain
main('idlelib.idle_test.test_run', verbosity=2)

capture_warnings(False) # Make sure turned off; see bpo-18081.