"""Init all the colours in curses and bang them into a dictionary"""

for i in range( 63 ):

if i > 7: j = i / 8

else: j = -1

curses.init_pair( i+1, i % 8, j )

c = {}

# blacK, Red, Green, Yellow, Blue, Magenta, Cyan, White, Default:

c["k"] = 0

c["r"] = 1

c["g"] = 2

c["y"] = 3

c["b"] = 4

c["m"] = 5

c["c"] = 6

c["w"] = 7

c["d"] = -1

def showtraceback( self ):

"""This needs to override the default traceback thing

try:

t, v, tb = sys.exc_info()

sys.last_type = t

sys.last_value = v

sys.last_traceback = tb

tblist = traceback.extract_tb( tb )

del tblist[:1]

l = traceback.format_list( tblist )

if l:

l.insert( 0, "Traceback (most recent call last):\n" )

l[len(l):] = traceback.format_exception_only( t, v )

finally:

tblist = tb = None

self.writetb( l )

def writetb( self, l ):

"""This outputs the traceback and should be overridden for anything

"""Implements the necessary guff for a Python-repl-alike interface

"""

def __init__( self, scr, interp, statusbar=None, idle=None):

"""Initialise the repl with, unfortunately, a curses screen passed to it.

self.buffer = []

self.scr = scr

self.interp = interp

self.match = False

self.rl_hist = []

self.stdout_hist = []

self.s_hist = []

self.history = []

self.h_i = 0

self.in_hist = False

self.evaluating = False

self.do_exit = False

self.cpos = 0

self.completer = rlcompleter.Completer( self.interp.locals )

self.statusbar = statusbar

self.list_win = curses.newwin( 1, 1, 1, 1 )

self.idle = idle

self.f_string = ''

self.matches = []

self.argspec = None

self.tablen = None

self.s = ''

self.list_win_visible = False

if not OPTS.arg_spec:

return

pexp = Forward()

chars = printables.replace('(', '')

chars = chars.replace(')', '')

pexpnest = Optional( Word( chars ) ) + Literal( "(" ) + Optional( Group( pexp ) ) + Optional( Literal( ")" ) )

pexp << ( OneOrMore( Word( chars ) | pexpnest ) )

self.pparser = pexp

def cw( self ):

"""Return the current word, i.e. the (incomplete) word

if self.cpos: # I don't know if autocomplete should be disabled

return

l = len( self.s )

if not self.s or ( not self.s[ l-1 ].isalnum() and self.s[ l-1 ] not in ( '.', '_' ) ):

return

i = 1

while i < l+1:

if not self.s[ -i ].isalnum() and self.s[ -i ] not in ( '.', '_' ):

break

i += 1

return self.s[ -i +1: ]

def get_args( self ):

"""Check if an unclosed parenthesis exists, then attempt to get the argspec()

def getpydocspec( f, func ):

try:

argspec = pydoc.getdoc( f )

except NameError:

return None

rx = re.compile( r'([a-zA-Z_][a-zA-Z0-9_]*?)\((.*?)\)' )

s = rx.search( argspec )

if s is None:

return None

if s.groups()[0] != func:

return None

args = [ i.strip() for i in s.groups()[1].split(',') ]

return [func, (args, None, None, None)]#None, None, None]

def getargspec( func ):

try:

if func in self.interp.locals:

f = self.interp.locals[ func ]

except TypeError:

return None

else:

try:

f = eval( func, self.interp.locals )

except Exception: # Same deal with the exceptions :(

return None

try:

if inspect.isclass(f):

argspec = inspect.getargspec( f.__init__ )

else:

argspec = inspect.getargspec( f )

self.argspec = [func, argspec]#[0]]#"Args for %s: " + ", ".join( argspec[0] )

#self.argspec = self.argspec % func

return True

except (NameError, TypeError, KeyError), x:

t = getpydocspec( f, func )

if t is None:

return None

self.argspec = t

return True

except AttributeError: # no __init__

return None

def parse_parens( s ):

"""Run a string through the pyparsing pattern for paren

try:

