"""The stdin object user code will reference

def __init__(self, coderunner, repl, configured_edit_keys=None):

self.coderunner = coderunner

self.repl = repl

self.has_focus = False # whether FakeStdin receives keypress events

self.current_line = ''

self.cursor_offset = 0

self.old_num_lines = 0

self.readline_results = []

if configured_edit_keys:

self.rl_char_sequences = configured_edit_keys

else:

self.rl_char_sequences = edit_keys

def process_event(self, e):

assert self.has_focus

logger.debug('fake input processing event %r', e)

if isinstance(e, events.PasteEvent):

for ee in e.events:

if ee not in self.rl_char_sequences:

self.add_input_character(ee)

elif e in self.rl_char_sequences:

self.cursor_offset, self.current_line = self.rl_char_sequences[e](

self.cursor_offset, self.current_line)

elif isinstance(e, events.SigIntEvent):

self.coderunner.sigint_happened_in_main_greenlet = True

self.has_focus = False

self.current_line = ''

self.cursor_offset = 0

self.repl.run_code_and_maybe_finish()

elif e in ("<Esc+.>",):

self.get_last_word()

elif e in ["<ESC>"]:

pass

elif e in ['<Ctrl-d>']:

if self.current_line == '':

self.repl.send_to_stdin('\n')

self.has_focus = False

self.current_line = ''

self.cursor_offset = 0

self.repl.run_code_and_maybe_finish(for_code='')

else:

pass

elif e in ["\n", "\r", "<Ctrl-j>", "<Ctrl-m>"]:

line = self.current_line

self.repl.send_to_stdin(line + '\n')

self.has_focus = False

self.current_line = ''

self.cursor_offset = 0

self.repl.run_code_and_maybe_finish(for_code=line+'\n')

else: # add normal character

self.add_input_character(e)

if self.current_line.endswith(("\n", "\r")):

pass

else:

self.repl.send_to_stdin(self.current_line)

def add_input_character(self, e):

if e == '<SPACE>':

e = ' '

if e.startswith('<') and e.endswith('>'):

return

assert len(e) == 1, 'added multiple characters: %r' % e

logger.debug('adding normal char %r to current line', e)

c = e if py3 else e.encode('utf8')

self.current_line = (self.current_line[:self.cursor_offset] +

c +

self.current_line[self.cursor_offset:])

self.cursor_offset += 1

def readline(self):

self.has_focus = True

self.repl.send_to_stdin(self.current_line)

value = self.coderunner.request_from_main_greenlet()

self.readline_results.append(value)

return value

def readlines(self, size=-1):

return list(iter(self.readline, ''))

def __iter__(self):

return iter(self.readlines())

def isatty(self):

return True

def flush(self):

"""Flush the internal buffer. This is a no-op. Flushing stdin

def write(self, value):

# XXX IPython expects sys.stdin.write to exist, there will no doubt be

# others, so here's a hack to keep them happy

raise IOError(errno.EBADF, "sys.stdin is read-only")

@property

def encoding(self):

return 'UTF8'

"""Stdin mock used during reevaluation (undo) so raw_inputs don't have to

def __init__(self, fakestdin, repl):

self.fakestdin = fakestdin

self.repl = repl

self.readline_results = fakestdin.readline_results[:]

def readline(self):

if self.readline_results:

value = self.readline_results.pop(0)

else:

value = 'no saved input available'

self.repl.send_to_stdout(value)

def __init__(self, watcher, loader):

self.watcher = watcher

self.loader = loader

def load_module(self, name):

module = self.loader.load_module(name)

if hasattr(module, '__file__'):

self.watcher.track_module(module.__file__)

def __init__(self, watcher, *args):

self.watcher = watcher

pkgutil.ImpLoader.__init__(self, *args)

def load_module(self, name):

module = pkgutil.ImpLoader.load_module(self, name)

if hasattr(module, '__file__'):

self.watcher.track_module(module.__file__)

def __init__(self, watcher, old_meta_path):

self.watcher = watcher

self.old_meta_path = old_meta_path

def find_module(self, fullname, path=None):

for finder in self.old_meta_path:

loader = finder.find_module(fullname, path)

if loader is not None:

return ImportLoader(self.watcher, loader)

if not py3:

# Python 2 does not have the default finders stored in

# sys.meta_path. Use imp to perform the actual importing.

try:

result = imp.find_module(fullname, path)

return ImpImportLoader(self.watcher, fullname, *result)

except ImportError:

return None

"""Python Repl

