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

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

if file is None:

file = sys.stderr

try:

file.write(PyShell.idle_formatwarning(

message, category, filename, lineno, line))

except IOError:

"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

"""Process any tk events that are ready to be dispatched if tkinter

"""Start the Python execution server in a subprocess

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[:] = [""]

sockthread = threading.Thread(target=manage_socket,

name='SockThread',

args=((LOCALHOST, port),))

sockthread.daemon = True

sockthread.start()

while 1:

try:

if exit_now:

try:

exit()

except KeyboardInterrupt:

# exiting but got an extra KBI? Try again!

continue

try:

seq, request = rpc.request_queue.get(block=True, timeout=0.05)

except queue.Empty:

handle_tk_events()

continue

method, args, kwargs = request

ret = method(*args, **kwargs)

rpc.response_queue.put((seq, ret))

except KeyboardInterrupt:

if quitting:

exit_now = True

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:

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

import tkinter

import tkinter.messagebox as tkMessageBox

root = tkinter.Tk()

root.withdraw()

if err.args[0] == 61: # connection refused

msg = "IDLE's subprocess can't connect to %s:%d. This may be due "\

"to your personal firewall configuration. It is safe to "\

"allow this internal connection because no data is visible on "\

"external ports." % address

tkMessageBox.showerror("IDLE Subprocess Error", msg, parent=root)

else:

tkMessageBox.showerror("IDLE Subprocess Error",

"Socket Error: %s" % err.args[1], parent=root)

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

seen = set()

def print_exc(typ, exc, tb):

seen.add(exc)

context = exc.__context__

cause = exc.__cause__

if cause is not None and cause not in seen:

print_exc(type(cause), cause, cause.__traceback__)

print("\nThe above exception was the direct cause "

"of the following exception:\n", file=efile)

elif (context is not None and

not exc.__suppress_context__ and

context not in seen):

print_exc(type(context), context, context.__traceback__)

print("\nDuring handling of the above exception, "

"another exception occurred:\n", file=efile)

if tb:

tbe = traceback.extract_tb(tb)

print('Traceback (most recent call last):', file=efile)

exclude = ("run.py", "rpc.py", "threading.py", "queue.py",

"RemoteDebugger.py", "bdb.py")

cleanup_traceback(tbe, exclude)

traceback.print_list(tbe, file=efile)

lines = traceback.format_exception_only(typ, exc)

for line in lines:

print(line, end='', file=efile)

"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), {})

"""Exit subprocess, possibly after first clearing exit functions.

if no_exitfunc:

import atexit

atexit._clear()

capture_warnings(False)

def handle_error(self, request, client_address):

"""Override RPCServer method for IDLE

global quitting

try:

raise

except SystemExit:

raise

except EOFError:

global exit_now

exit_now = True

thread.interrupt_main()

except:

erf = sys.__stderr__

print('\n' + '-'*40, file=erf)

print('Unhandled server exception!', file=erf)

print('Thread: %s' % threading.current_thread().name, file=erf)

print('Client Address: ', client_address, file=erf)

print('Request: ', repr(request), file=erf)

traceback.print_exc(file=erf)

print('\n*** Unrecoverable, server exiting!', file=erf)

print('-'*40, file=erf)

quitting = True

def handle(self):

"""Override base method"""

executive = Executive(self)

self.register("exec", executive)

self.console = self.get_remote_proxy("console")

sys.stdin = PyShell.PseudoInputFile(self.console, "stdin",

IOBinding.encoding)

sys.stdout = PyShell.PseudoOutputFile(self.console, "stdout",

IOBinding.encoding)

sys.stderr = PyShell.PseudoOutputFile(self.console, "stderr",

IOBinding.encoding)

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

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

def __init__(self, rpchandler):

self.rpchandler = rpchandler

self.locals = __main__.__dict__

self.calltip = CallTips.CallTips()

self.autocomplete = AutoComplete.AutoComplete()

def runcode(self, code):

global interruptable

try:

self.usr_exc_info = None

interruptable = True

try:

exec(code, self.locals)

finally:

interruptable = False

except SystemExit:

# Scripts that raise SystemExit should just

# return to the interactive prompt

pass

except:

self.usr_exc_info = sys.exc_info()

if quitting:

exit()

# even print a user code SystemExit exception, continue

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 interruptable:

thread.interrupt_main()

def start_the_debugger(self, gui_adap_oid):

return RemoteDebugger.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.usr_exc_info:

typ, val, tb = self.usr_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

sys.last_type = typ

sys.last_value = val

item = StackViewer.StackTreeItem(flist, tb)