parsed = self.pparser.parseString( s ).asList()

except ParseException:

return False

return parsed

def walk( seq ):

"""Walk a nested list and return the last list found that

r = None

if isinstance( seq, list ):

if ")" not in seq and "(" in seq:

r = seq[ seq.index('(') - 1 ]

for i in seq:

t = walk( i )

if t:

r = t

return r

if not OPTS.arg_spec:

return False

t = parse_parens( self.s )

if not t:

return False

func = walk( t )

if not func:

return False

return getargspec( func )

def complete( self, tab=False ):

"""Wrap the _complete method to determine the visibility of list_win

if self.list_win_visible and not OPTS.auto_display_list:

self.scr.touchwin()

self.list_win_visible = False

return

if OPTS.auto_display_list or tab:

self.list_win_visible = self._complete( tab )

return

def _complete( self, tab=False ):

"""Construct a full list of possible completions and construct and

words = []

i = 0

if not self.get_args():

self.argspec = None

cw = self.cw()

if not (cw or self.argspec):

self.scr.redrawwin()

self.scr.refresh()

return False

if not cw:

self.matches = []

try:

self.completer.complete( cw, 0 )

except Exception: # This sucks, but it's either that or list all the

e = True

else:

e = False

if (e or not self.completer.matches) and not self.argspec:

self.scr.redrawwin()

return False

if not e and self.completer.matches:

self.matches = sorted( set( self.completer.matches ) ) # remove duplicates and

if len( self.matches ) == 1 and not OPTS.auto_display_list:

self.list_win_visible = True

self.tab()

return False

self.show_list( self.matches, self.argspec )

return True

def show_list( self, items, topline=None ):

shared = Dummy()

shared.cols = 0

shared.rows = 0

shared.wl = 0

y, x = self.scr.getyx()

h, w = self.scr.getmaxyx()

down = (y < h / 2)

max_h = h - y if down else y+1

max_w = int(w * 0.6)

self.list_win.erase()

if topline:

height_offset = self.mkargspec(topline, down) + 1

else:

height_offset = 0

def lsize():

wl = max( len(i) for i in v_items ) + 1 # longest word length (and a space)

if not wl:

wl = 1

cols = (max_w - 2) / wl

rows = len( v_items ) / (cols or 1)

if cols * rows < len( v_items ):

rows += 1

if rows + 2 >= max_h:

rows = max_h - 2

return False

shared.rows = rows

shared.cols = cols

shared.wl = wl

return True

if items:

v_items = [ items[0][:max_w-3] ] # visible items (we'll append until we can't fit any more in)

lsize()

else:

v_items = []

for i in items[1:]:

v_items.append( i[:max_w-3] )

if not lsize():

del v_items[-1]

v_items[-1] = '...'

break

rows = shared.rows

if rows + height_offset < max_h:

rows += height_offset

display_rows = rows

else:

display_rows = rows + height_offset

cols = shared.cols

wl = shared.wl

if topline and not v_items:

w = max_w

elif wl + 3 > max_w:

w = max_w

else:

w = (cols + 1) * wl + 3

if height_offset and display_rows+5 >= max_h:

del v_items[-(cols * (height_offset)):]

self.list_win.resize( rows+2, w )#(cols + 1) * wl + 3 )

if down:

self.list_win.mvwin(y+1, 0)

else:

self.list_win.mvwin(y-rows-2, 0)

if v_items:

self.list_win.addstr( '\n ' )

for ix, i in enumerate(v_items):

padding = (wl - len(i)) * ' '

self.list_win.addstr( i + padding, curses.color_pair( self._C["c"]+1 ) )

if ((cols == 1) or (ix and not ix % cols)) and ix+1 < len(v_items):

self.list_win.addstr( '\n ' )

y = self.list_win.getyx()[0]

self.list_win.resize(y + 2, w )

self.statusbar.win.touchwin()

self.statusbar.win.noutrefresh()

self.list_win.border()

self.scr.touchwin()

self.scr.cursyncup()

self.scr.noutrefresh()

self.scr.move( *self.scr.getyx() )

self.list_win.refresh()

def mkargspec( self, topline, down ):

"""This figures out what to do with the argspec and puts it nicely into