def __init__(self,

locals_=None,

config=None,

request_refresh=lambda: None,

schedule_refresh=lambda when=0: None,

request_reload=lambda desc: None,

request_undo=lambda n=1: None,

get_term_hw=lambda: (50, 10),

get_cursor_vertical_diff=lambda: 0,

banner=None,

interp=None,

interactive=True,

orig_tcattrs=None,

on_suspend=lambda *args: None,

after_suspend=lambda *args: None):

"""

logger.debug("starting init")

if config is None:

config = Struct()

loadini(config, default_config_path())

# If creating a new interpreter on undo would be unsafe because initial

# state was passed in

self.weak_rewind = bool(locals_ or interp)

if interp is None:

interp = Interp(locals=locals_)

interp.write = self.send_to_stderr

if banner is None:

if config.help_key:

banner = ' '.join((_('Welcome to bpython!'),

_('Press <%s> for help.') % config.help_key))

else:

banner = None

# only one implemented currently

config.autocomplete_mode = autocomplete.SIMPLE

if config.cli_suggestion_width <= 0 or config.cli_suggestion_width > 1:

config.cli_suggestion_width = 1

self.reevaluating = False

self.fake_refresh_requested = False

def smarter_request_refresh():

if self.reevaluating or self.paste_mode:

self.fake_refresh_requested = True

else:

request_refresh()

self.request_refresh = smarter_request_refresh

def smarter_schedule_refresh(when='now'):

if self.reevaluating or self.paste_mode:

self.fake_refresh_requested = True

else:

schedule_refresh(when=when)

self.schedule_refresh = smarter_schedule_refresh

def smarter_request_reload(files_modified=()):

if self.watching_files:

request_reload(files_modified=files_modified)

self.request_reload = smarter_request_reload

self.request_undo = request_undo

self.get_term_hw = get_term_hw

self.get_cursor_vertical_diff = get_cursor_vertical_diff

self.status_bar = StatusBar('',

request_refresh=self.request_refresh,

schedule_refresh=self.schedule_refresh)

self.edit_keys = edit_keys.mapping_with_config(config, key_dispatch)

logger.debug("starting parent init")

super(Repl, self).__init__(interp, config)

self.formatter = BPythonFormatter(config.color_scheme)

# overwriting what bpython.Repl put there

# interact is called to interact with the status bar,

# so we're just using the same object

self.interact = self.status_bar

# line currently being edited, without ps1 (usually '>>> ')

self._current_line = ''

# current line of output - stdout and stdin go here

self.current_stdouterr_line = ''

# lines separated whenever logical line

# length goes over what the terminal width

# was at the time of original output

self.display_lines = []

# this is every line that's been executed; it gets smaller on rewind

self.history = []

# formatted version of lines in the buffer kept around so we can

# unhighlight parens using self.reprint_line as called by bpython.Repl

self.display_buffer = []

# how many times display has been scrolled down

# because there wasn't room to display everything

self.scroll_offset = 0

# from the left, 0 means first char

self._cursor_offset = 0

self.orig_tcattrs = orig_tcattrs

self.on_suspend = on_suspend

self.after_suspend = after_suspend

self.coderunner = CodeRunner(self.interp, self.request_refresh)

self.stdout = FakeOutput(self.coderunner, self.send_to_stdout)

self.stderr = FakeOutput(self.coderunner, self.send_to_stderr)

self.stdin = FakeStdin(self.coderunner, self, self.edit_keys)

# next paint should clear screen

self.request_paint_to_clear_screen = False

# offscreen command yields results different from scrollback bufffer

self.inconsistent_history = False

# history error message has already been displayed

self.history_already_messed_up = False

# some commands act differently based on the prev event

# this list doesn't include instances of event.Event,

# only keypress-type events (no refresh screen events etc.)

self.last_events = [None] * 50

# displays prev events in a column on the right hand side

self.presentation_mode = False

self.paste_mode = False

self.current_match = None

self.list_win_visible = False

self.watching_files = False # whether auto reloading active

# 'reverse_incremental_search', 'incremental_search' or None

self.incremental_search_mode = None

self.incremental_search_target = ''

self.original_modules = sys.modules.keys()

self.width = None

self.height = None

self.status_bar.message(banner)

self.watcher = ModuleChangedEventHandler([], smarter_request_reload)

def __enter__(self):

self.orig_stdout = sys.stdout

self.orig_stderr = sys.stderr

self.orig_stdin = sys.stdin

sys.stdout = self.stdout

sys.stderr = self.stderr

sys.stdin = self.stdin

self.orig_sigwinch_handler = signal.getsignal(signal.SIGWINCH)

self.orig_sigtstp_handler = signal.getsignal(signal.SIGTSTP)

signal.signal(signal.SIGWINCH, self.sigwinch_handler)

signal.signal(signal.SIGTSTP, self.sigtstp_handler)

self.orig_meta_path = sys.meta_path

if self.watcher:

sys.meta_path = [ImportFinder(self.watcher, self.orig_meta_path)]

sitefix.monkeypatch_quit()

return self

def __exit__(self, *args):

sys.stdin = self.orig_stdin

sys.stdout = self.orig_stdout

sys.stderr = self.orig_stderr

signal.signal(signal.SIGWINCH, self.orig_sigwinch_handler)

signal.signal(signal.SIGTSTP, self.orig_sigtstp_handler)

sys.meta_path = self.orig_meta_path

def sigwinch_handler(self, signum, frame):

old_rows, old_columns = self.height, self.width

self.height, self.width = self.get_term_hw()

cursor_dy = self.get_cursor_vertical_diff()

self.scroll_offset -= cursor_dy

logger.info('sigwinch! Changed from %r to %r', (old_rows, old_columns),

(self.height, self.width))

logger.info('decreasing scroll offset by %d to %d', cursor_dy,

self.scroll_offset)

def sigtstp_handler(self, signum, frame):

self.scroll_offset = len(self.lines_for_display)

self.__exit__()

self.on_suspend()

os.kill(os.getpid(), signal.SIGTSTP)

self.after_suspend()

self.__enter__()

def clean_up_current_line_for_exit(self):

"""Called when trying to exit to prep for final paint"""

logger.debug('unhighlighting paren for exit')

self.cursor_offset = -1

self.unhighlight_paren()

# Event handling

def process_event(self, e):

"""Returns True if shutting down, otherwise returns None.

