Lines Matching refs:self
133 def __init__(self, *args):
134 self.breakpoints = []
135 EditorWindow.__init__(self, *args)
136 self.text.bind("<<set-breakpoint-here>>", self.set_breakpoint_here)
137 self.text.bind("<<clear-breakpoint-here>>", self.clear_breakpoint_here)
138 self.text.bind("<<open-python-shell>>", self.flist.open_shell)
141 self.breakpointPath = os.path.join(
144 def filename_changed_hook(old_hook=self.io.filename_change_hook,
145 self=self):
146 self.restore_file_breaks()
148 self.io.set_filename_change_hook(filename_changed_hook)
149 if self.io.filename:
150 self.restore_file_breaks()
151 self.color_breakpoint_text()
162 def color_breakpoint_text(self, color=True):
164 if self.io is None:
172 self.text.tag_config('BREAK', cfg)
174 def set_breakpoint(self, lineno):
175 text = self.text
176 filename = self.io.filename
179 self.breakpoints.index(lineno)
181 self.breakpoints.append(lineno)
183 debug = self.flist.pyshell.interp.debugger
188 def set_breakpoint_here(self, event=None):
189 text = self.text
190 filename = self.io.filename
195 self.set_breakpoint(lineno)
197 def clear_breakpoint_here(self, event=None):
198 text = self.text
199 filename = self.io.filename
205 self.breakpoints.remove(lineno)
211 debug = self.flist.pyshell.interp.debugger
216 def clear_file_breaks(self):
217 if self.breakpoints:
218 text = self.text
219 filename = self.io.filename
223 self.breakpoints = []
226 debug = self.flist.pyshell.interp.debugger
231 def store_file_breaks(self):
245 # run, and since self.breakpoints (from which the subprocess
249 breaks = self.breakpoints
250 filename = self.io.filename
252 with open(self.breakpointPath) as fp:
257 with open(self.breakpointPath, "w") as new_file:
261 self.update_breakpoints()
262 breaks = self.breakpoints
266 if not getattr(self.root, "breakpoint_error_displayed", False):
267 self.root.breakpoint_error_displayed = True
271 parent=self.text)
273 def restore_file_breaks(self):
274 self.text.update() # this enables setting "BREAK" tags to be visible
275 if self.io is None:
278 filename = self.io.filename
281 if os.path.isfile(self.breakpointPath):
282 with open(self.breakpointPath) as fp:
288 self.set_breakpoint(breakpoint_linenumber)
290 def update_breakpoints(self):
292 text = self.text
294 linenumber_list = self.ranges_to_linenumbers(ranges)
295 self.breakpoints = linenumber_list
297 def ranges_to_linenumbers(self, ranges):
308 # def saved_change_hook(self):
310 # if not self.get_saved():
311 # self.clear_file_breaks()
312 # EditorWindow.saved_change_hook(self)
314 def _close(self):
316 self.clear_file_breaks()
317 EditorWindow._close(self)
329 def open_shell(self, event=None):
330 if self.pyshell:
331 self.pyshell.top.wakeup()
333 self.pyshell = PyShell(self)
334 if self.pyshell:
335 if not self.pyshell.begin():
337 return self.pyshell
342 def recolorize_main(self):
343 self.tag_remove("TODO", "1.0", "iomark")
344 self.tag_add("SYNC", "1.0", "iomark")
345 ColorDelegator.recolorize_main(self)
347 def removecolors(self):
349 for tag in self.tagdefs:
350 self.tag_remove(tag, "iomark", "end")
355 def insert(self, index, chars, tags=None):
357 if self.delegate.compare(index, "<", "iomark"):
358 self.delegate.bell()
362 UndoDelegator.insert(self, index, chars, tags)
364 def delete(self, index1, index2=None):
366 if self.delegate.compare(index1, "<", "iomark"):
367 self.delegate.bell()
371 UndoDelegator.delete(self, index1, index2)
373 def undo_event(self, event):
378 orig_insert = self.delegate.insert
379 self.delegate.insert = \
384 self.delegate.insert = orig_insert
389 def insert(self, index, chars, tags=None):
392 self.delegate.insert(index, chars, tags)
397 def handle_EOF(self):
417 def __init__(self, tkconsole):
418 self.tkconsole = tkconsole
420 InteractiveInterpreter.__init__(self, locals=locals)
421 self.restarting = False
422 self.subprocess_arglist = None
423 self.port = PORT
424 self.original_compiler_flags = self.compile.compiler.flags
430 def spawn_subprocess(self):
431 if self.subprocess_arglist is None:
432 self.subprocess_arglist = self.build_subprocess_arglist()
433 self.rpcsubproc = subprocess.Popen(self.subprocess_arglist)
435 def build_subprocess_arglist(self):
436 assert (self.port!=0), (
445 return [sys.executable] + w + ["-c", command, str(self.port)]
447 def start_subprocess(self):
448 addr = (HOST, self.port)
453 self.rpcclt = MyRPCClient(addr)
458 self.display_port_binding_error()
461 self.port = self.rpcclt.listening_sock.getsockname()[1]
468 self.rpcclt.listening_sock.setsockopt(socket.SOL_SOCKET,
470 self.spawn_subprocess()
473 self.rpcclt.listening_sock.settimeout(10)
475 self.rpcclt.accept()
477 self.display_no_subprocess_error()
479 self.rpcclt.register("console", self.tkconsole)
480 self.rpcclt.register("stdin", self.tkconsole.stdin)
481 self.rpcclt.register("stdout", self.tkconsole.stdout)
482 self.rpcclt.register("stderr", self.tkconsole.stderr)
483 self.rpcclt.register("flist", self.tkconsole.flist)
484 self.rpcclt.register("linecache", linecache)
485 self.rpcclt.register("interp", self)
486 self.transfer_path(with_cwd=True)
487 self.poll_subprocess()
488 return self.rpcclt
490 def restart_subprocess(self, with_cwd=False, filename=''):
491 if self.restarting:
492 return self.rpcclt
493 self.restarting = True
495 debug = self.getdebugger()
499 debugger_r.close_subprocess_debugger(self.rpcclt)
503 self.rpcclt.close()
504 self.terminate_subprocess()
505 console = self.tkconsole
508 self.spawn_subprocess()
510 self.rpcclt.accept()
512 self.display_no_subprocess_error()
514 self.transfer_path(with_cwd=with_cwd)
527 debugger_r.restart_subprocess_debugger(self.rpcclt)
530 self.compile.compiler.flags = self.original_compiler_flags
531 self.restarting = False
532 return self.rpcclt
534 def __request_interrupt(self):
535 self.rpcclt.remotecall("exec", "interrupt_the_server", (), {})
537 def interrupt_subprocess(self):
538 threading.Thread(target=self.__request_interrupt).start()
540 def kill_subprocess(self):
541 if self._afterid is not None:
542 self.tkconsole.text.after_cancel(self._afterid)
544 self.rpcclt.listening_sock.close()
548 self.rpcclt.close()
551 self.terminate_subprocess()
552 self.tkconsole.executing = False
553 self.rpcclt = None
555 def terminate_subprocess(self):
558 self.rpcsubproc.kill()
564 self.rpcsubproc.wait()
568 def transfer_path(self, with_cwd=False):
575 self.runcommand("""if 1:
583 def poll_subprocess(self):
584 clt = self.rpcclt
588 response = clt.pollresponse(self.active_seq, wait=0.05)
592 if self.tkconsole.closing:
595 self.restart_subprocess()
597 self.tkconsole.resetoutput()
598 self.active_seq = None
600 console = self.tkconsole.console
605 if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):
606 self.remote_stack_viewer()
613 self.tkconsole.endexecuting()
617 if not self.tkconsole.closing:
618 self._afterid = self.tkconsole.text.after(
619 self.tkconsole.pollinterval, self.poll_subprocess)
623 def setdebugger(self, debugger):
624 self.debugger = debugger
626 def getdebugger(self):
627 return self.debugger
629 def open_remote_stack_viewer(self):
639 self.tkconsole.text.after(300, self.remote_stack_viewer)
642 def remote_stack_viewer(self):
644 oid = self.rpcclt.remotequeue("exec", "stackviewer", ("flist",), {})
646 self.tkconsole.root.bell()
648 item = debugobj_r.StubObjectTreeItem(self.rpcclt, oid)
650 top = Toplevel(self.tkconsole.root)
661 def execsource(self, source):
663 filename = self.stuffsource(source)
664 self.execfile(filename, source)
666 def execfile(self, filename, source=None):
677 self.tkconsole.resetoutput()
680 file=self.tkconsole.stderr)
681 InteractiveInterpreter.showsyntaxerror(self, filename)
682 self.tkconsole.showprompt()
684 self.runcode(code)
686 def runsource(self, source):
688 filename = self.stuffsource(source)
693 return InteractiveInterpreter.runsource(self, source, filename)
695 def stuffsource(self, source):
697 filename = "<pyshell#%d>" % self.gid
698 self.gid = self.gid + 1
703 def prepend_syspath(self, filename):
705 self.runcommand("""if 1:
715 def showsyntaxerror(self, filename=None):
722 tkconsole = self.tkconsole
738 self.write("SyntaxError: %s\n" % msg)
741 def showtraceback(self):
743 self.tkconsole.resetoutput()
744 self.checklinecache()
745 InteractiveInterpreter.showtraceback(self)
746 if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):
747 self.tkconsole.open_stack_viewer()
749 def checklinecache(self):
755 def runcommand(self, code):
758 if self.tkconsole.executing:
759 self.display_executing_dialog()
761 if self.rpcclt:
762 self.rpcclt.remotequeue("exec", "runcode", (code,), {})
764 exec(code, self.locals)
767 def runcode(self, code):
769 if self.tkconsole.executing:
770 self.restart_subprocess()
771 self.checklinecache()
772 debugger = self.debugger
774 self.tkconsole.beginexecuting()
775 if not debugger and self.rpcclt is not None:
776 self.active_seq = self.rpcclt.asyncqueue("exec", "runcode",
779 debugger.run(code, self.locals)
781 exec(code, self.locals)
783 if not self.tkconsole.closing:
788 parent=self.tkconsole.text):
791 self.showtraceback()
797 file=self.tkconsole.stderr)
798 self.showtraceback()
799 self.tkconsole.endexecuting()
801 if self.tkconsole.canceled:
802 self.tkconsole.canceled = False
803 print("KeyboardInterrupt", file=self.tkconsole.stderr)
805 self.showtraceback()
809 self.tkconsole.endexecuting()
813 def write(self, s):
815 return self.tkconsole.stderr.write(s)
817 def display_port_binding_error(self):
826 parent=self.tkconsole.text)
828 def display_no_subprocess_error(self):
834 parent=self.tkconsole.text)
836 def display_executing_dialog(self):
841 parent=self.tkconsole.text)
882 def __init__(self, flist=None):
884 ms = self.menu_specs
887 self.interp = ModifiedInterpreter(self)
894 self.shell_sidebar = None # initialized below
896 OutputWindow.__init__(self, flist, None, None)
898 self.usetabs = False
900 self.indentwidth = 4
902 self.sys_ps1 = sys.ps1 if hasattr(sys, 'ps1') else '>>>\n'
903 self.prompt_last_line = self.sys_ps1.split('\n')[-1]
904 self.prompt = self.sys_ps1 # Changes when debug active
906 text = self.text
908 text.bind("<<newline-and-indent>>", self.enter_callback)
909 text.bind("<<plain-newline-and-indent>>", self.linefeed_callback)
910 text.bind("<<interrupt-execution>>", self.cancel_callback)
911 text.bind("<<end-of-file>>", self.eof_callback)
912 text.bind("<<open-stack-viewer>>", self.open_stack_viewer)
913 text.bind("<<toggle-debugger>>", self.toggle_debugger)
914 text.bind("<<toggle-jit-stack-viewer>>", self.toggle_jit_stack_viewer)
915 text.bind("<<copy-with-prompts>>", self.copy_with_prompts_callback)
917 text.bind("<<view-restart>>", self.view_restart_mark)
918 text.bind("<<restart-shell>>", self.restart_shell)
919 self.squeezer = self.Squeezer(self)
921 self.squeeze_current_text_event)
923 self.save_stdout = sys.stdout
924 self.save_stderr = sys.stderr
925 self.save_stdin = sys.stdin
927 self.stdin = StdInputFile(self, "stdin",
929 self.stdout = StdOutputFile(self, "stdout",
931 self.stderr = StdOutputFile(self, "stderr",
933 self.console = StdOutputFile(self, "console",
936 sys.stdout = self.stdout
937 sys.stderr = self.stderr
938 sys.stdin = self.stdin
948 self.history = self.History(self.text)
950 self.pollinterval = 50 # millisec
952 self.shell_sidebar = self.ShellSidebar(self)
957 self.text.insert = self.per.top.insert
958 self.per.insertfilter(UserInputTaggingDelegator())
960 def ResetFont(self):
963 if self.shell_sidebar is not None:
964 self.shell_sidebar.update_font()
966 def ResetColorizer(self):
977 self.text.tag_configure(tag, **tag_colors_config)
979 if self.shell_sidebar is not None:
980 self.shell_sidebar.update_colors()
982 def replace_event(self, event):
983 replace.replace(self.text, insert_tags="stdin")
986 def get_standard_extension_names(self):
989 def get_prompt_text(self, first, last):
991 text = self.text.get(first, last)
997 self.shell_sidebar.line_prompts.get(lineno)
1006 def copy_with_prompts_callback(self, event=None):
1015 text = self.text
1023 prompt_text = self.get_prompt_text(selfirst, sellast)
1033 def set_warning_stream(self, stream):
1037 def get_warning_stream(self):
1040 def toggle_debugger(self, event=None):
1041 if self.executing:
1044 parent=self.text)
1045 self.set_debugger_indicator()
1048 db = self.interp.getdebugger()
1050 self.close_debugger()
1052 self.open_debugger()
1054 def set_debugger_indicator(self):
1055 db = self.interp.getdebugger()
1056 self.setvar("<<toggle-debugger>>", not not db)
1058 def toggle_jit_stack_viewer(self, event=None):
1061 def close_debugger(self):
1062 db = self.interp.getdebugger()
1064 self.interp.setdebugger(None)
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()
1074 def open_debugger(self):
1075 if self.interp.rpcclt:
1076 dbg_gui = debugger_r.start_remote_debugger(self.interp.rpcclt,
1077 self)
1079 dbg_gui = debugger.Debugger(self)
1080 self.interp.setdebugger(dbg_gui)
1082 self.prompt = "[DEBUG ON]\n" + self.sys_ps1
1083 self.showprompt()
1084 self.set_debugger_indicator()
1086 def debug_menu_postcommand(self):
1087 state = 'disabled' if self.executing else 'normal'
1088 self.update_menu_state('debug', '*tack*iewer', state)
1090 def beginexecuting(self):
1092 self.resetoutput()
1093 self.executing = True
1095 def endexecuting(self):
1097 self.executing = False
1098 self.canceled = False
1099 self.showprompt()
1101 def close(self):
1103 if self.executing:
1108 parent=self.text)
1111 self.stop_readline()
1112 self.canceled = True
1113 self.closing = True
1114 return EditorWindow.close(self)
1116 def _close(self):
1118 self.close_debugger()
1120 self.interp.kill_subprocess()
1122 sys.stdout = self.save_stdout
1123 sys.stderr = self.save_stderr
1124 sys.stdin = self.save_stdin
1126 self.interp = None
1127 self.console = None
1128 self.flist.pyshell = None
1129 self.history = None
1130 EditorWindow._close(self)
1132 def ispythonsource(self, filename):
1136 def short_title(self):
1137 return self.shell_title
1142 def begin(self):
1143 self.text.mark_set("iomark", "insert")
1144 self.resetoutput()
1147 client = self.interp.start_subprocess()
1149 self.close()
1158 self.write("Python %s on %s\n%s\n%s" %
1159 (sys.version, sys.platform, self.COPYRIGHT, nosub))
1160 self.text.focus_force()
1161 self.showprompt()
1168 def stop_readline(self):
1169 if not self.reading: # no nested mainloop to exit.
1171 self._stop_readline_flag = True
1172 self.top.quit()
1174 def readline(self):
1175 save = self.reading
1177 self.reading = True
1178 self.top.mainloop() # nested mainloop()
1180 self.reading = save
1181 if self._stop_readline_flag:
1182 self._stop_readline_flag = False
1184 line = self.text.get("iomark", "end-1c")
1187 self.resetoutput()
1188 if self.canceled:
1189 self.canceled = False
1192 if self.endoffile:
1193 self.endoffile = False
1197 def isatty(self):
1200 def cancel_callback(self, event=None):
1202 if self.text.compare("sel.first", "!=", "sel.last"):
1206 if not (self.executing or self.reading):
1207 self.resetoutput()
1208 self.interp.write("KeyboardInterrupt\n")
1209 self.showprompt()
1211 self.endoffile = False
1212 self.canceled = True
1213 if (self.executing and self.interp.rpcclt):
1214 if self.interp.getdebugger():
1215 self.interp.restart_subprocess()
1217 self.interp.interrupt_subprocess()
1218 if self.reading:
1219 self.top.quit() # exit the nested mainloop() in readline()
1222 def eof_callback(self, event):
1223 if self.executing and not self.reading:
1225 if not (self.text.compare("iomark", "==", "insert") and
1226 self.text.compare("insert", "==", "end-1c")):
1228 if not self.executing:
1229 self.resetoutput()
1230 self.close()
1232 self.canceled = False
1233 self.endoffile = True
1234 self.top.quit()
1237 def linefeed_callback(self, event):
1239 if self.reading:
1240 self.text.insert("insert", "\n")
1241 self.text.see("insert")
1243 self.newline_and_indent_event(event)
1246 def enter_callback(self, event):
1247 if self.executing and not self.reading:
1252 sel = self.text.get("sel.first", "sel.last")
1254 if self.text.compare("sel.last", "<=", "iomark"):
1255 self.recall(sel, event)
1262 if self.text.compare("insert", "<", "iomark linestart"):
1267 prev = self.text.tag_prevrange("stdin", "insert")
1270 self.text.compare("insert", "<", prev[1]) and
1272 "console" not in self.text.tag_names("insert")
1274 prev_cons = self.text.tag_prevrange("console", "insert")
1275 if prev_cons and self.text.compare(prev_cons[1], ">=", prev[0]):
1277 next_cons = self.text.tag_nextrange("console", "insert")
1278 if next_cons and self.text.compare(next_cons[0], "<", prev[1]):
1279 prev = (prev[0], self.text.index(next_cons[0] + "+1c"))
1280 self.recall(self.text.get(prev[0], prev[1]), event)
1282 next = self.text.tag_nextrange("stdin", "insert")
1283 if next and self.text.compare("insert lineend", ">=", next[0]):
1284 next_cons = self.text.tag_nextrange("console", "insert lineend")
1285 if next_cons and self.text.compare(next_cons[0], "<", next[1]):
1286 next = (next[0], self.text.index(next_cons[0] + "+1c"))
1287 self.recall(self.text.get(next[0], next[1]), event)
1290 indices = self.text.tag_nextrange("console", "insert linestart")
1292 self.text.compare(indices[0], "<=", "insert linestart"):
1293 self.recall(self.text.get(indices[1], "insert lineend"), event)
1295 self.recall(self.text.get("insert linestart", "insert lineend"), event)
1299 if self.text.compare("insert", "<", "iomark"):
1300 self.text.mark_set("insert", "iomark")
1303 s = self.text.get("insert", "end-1c")
1305 self.text.delete("insert", "end-1c")
1308 if self.text.compare("insert", "<", "end-1c linestart"):
1309 self.newline_and_indent_event(event)
1312 self.text.mark_set("insert", "end-1c")
1313 if self.reading:
1314 self.text.insert("insert", "\n")
1315 self.text.see("insert")
1317 self.newline_and_indent_event(event)
1318 self.text.update_idletasks()
1319 if self.reading:
1320 self.top.quit() # Break out of recursive mainloop()
1322 self.runit()
1325 def recall(self, s, event):
1330 self.text.undo_block_start()
1332 self.text.tag_remove("sel", "1.0", "end")
1333 self.text.mark_set("insert", "end-1c")
1334 prefix = self.text.get("insert linestart", "insert")
1336 self.newline_and_indent_event(event)
1337 prefix = self.text.get("insert linestart", "insert")
1338 self.text.insert("insert", lines[0].strip(),
1339 self.user_input_insert_tags)
1347 self.text.insert('insert', '\n' + line.rstrip(),
1348 self.user_input_insert_tags)
1350 self.text.see("insert")
1351 self.text.undo_block_stop()
1354 def runit(self):
1355 index_before = self.text.index("end-2c")
1356 line = self.text.get("iomark", "end-1c")
1359 line = self._last_newline_re.sub("", line)
1360 input_is_complete = self.interp.runsource(line)
1362 if self.text.get(index_before) == '\n':
1363 self.text.tag_remove(self.user_input_insert_tags, index_before)
1364 self.shell_sidebar.update_sidebar()
1366 def open_stack_viewer(self, event=None):
1367 if self.interp.rpcclt:
1368 return self.interp.remote_stack_viewer()
1375 parent=self.text)
1378 StackBrowser(self.root, self.flist)
1380 def view_restart_mark(self, event=None):
1381 self.text.see("iomark")
1382 self.text.see("restart")
1384 def restart_shell(self, event=None):
1386 self.interp.restart_subprocess(with_cwd=True)
1388 def showprompt(self):
1389 self.resetoutput()
1391 prompt = self.prompt
1392 if self.sys_ps1 and prompt.endswith(self.sys_ps1):
1393 prompt = prompt[:-len(self.sys_ps1)]
1394 self.text.tag_add("console", "iomark-1c")
1395 self.console.write(prompt)
1397 self.shell_sidebar.update_sidebar()
1398 self.text.mark_set("insert", "end-1c")
1399 self.set_line_and_column()
1400 self.io.reset_undo()
1402 def show_warning(self, msg):
1403 width = self.interp.tkconsole.width
1408 self.per.bottom.insert("iomark linestart", wrapped_msg, "stderr")
1410 def resetoutput(self):
1411 source = self.text.get("iomark", "end-1c")
1412 if self.history:
1413 self.history.store(source)
1414 if self.text.get("end-2c") != "\n":
1415 self.text.insert("end-1c", "\n")
1416 self.text.mark_set("iomark", "end-1c")
1417 self.set_line_and_column()
1418 self.ctip.remove_calltip_window()
1420 def write(self, s, tags=()):
1422 self.text.mark_gravity("iomark", "right")
1423 count = OutputWindow.write(self, s, tags, "iomark")
1424 self.text.mark_gravity("iomark", "left")
1428 if self.canceled:
1429 self.canceled = False
1434 def rmenu_check_cut(self):
1436 if self.text.compare('sel.first', '<', 'iomark'):
1442 def rmenu_check_paste(self):
1443 if self.text.compare('insert','<','iomark'):
1447 def squeeze_current_text_event(self, event=None):
1448 self.squeezer.squeeze_current_text()
1449 self.shell_sidebar.update_sidebar()
1451 def on_squeezed_expand(self, index, text, tags):
1452 self.shell_sidebar.update_sidebar()