r = 3

fn = topline[0]

args = topline[1][0]

kwargs = topline[1][3]

_args = topline[1][1]

_kwargs = topline[1][2]

max_w = int(self.scr.getmaxyx()[1] * 0.6)

self.list_win.erase()

self.list_win.resize( 3, max_w )

h, w = self.list_win.getmaxyx()

self.list_win.addstr( '\n ')

self.list_win.addstr( fn, curses.color_pair( self._C["b"]+1 ) | curses.A_BOLD )

self.list_win.addstr( ': ( ', curses.color_pair( self._C["y"]+1 ) )

maxh = self.scr.getmaxyx()[0]

for k, i in enumerate( args ):

y, x = self.list_win.getyx()

ln = len( str(i) )

kw = None

if kwargs and k+1 > len(args) - len(kwargs):

kw = '%s' % str(kwargs[ k - (len(args) - len(kwargs))])

ln += len( kw ) + 1

if ln + x >= w:

ty = self.list_win.getbegyx()[0]

if not down and ty > 0:

h +=1

self.list_win.mvwin( ty-1, 1 )

self.list_win.resize(h,w)

elif down and h + r < maxh-ty:

h += 1

self.list_win.resize(h,w)

else:

break

r += 1

self.list_win.addstr('\n\t')

self.list_win.addstr( str(i), curses.color_pair( self._C["g"]+1 ) | curses.A_BOLD )

if kw:

self.list_win.addstr( '=', curses.color_pair( self._C["c"]+1 ) )

self.list_win.addstr( kw, curses.color_pair( self._C["g"]+1) )

if k != len(args) -1:

self.list_win.addstr( ', ', curses.color_pair( self._C["g"]+1 ) )

if _args:

self.list_win.addstr( ', ', curses.color_pair( self._C["g"]+1 ) )

self.list_win.addstr( '*%s' % _args, curses.color_pair( self._C["m"]+1 ) )

if _kwargs:

self.list_win.addstr( ', ', curses.color_pair( self._C["g"]+1 ) )

self.list_win.addstr( '**%s' % _kwargs, curses.color_pair( self._C["m"]+1 ) )

self.list_win.addstr( ' )', curses.color_pair( self._C["y"]+1 ) )

return r

def getstdout( self ):

"""This method returns the 'spoofed' stdout buffer, for writing to a file

return "\n".join( self.stdout_hist )

def write2file( self ):

"""Prompt for a filename and write the current contents of the stdout buffer

fn = self.statusbar.prompt( 'Save to file: ' )

if fn.startswith('~'):

fn = os.path.expanduser( fn )

s = self.getstdout()

try:

f = open( fn, 'w' )

f.write( s )

f.close()

except IOError:

self.statusbar.message("Disk write error for file '%s'." % fn )

else:

self.statusbar.message( 'Saved to %s' % fn )

def pastebin( self ):

"""Upload to a pastebin and display the URL in the status bar."""

s = self.getstdout()

url = 'http://rafb.net/paste/paste.php'

pdata = { 'lang' : 'Python',

'cvt_tabs' : 'No',

'text' : s }

pdata = urllib.urlencode( pdata )

self.statusbar.message( 'Posting data to pastebin...' )

u = urllib.urlopen( url, data=pdata )

d = u.read()

rx = re.search( '(http://rafb.net/p/[0-9a-zA-Z]+\.html)', d )

if not rx:

self.statusbar.message( 'Error parsing pastebin URL! Please report a bug.' )

return

r_url = rx.groups()[ 0 ]

self.statusbar.message( 'Pastebin URL: %s' % r_url, 10 )

def make_list( self, items ):

"""Compile a list of items. At the moment this simply returns

return items

def push( self, s ):

"""Push a line of code onto the buffer so it can process it all

s = s.rstrip('\n')

self.buffer.append( s )

more = self.interp.runsource( "\n".join( self.buffer ) )

if not more:

self.buffer = []

return more

def undo( self, n=1 ):

"""Go back in the undo history n steps and call reeavluate()

implementation, it is merely a convenience bonus."""

if not self.history:

return None

if len( self.history ) < n:

n = len( self.history )

self.history = self.history[ : -n ]

self.reevaluate()

def enter_hist( self ):

"""Set flags for entering into the history by pressing up/down"""

if not self.in_hist:

self.in_hist = True

self.ts = self.s

def back( self ):

"""Replace the active line with previous line in history and

if not self.rl_hist:

return None

self.cpos = 0

self.enter_hist()

if self.h_i < len( self.rl_hist ):

self.h_i += 1

self.s = self.rl_hist[ -self.h_i ].rstrip('\n')

self.print_line( self.s, clr=True )

def fwd( self ):

"""Same as back() but, well, forward"""

self.enter_hist()

self.cpos = 0

if self.h_i > 1:

self.h_i -= 1

self.s = self.rl_hist[ -self.h_i ]

else:

self.h_i = 0

self.s = self.ts

self.ts = ''

self.in_hist = False

self.print_line( self.s, clr=True )

def redraw( self ):

"""Redraw the screen."""

self.scr.erase()

for k, s in enumerate( self.s_hist ):

if not s:

continue

self.iy, self.ix = self.scr.getyx()

for i in s.split('\x04'):

self.echo( i, redraw=False )

if k < len( self.s_hist ) -1:

self.scr.addstr( '\n' )

self.iy, self.ix = self.scr.getyx()

self.print_line( self.s )

self.scr.refresh()

self.statusbar.refresh()

def reevaluate( self ):

"""Clear the buffer, redraw the screen and re-evaluate the history"""

self.evaluating = True

self.stdout_hist = []

self.f_string = ''

self.stdout_hist = []

self.buffer = []

self.scr.erase()

self.s_hist = []

self.prompt( False )

self.iy, self.ix = self.scr.getyx()

for line in self.history:

self.stdout_hist[-1] += line.rstrip('\n')

self.print_line( line )

self.s_hist[-1] += self.f_string

self.scr.addstr( '\n' ) # I decided it was easier to just do this manually

more = self.push( line )

self.prompt( more )

self.iy, self.ix = self.scr.getyx()

self.s = ''

self.scr.refresh()

self.evaluating = False

#map( self.push, self.history ) # <-- That's how simple this function was at first :(

def prompt( self, more ):

"""Show the appropriate Python prompt"""

if not more:

self.echo( "\x01g\x03>>> " )

self.stdout_hist.append('>>> ')

self.s_hist.append( '\x01g\x03>>> \x04' )

else:

self.echo( "\x01r\x03... " )

self.stdout_hist.append('... ')

self.s_hist.append( '\x01r\x03... \x04' )

def repl( self ):

"""Initialise the repl and jump into the loop. This method also

# This was a feature request to have the PYTHONSTARTUP

# file executed on startup - I personally don't use this

# feature so please notify me of any breakage.

filename = os.environ.get('PYTHONSTARTUP')

if filename and os.path.isfile(filename):

for line in open(filename, 'r'):

self.push( line )

self.push( '\n' )

from bpython import _internal

_internal.window = self.scr

self.push('from bpython import _internal\n')

self.push('help = _internal._help')

self.iy, self.ix = self.scr.getyx()

more = False

while not self.do_exit:

self.f_string = ''

self.prompt( more )

try:

inp = self.get_line()

except KeyboardInterrupt:

self.statusbar.message('KeyboardInterrupt')

self.scr.addstr('\n')

continue

self.scr.redrawwin()

if self.do_exit:

return

self.h_i = 0

self.history.append( inp )

self.s_hist[-1] += self.f_string

self.stdout_hist[-1] += inp.rstrip('\n')

self.rl_hist.append( inp ) # Keep two copies so you can go up and down in the hist

more = self.push( inp )

def size( self, scr ):