logger.debug("processing event %r", e)

if isinstance(e, events.Event):

return self.process_control_event(e)

else:

self.last_events.append(e)

self.last_events.pop(0)

return self.process_key_event(e)

def process_control_event(self, e):

if isinstance(e, bpythonevents.ScheduledRefreshRequestEvent):

# This is a scheduled refresh - it's really just a refresh (so nop)

pass

elif isinstance(e, bpythonevents.RefreshRequestEvent):

logger.info('received ASAP refresh request event')

if self.status_bar.has_focus:

self.status_bar.process_event(e)

else:

assert self.coderunner.code_is_waiting

self.run_code_and_maybe_finish()

elif self.status_bar.has_focus:

return self.status_bar.process_event(e)

# handles paste events for both stdin and repl

elif isinstance(e, events.PasteEvent):

ctrl_char = compress_paste_event(e)

if ctrl_char is not None:

return self.process_event(ctrl_char)

simple_events = just_simple_events(e.events)

source = preprocess(''.join(simple_events),

self.interp.compile)

with self.in_paste_mode():

for ee in source:

if self.stdin.has_focus:

self.stdin.process_event(ee)

else:

self.process_simple_keypress(ee)

elif isinstance(e, bpythonevents.RunStartupFileEvent):

try:

self.startup()

except IOError as e:

self.status_bar.message(

_('Executing PYTHONSTARTUP failed: %s') % (e, ))

elif isinstance(e, bpythonevents.UndoEvent):

self.undo(n=e.n)

elif self.stdin.has_focus:

return self.stdin.process_event(e)

elif isinstance(e, events.SigIntEvent):

logger.debug('received sigint event')

self.keyboard_interrupt()

return

elif isinstance(e, bpythonevents.ReloadEvent):

if self.watching_files:

self.clear_modules_and_reevaluate()

self.status_bar.message(

_('Reloaded at %s because %s modified.') % (

time.strftime('%X'),

' & '.join(e.files_modified)))

else:

raise ValueError("Don't know how to handle event type: %r" % e)

def process_key_event(self, e):

# To find the curtsies name for a keypress, try

# python -m curtsies.events

if self.status_bar.has_focus:

return self.status_bar.process_event(e)

if self.stdin.has_focus:

return self.stdin.process_event(e)

if (e in (key_dispatch[self.config.right_key] +

key_dispatch[self.config.end_of_line_key] +

("<RIGHT>",))

and self.config.curtsies_right_arrow_completion

and self.cursor_offset == len(self.current_line)):

self.current_line += self.current_suggestion

self.cursor_offset = len(self.current_line)

elif e in ("<UP>",) + key_dispatch[self.config.up_one_line_key]:

self.up_one_line()

elif e in ("<DOWN>",) + key_dispatch[self.config.down_one_line_key]:

self.down_one_line()

elif e in ("<Ctrl-d>",):

self.on_control_d()

elif e in ("<Esc+.>",):

self.get_last_word()

elif e in key_dispatch[self.config.reverse_incremental_search_key]:

self.incremental_search(reverse=True)

elif e in key_dispatch[self.config.incremental_search_key]:

self.incremental_search()

elif (e in ("<BACKSPACE>",) + key_dispatch[self.config.backspace_key]

and self.incremental_search_mode):

self.add_to_incremental_search(self, backspace=True)

elif e in self.edit_keys.cut_buffer_edits:

self.readline_kill(e)

elif e in self.edit_keys.simple_edits:

self.cursor_offset, self.current_line = self.edit_keys.call(

e,

cursor_offset=self.cursor_offset,

line=self.current_line,

cut_buffer=self.cut_buffer)

elif e in key_dispatch[self.config.cut_to_buffer_key]:

self.cut_to_buffer()

elif e in key_dispatch[self.config.reimport_key]:

self.clear_modules_and_reevaluate()

elif e in key_dispatch[self.config.toggle_file_watch_key]:

return self.toggle_file_watch()

elif e in key_dispatch[self.config.debug_key]:

self.toggle_auto_debug()

elif e in key_dispatch[self.config.clear_screen_key]:

self.request_paint_to_clear_screen = True

elif e in key_dispatch[self.config.show_source_key]:

self.show_source()

elif e in key_dispatch[self.config.help_key]:

self.pager(self.help_text())

elif e in key_dispatch[self.config.exit_key]:

raise SystemExit()

elif e in ("\n", "\r", "<PADENTER>", "<Ctrl-j>", "<Ctrl-m>"):

self.on_enter()

elif e == '<TAB>': # tab

self.on_tab()

elif e in ("<Shift-TAB>",):

self.on_tab(back=True)

elif e in key_dispatch[self.config.undo_key]: # ctrl-r for undo