"""Set instance attributes for x and y top left corner coordinates

h, w = stdscr.getmaxyx()

self.y = 0

self.w = w

self.h = h-1

self.x = 0

def resize( self ):

"""This method exists simply to keep it straight forward when initialising

self.size( self.scr )

self.scr.erase()

self.scr.resize( self.h, self.w )

self.scr.mvwin( self.y, self.x )

self.redraw()

def write( self, s ):

"""For overriding stdout defaults"""

if s.rstrip('\n'):

if '\x03' in s:

t = s.split('\x03')[1].rstrip('\n')

else:

t = s.rstrip('\n')

self.stdout_hist.append( t )

self.echo( s )

self.s_hist.append( s.rstrip('\n') )

def flush( self ):

"""Olivier Grisel brought it to my attention that the logging

to do it."""

pass

def close( self ):

"""See the flush() method docstring."""

pass

def echo( self, s, redraw=True ):

"""Parse and echo a formatted string with appropriate attributes. It uses the

a = curses.color_pair( 0 )

if '\x01' in s:

rx = re.search( '\x01([a-z])([a-z]?)', s )

if rx:

p = self._C[ rx.groups()[ 0 ] ]

if rx.groups()[ 1 ]:

p *= self._C[ rx.groups()[ 1 ] ]

a = curses.color_pair( int( p ) + 1 )

s = re.sub( '\x01[a-z][a-z]?', '', s )

if '\x02' in s:

a = a | curses.A_BOLD

s = s.replace( '\x02', '' )

s = s.replace( '\x03', '' )

s = s.replace( '\x01', '' )

self.scr.addstr( s, a )

if redraw and not self.evaluating:

self.scr.refresh()

def mvc( self, i, refresh=True ):

"""This method moves the cursor relatively from the current

y, x = self.scr.getyx()

if self.cpos == 0 and i < 0:

return

if x == self.ix and y == self.iy and i >= 1:

return

h, w = gethw()

if x - i < 0:

y -= 1

x = w

if x - i >= w:

y += 1

x = 0 + i

self.cpos += i

self.scr.move( y, x - i )

if refresh:

self.scr.refresh()

def bs( self ):

"""Process a backspace"""

y, x = self.scr.getyx()

if not self.s:

return

if x == self.ix and y == self.iy:

return

n = 1

if x == 0:

y -= 1

x = gethw()[1]

if not self.cpos: # I know the nested if blocks look nasty. :(

if self.s[-1] == '\t':

n = self.tablen

if len(self.s) > 1:

n = n * 2

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

else:

self.s = self.s[ : -self.cpos-1 ] + self.s[ -self.cpos : ]

for i in range(n):

self.scr.delch( y, x - n )

self.scr.refresh()

def clrtobol( self ):

"""Clear from cursor to beginning of line; usual C-u behaviour"""

if not self.cpos:

self.s = ''

else:

self.s = self.s[ self.cpos : ]

self.print_line( self.s, clr=True )

self.scr.redrawwin()

self.scr.refresh()

def p_key( self ):

"""Process a keypress"""

if self.c is None:

return ''

if self.c == chr(8): # C-Backspace (on my computer anyway!)

self.clrtobol()

self.c = '\n'

# Don't return; let it get handled

if self.c == chr( 27 ):

return ''

if self.c in ( chr(127), 'KEY_BACKSPACE' ):

self.bs()

self.complete()

return ''

elif self.c == chr(18):# C-r

self.undo()

return ''

elif self.c == 'KEY_UP': # Cursor Up

self.back()

return ''

elif self.c == 'KEY_DOWN': # Cursor Down

self.fwd()

return ''

elif self.c == 'KEY_LEFT': # Cursor Left

self.mvc( 1 )

elif self.c == 'KEY_RIGHT': # Cursor Right

self.mvc( -1 )

elif self.c in ('^U', chr(21) ): # C-u

self.clrtobol()

return ''

elif self.c in ('^L', chr(12) ): # C-l

self.redraw()

return ''

elif self.c in ( chr(4), '^D' ): # C-d

self.do_exit = True

return None

elif self.c == 'KEY_F(2)':

self.write2file()

return ''