self.prompt_undo()

elif e in key_dispatch[self.config.save_key]: # ctrl-s for save

greenlet.greenlet(self.write2file).switch()

elif e in key_dispatch[self.config.pastebin_key]: # F8 for pastebin

greenlet.greenlet(self.pastebin).switch()

elif e in key_dispatch[self.config.copy_clipboard_key]:

greenlet.greenlet(self.copy2clipboard).switch()

elif e in key_dispatch[self.config.external_editor_key]:

self.send_session_to_external_editor()

elif e in key_dispatch[self.config.edit_config_key]:

greenlet.greenlet(self.edit_config).switch()

# TODO add PAD keys hack as in bpython.cli

elif e in key_dispatch[self.config.edit_current_block_key]:

self.send_current_block_to_external_editor()

elif e in ["<ESC>"]:

self.incremental_search_mode = None

elif e in ["<SPACE>"]:

self.add_normal_character(' ')

else:

self.add_normal_character(e)

def get_last_word(self):

previous_word = _last_word(self.rl_history.entry)

word = _last_word(self.rl_history.back())

line = self.current_line

self._set_current_line(line[:len(line) - len(previous_word)] + word,

reset_rl_history=False)

self._set_cursor_offset(

self.cursor_offset-len(previous_word) + len(word),

reset_rl_history=False)

def incremental_search(self, reverse=False, include_current=False):

if self.incremental_search_mode is None:

self.rl_history.enter(self.current_line)

self.incremental_search_target = ''

else:

if self.incremental_search_target:

line = (self.rl_history.back(

False, search=True,

target=self.incremental_search_target,

include_current=include_current)

if reverse else

self.rl_history.forward(

False, search=True,

target=self.incremental_search_target,

include_current=include_current))

self._set_current_line(line,

reset_rl_history=False,

clear_special_mode=False)

self._set_cursor_offset(len(self.current_line),

reset_rl_history=False,

clear_special_mode=False)

if reverse:

self.incremental_search_mode = 'reverse_incremental_search'

else:

self.incremental_search_mode = 'incremental_search'

def readline_kill(self, e):

func = self.edit_keys[e]

self.cursor_offset, self.current_line, cut = func(self.cursor_offset,

self.current_line)

if self.last_events[-2] == e: # consecutive kill commands accumulative

if func.kills == 'ahead':

self.cut_buffer += cut

elif func.kills == 'behind':

self.cut_buffer = cut + self.cut_buffer

else:

raise ValueError("cut value other than 'ahead' or 'behind'")

else:

self.cut_buffer = cut

def on_enter(self, insert_into_history=True):

# so the cursor isn't touching a paren TODO: necessary?

self._set_cursor_offset(-1, update_completion=False)

self.history.append(self.current_line)

self.push(self.current_line, insert_into_history=insert_into_history)

def on_tab(self, back=False):

"""Do something on tab key

def only_whitespace_left_of_cursor():

"""returns true if all characters before cursor are whitespace"""

return not self.current_line[:self.cursor_offset].strip()

logger.debug('self.matches_iter.matches:%r', self.matches_iter.matches)

if only_whitespace_left_of_cursor():

front_ws = (len(self.current_line[:self.cursor_offset]) -

len(self.current_line[:self.cursor_offset].lstrip()))

to_add = 4 - (front_ws % self.config.tab_length)

for unused in range(to_add):

self.add_normal_character(' ')

return

# run complete() if we don't already have matches

if len(self.matches_iter.matches) == 0:

self.list_win_visible = self.complete(tab=True)

# 3. check to see if we can expand the current word

if self.matches_iter.is_cseq():

self._cursor_offset, self._current_line = self.matches_iter.substitute_cseq()

# using _current_line so we don't trigger a completion reset

if not self.matches_iter.matches:

self.list_win_visible = self.complete()

elif self.matches_iter.matches:

self.current_match = (back and self.matches_iter.previous()

or next(self.matches_iter))

self._cursor_offset, self._current_line = self.matches_iter.cur_line()

# using _current_line so we don't trigger a completion reset

self.list_win_visible = True

def on_control_d(self):

if self.current_line == '':

raise SystemExit()

else:

self.current_line = (self.current_line[:self.cursor_offset] +

self.current_line[self.cursor_offset+1:])

def cut_to_buffer(self):

self.cut_buffer = self.current_line[self.cursor_offset:]

self.current_line = self.current_line[:self.cursor_offset]

def yank_from_buffer(self):

pass

def up_one_line(self):

self.rl_history.enter(self.current_line)

self._set_current_line(tabs_to_spaces(self.rl_history.back(

False,

search=self.config.curtsies_right_arrow_completion)),

update_completion=False,

reset_rl_history=False)

self._set_cursor_offset(len(self.current_line), reset_rl_history=False)

def down_one_line(self):

self.rl_history.enter(self.current_line)

self._set_current_line(tabs_to_spaces(self.rl_history.forward(

False,

search=self.config.curtsies_right_arrow_completion)),

update_completion=False,

reset_rl_history=False)

self._set_cursor_offset(len(self.current_line), reset_rl_history=False)

def process_simple_keypress(self, e):

# '\n' needed for pastes

if e in ("<Ctrl-j>", "<Ctrl-m>", "<PADENTER>", "\n", "\r"):

self.on_enter()

while self.fake_refresh_requested:

self.fake_refresh_requested = False

self.process_event(bpythonevents.RefreshRequestEvent())

elif isinstance(e, events.Event):

pass # ignore events

elif e == '<SPACE>':

self.add_normal_character(' ')

else:

self.add_normal_character(e)

def send_current_block_to_external_editor(self, filename=None):

text = self.send_to_external_editor(self.get_current_block())

lines = [line for line in text.split('\n')]

while lines and not lines[-1].split():

lines.pop()

events = '\n'.join(lines + ([''] if len(lines) == 1 else ['', '']))

self.clear_current_block()

with self.in_paste_mode():

for e in events:

self.process_simple_keypress(e)

self.cursor_offset = len(self.current_line)

def send_session_to_external_editor(self, filename=None):

for_editor = ("### current bpython session - file will be "

"reevaluated, ### lines will not be run\n")

for_editor += '\n'.join(line[len(self.ps1):]

if line.startswith(self.ps1) else

line[len(self.ps2):]

if line.startswith(self.ps2) else

'### '+line

for line in self.getstdout().split('\n'))

text = self.send_to_external_editor(for_editor)

lines = text.split('\n')

from_editor = [line for line in lines if line[:4] != '### ']

source = preprocess('\n'.join(from_editor), self.interp.compile)

self.history = source.split('\n')

self.reevaluate(insert_into_history=True)

self.current_line = lines[-1][4:]

self.cursor_offset = len(self.current_line)

def clear_modules_and_reevaluate(self):

if self.watcher:

self.watcher.reset()

cursor, line = self.cursor_offset, self.current_line

for modname in sys.modules.keys():

if modname not in self.original_modules:

del sys.modules[modname]

self.reevaluate(insert_into_history=True)

self.cursor_offset, self.current_line = cursor, line

self.status_bar.message(_('Reloaded at %s by user.') %

(time.strftime('%X'), ))

def toggle_file_watch(self):

if self.watcher:

if self.watching_files:

msg = _("Auto-reloading deactivated.")

self.status_bar.message(msg)

self.watcher.deactivate()

self.watching_files = False

else:

msg = _("Auto-reloading active, watching for file changes...")

self.status_bar.message(msg)

self.watching_files = True

self.watcher.activate()

else:

self.status_bar.message(_('Auto-reloading not available because '

'watchdog not installed.'))

def toggle_auto_debug(self):

if debugger is None:

self.status_bar.message(

_('No debugger, check your PYTHON_DEBUGGER value.'))

return

if sys.excepthook is not debugger_hook:

self.status_bar.message(

_('Auto-debug activated'))

sys.excepthook = debugger_hook

else:

sys.excepthook = sys.__excepthook__

self.status_bar.message(

_('Auto-debug deactivated'))

# Handler Helpers

def add_normal_character(self, char):

if len(char) > 1 or is_nop(char):

return

if self.incremental_search_mode:

self.add_to_incremental_search(char)

else:

self._set_current_line((self.current_line[:self.cursor_offset] +

char +

self.current_line[self.cursor_offset:]),

update_completion=False,

reset_rl_history=False,

clear_special_mode=False)

self.cursor_offset += 1

if (self.config.cli_trim_prompts and

self.current_line.startswith(self.ps1)):

self.current_line = self.current_line[4:]

self.cursor_offset = max(0, self.cursor_offset - 4)

def add_to_incremental_search(self, char=None, backspace=False):

"""Modify the current search term while in incremental search.

if char is None and not backspace:

raise ValueError("must provide a char or set backspace to True")

if backspace:

self.incremental_search_target = self.incremental_search_target[:-1]

else:

self.incremental_search_target += char

if self.incremental_search_mode == 'reverse_incremental_search':

self.incremental_search(reverse=True, include_current=True)

elif self.incremental_search_mode == 'incremental_search':

self.incremental_search(include_current=True)

else:

raise ValueError('add_to_incremental_search not in a special mode')

def update_completion(self, tab=False):

"""Update visible docstring and matches, and possibly hide/show completion box"""

# Update autocomplete info; self.matches_iter and self.argspec

# Should be called whenever the completion box might need to appear / dissapear

# when current line or cursor offset changes, unless via selecting a match

self.current_match = None

self.list_win_visible = BpythonRepl.complete(self, tab)

def predicted_indent(self, line):

# TODO get rid of this! It's repeated code! Combine with Repl.

logger.debug('line is %r', line)

indent = len(re.match(r'[ ]*', line).group())

if line.endswith(':'):

indent = max(0, indent + self.config.tab_length)

elif line and line.count(' ') == len(line):

indent = max(0, indent - self.config.tab_length)

elif line and ':' not in line and line.strip().startswith(('return', 'pass', 'raise', 'yield')):

indent = max(0, indent - self.config.tab_length)

logger.debug('indent we found was %s', indent)

return indent

def push(self, line, insert_into_history=True):

"""Push a line of code onto the buffer, start running the buffer

if self.paste_mode:

self.saved_indent = 0

else:

self.saved_indent = self.predicted_indent(line)

if self.config.syntax:

display_line = bpythonparse(format(self.tokenize(line), self.formatter))

# careful: self.tokenize requires that the line not be in self.buffer yet!

logger.debug('display line being pushed to buffer: %r -> %r', line, display_line)

self.display_buffer.append(display_line)

else:

self.display_buffer.append(fmtstr(line))

if insert_into_history:

self.insert_into_history(line)

self.buffer.append(line)

code_to_run = '\n'.join(self.buffer)

logger.debug('running %r in interpreter', self.buffer)

c, code_will_parse = code_finished_will_parse('\n'.join(self.buffer),

self.interp.compile)

self.saved_predicted_parse_error = not code_will_parse

if c:

logger.debug('finished - buffer cleared')

self.cursor_offset = 0

self.display_lines.extend(self.display_buffer_lines)

self.display_buffer = []

self.buffer = []

self.coderunner.load_code(code_to_run)

self.run_code_and_maybe_finish()

def run_code_and_maybe_finish(self, for_code=None):

r = self.coderunner.run_code(for_code=for_code)

if r:

logger.debug("----- Running finish command stuff -----")

logger.debug("saved_indent: %r", self.saved_indent)

err = self.saved_predicted_parse_error

self.saved_predicted_parse_error = False