def do_history(self, args):
"""
Prints cloudmonkey history
"""
if self.pipe_runner("history " + args):
return
startIdx = 1
endIdx = readline.get_current_history_length()
numLen = len(str(endIdx))
historyArg = args.split(' ')[0]
if historyArg.isdigit():
startIdx = endIdx - long(historyArg)
if startIdx < 1:
startIdx = 1
elif historyArg == "clear" or historyArg == "c":
readline.clear_history()
print "CloudMonkey history cleared"
return
elif len(historyArg) > 1 and historyArg[0] == "!" and historyArg[1:].isdigit():
command = readline.get_history_item(long(historyArg[1:]))
readline.set_startup_hook(lambda: readline.insert_text(command))
self.hook_count = 1
return
for idx in xrange(startIdx, endIdx):
self.monkeyprint("%s %s" % (str(idx).rjust(numLen),
readline.get_history_item(idx)))
def history(start=None, end=None, lines=30,
number=False):
"""
Display the history starting from entry 'start' to
entry 'end'. Only available on platforms where the
readline module can be imported.
History starts from 0 and goes to a large number.
The history file is $ZENHOME/.pyhistory by default.
@parameter start: Line number to start printing
@type start: integer
@parameter end: Line number to finish printing
@type end: integer
@parameter lines: number of lines to show if no end
@type lines: integer
@parameter number: show the line numbers?
@type number: boolean
"""
if readline is not None:
maxHistLength = readline.get_current_history_length()
if start is None:
start = maxHistLength
if end is None:
end = maxHistLength - lines
if start < end:
end, start = start, end
for i in range(end, start):
if number:
print i, readline.get_history_item(i)
else:
print readline.get_history_item(i)
def do_history(self, args):
"""
Prints cloudmonkey history
"""
if self.pipe_runner("history " + args):
return
startIdx = 1
endIdx = readline.get_current_history_length()
numLen = len(str(endIdx))
historyArg = args.split(' ')[0]
if historyArg.isdigit():
startIdx = endIdx - long(historyArg)
if startIdx < 1:
startIdx = 1
elif historyArg == "clear" or historyArg == "c":
readline.clear_history()
print "CloudMonkey history cleared"
return
elif len(historyArg
) > 1 and historyArg[0] == "!" and historyArg[1:].isdigit():
command = readline.get_history_item(long(historyArg[1:]))
readline.set_startup_hook(lambda: readline.insert_text(command))
self.hook_count = 1
return
for idx in xrange(startIdx, endIdx):
self.monkeyprint(
"%s %s" %
(str(idx).rjust(numLen), readline.get_history_item(idx)))
def printf(x):
current_line = inspect.currentframe().f_back.f_lineno
filename = os.path.abspath(sys.argv[0]) #__file__)
#print('==> ' + str(current_line))
#print('==> ' + str(filename))
# Detect if user is using an interactive shell
if os.isatty(sys.stdout.fileno()):
first_line = readline.get_current_history_length()
readline.get_history_item(first_line + 0) #TODO: find current_line
print() #TODO
return
with open(filename, 'r') as source:
for n, line in enumerate(source, start=1):
if n == current_line:
#print('==> ' + str(line))
mo = __import__('re').search(
r'printf\s*\(\s*([_a-zA-Z][_a-zA-Z0-9]*)\s*\)', line)
if mo is not None:
print('{}: {}'.format(mo.group(1), x))
'''
else:
print('Error: Steven\'s regex is broken')
'''
break
else:
print('Error: symbol not found')
def eventFilter(self, source, event):
# Console Input
if source is self.ui.console_input:
if event.type() == QEvent.KeyPress:
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
command = self.ui.console_input.text()
if command != "":
readline.add_history(command)
self.length = readline.get_current_history_length()
self.index = -1
if event.key() == Qt.Key_Up:
if self.index < self.length:
self.index += 1
command = readline.get_history_item(self.length -
self.index)
self.ui.console_input.setText(command)
if event.key() == Qt.Key_Down:
if self.index > 0:
self.index -= 1
command = readline.get_history_item(self.length -
self.index)
self.ui.console_input.setText(command)
return False
return False
def journal(idx = None):
if idx != None:
cache_list = '\n'.join([str(readline.get_history_item(i + 1)) for i in range(readline.get_current_history_length())]).split('\n')[int(idx)]
out = tabulate({"Command": cache_list.split('\n')}, headers=["Command"])
else:
cache_list = '\n'.join([str(readline.get_history_item(i + 1)) for i in range(readline.get_current_history_length())])
out = tabulate({"Command": cache_list.split('\n')}, headers=["Index","Command"], showindex="always")
print('journal:', out)
def repeat_last_cmd(self): """ repeat previously typed cmd """ index = readline.get_current_history_length() line = readline.get_history_item(index - 1) while self._is_custom_cmd(line): index -= 1 line = readline.get_history_item(index) self.push(line) return ''
def main():
prevrun = []
warning = 0
readline.parse_and_bind('tab: complete') # Enable local file tab completion and history
#readline.read_history_file(history.his)
# Need to initialize history file here TODO
while True:
try:
dir = os.getcwd()
input = raw_input('{} >> '.format(dir)) # Print >>, take user input (blocking)
args = shlex.split(input) # Use shell lexer module to parse input into list of strings
if input[0][0] == '!':
if int(input[1][0]) > int(readline.get_current_history_length()):
continue
if readline.get_history_item(int(input[1][0])) is not None:
args = shlex.split(readline.get_history_item(int(input[1][0])))
if int(input[1][0]) == 0:
args = prevrun
run = builtins.get(args[0], builtin_exec) # Store relevant function into run variable (builtin_exec being default)
retVal = run(args) # Execute function stored in run with arguments args, storing the return value in retVal
prevrun = args
if warning > 0:
warning = warning - 1 # This is a bit silly
builtin_check_children()
except KeyboardInterrupt: # Can use Finally to run commands regardless, or else to run things when no exception
print "\r\nCaught interrupt signal! Killing any child processes..."
builtin_kill_children()
continue
except EOFError:
if len(children) > 0 and warning < 1:
warning = warning + 3 # Two commands of leeway before next warning
print "\r\nWarning: this shell still has child processes active. Pressing ^D again will kill them."
continue
builtin_kill_children()
print "\r\nLogout"
exit()
except ValueError:
print "Unable to parse command. Do you have a non-paired delimiter? Think (), [], '', or \"\""
except OSError:
print "Received an OS Error. Does the file or command you're looking for exist, or are you running out of memory?"
#traceback.print_exc()
except Exception:
print "Error: I'm unsure of how to parse/execute the previous input. Common reasons for this are multiple redirects"
print "on the same line, commands that don't syntactically make sense, or attempting to reach files that don't exist."
print "Nothing but whitespace will also trigger this error."
print "Additionally, I caught the following exception:"
traceback.print_exc()
def do_history(self, args):
"""
This method handles all tasks related to management of history of commands
"""
self.gLogging.debug("do_history invoked")
description = "work with commands history"
try:
#import argcomplete
parser = argparse.ArgumentParser(prog="history", add_help=True, epilog=self.epilog, description=description, usage="history <command> [<args>]")
subparsers = parser.add_subparsers()
clear_parser = subparsers.add_parser('clear', description="clear history", usage="history clear <args>")
clear_parser.set_defaults(which='clear')
clear_parser.add_argument('-Y', '--yes', action='store_true', required=True, help="confirm")
show_parser = subparsers.add_parser('show', description="show history", usage="history show") #, aliases=['s']
show_parser.set_defaults(which='show')
rem_parser = subparsers.add_parser('run', description="run command again", usage="history run <args>")
rem_parser.set_defaults(which='run')
rem_parser.add_argument('-c', '--command', type=int, required=True, help="command number")
find_parser = subparsers.add_parser('find', description="find command", usage="history find <args>")
find_parser.set_defaults(which='find')
find_parser.add_argument('-c', '--command', type=str, required=True, help="command substring")
#completer = argcomplete.CompletionFinder(parser)
#readline.set_completer_delims("")
#readline.set_completer(completer.rl_complete)
#readline.parse_and_bind("tab: complete")
choice = vars(parser.parse_args(args.split()))
if len(args) == 0:
parser.print_help()
elif choice['which'] == 'clear':
if choice['yes']:
readline.clear_history()
else:
self.gLogging.show("skipped.. ")
elif choice['which'] == 'show':
for i in range(readline.get_current_history_length()):
print(i+1, readline.get_history_item(i + 1))
elif choice['which'] == 'run':
self.onecmd(readline.get_history_item(choice['command']))
elif choice['which'] == 'find':
for i in range(readline.get_current_history_length()):
if choice['command'] in readline.get_history_item(i + 1):
print(i+1, readline.get_history_item(i + 1))
else:
parser.print_help()
except SystemExit:
pass
except Exception:
self.gLogging.error("cannot parse given arguments")
def history(history_id=None):
if history_id is None:
for i in range(readline.get_current_history_length()):
print(str(i + 1) + ': ' + readline.get_history_item(i + 1))
return None
else:
# print( str(history_id ) + ': ' + readline.get_history_item(history_id) )
return readline.get_history_item(history_id)
def history(history_id=None):
if history_id is None:
for i in range(readline.get_current_history_length()):
print( str(i+1) + ': ' + readline.get_history_item(i+1) )
return None
else:
# print( str(history_id ) + ': ' + readline.get_history_item(history_id) )
return readline.get_history_item(history_id)
def __getitem__(self, index):
'''
Get a single event at ``index`` or a :class:`slice` of events.
'''
if isinstance(index, slice):
start = self.normalize_index(index.start or 0)
stop = self.normalize_index((index.stop or self.__len__())-1)
step = index.step or 1
return [readline.get_history_item(i) for i in range(start, stop+1, step)]
else:
index = self.normalize_index(index)
return readline.get_history_item(index)
def save():
"""save the readline history since last call to mark()"""
end = readline.get_current_history_length() - 1
session = []
item = readline.get_history_item(end)
while item != _marker:
session.insert(0, item+"\n")
end -= 1
item = readline.get_history_item(end)
file(_session_file, 'w').writelines(session)
print >> sys.stderr, "saved session to", _session_file
def history(self, argv):
"""history [<index>]
Display the current readline history buffer."""
if not readline:
self._print("The readline library is not available.")
return
if len(argv) > 1:
idx = int(argv[1])
self._print(readline.get_history_item(idx))
else:
for i in range(readline.get_current_history_length()):
self._print(readline.get_history_item(i))
def history(self, argv):
"""history [<index>]
Display the current readline history buffer."""
if not readline:
self._print("The readline library is not available.")
return
if len(argv) > 1:
idx = int(argv[1])
self._print(readline.get_history_item(idx))
else:
for i in range(readline.get_current_history_length()):
self._print(readline.get_history_item(i))
def compact_history():
if hasattr(readline, "replace_history_item"):
unique_history = utils.unique_list()
for index in reversed(list(range(1, readline.get_current_history_length()))):
hist_item = readline.get_history_item(index)
if hist_item: # some history items are None (usually at index 0)
unique_history.append(readline.get_history_item(index))
unique_history.reverse()
for index in range(len(unique_history)):
readline.replace_history_item(index + 1, unique_history[index])
for index in reversed(list(range(len(unique_history) + 1, readline.get_current_history_length()))):
readline.remove_history_item(index)
def compact_history():
if hasattr(readline, "replace_history_item"):
unique_history = utils.unique_list()
for index in reversed(list(range(1, readline.get_current_history_length()))):
hist_item = readline.get_history_item(index)
if hist_item: # some history items are None (usually at index 0)
unique_history.append(readline.get_history_item(index))
unique_history.reverse()
for index in range(len(unique_history)):
readline.replace_history_item(index + 1, unique_history[index])
for index in reversed(list(range(len(unique_history) + 1, readline.get_current_history_length()))):
readline.remove_history_item(index)
def history(start=0, end=None, find=None, concat=False):
if end is None:
end = rl.get_current_history_length()
if start < 0:
start += rl.get_current_history_length()
if concat:
print(';'.join(
rl.get_history_item(i + 1) for i in range(start, end)
if find is None or find in rl.get_history_item(i + 1)))
return
for i in range(start, end):
if find is None or find in rl.get_history_item(i + 1):
print(str(i + 1) + ":", rl.get_history_item(i + 1))
def history(self, arguments):
"""Display the current readline history buffer.
Usage:
history [<index>]
"""
index = arguments["<index>"]
if index:
idx = int(index)
self._ui.print(readline.get_history_item(idx))
else:
for i in range(readline.get_current_history_length()):
self._ui.print(readline.get_history_item(i))
def wait_input(self, prompt="", completer=None):
"""
Wait for the user to input a message and hit enter.
Returns the message
"""
self.inputbuffer = prompt
self.redraw_chatline()
self.win_chatline.cursyncup()
last = -1
historyPos = 0
while last != ord('\n'):
# commands to execute based on which key
# tab: complete
# arrows: iterate history
last = self.stdscr.getch()
if last == ord('\n'):
readline.add_history(self.inputbuffer)
tmp = self.inputbuffer
self.inputbuffer = ""
self.redraw_chatline()
self.win_chatline.cursyncup()
return tmp[len(prompt):]
elif last == ord('\t'):
if completer != None:
response = completer.complete(self.inputbuffer)
if response:
self.inputbuffer = response
else:
pass
elif last == curses.KEY_UP:
historyPos += 1
resp = readline.get_history_item(
readline.get_current_history_length() - historyPos)
if resp != None:
self.inputbuffer = resp
elif last == curses.KEY_DOWN:
historyPos -= 1
resp = readline.get_history_item(
readline.get_current_history_length() - historyPos)
if resp != None:
self.inputbuffer = resp
elif last == curses.KEY_BACKSPACE or last == 127:
if len(self.inputbuffer) > len(prompt):
self.inputbuffer = self.inputbuffer[:-1]
elif last == curses.KEY_RESIZE:
self.resize()
elif 32 <= last <= 126:
self.inputbuffer += chr(last)
self.redraw_chatline()
def search(self, searchItem):
historyLength = readline.get_current_history_length()
historyLengthDigitNr = len(str(historyLength))
for idx in range(1, historyLength):
historyItem = readline.get_history_item(idx)
if historyItem.find(searchItem) != -1:
idxLen = len(str(idx))
print "%(space)s%(idx)s '%(historyItem)s'" % {
'space': ' ' * (1 + historyLengthDigitNr - idxLen),
'idx': idx,
'historyItem': readline.get_history_item(idx)
}
def __getitem__(self, index):
'''
Get a single event at ``index`` or a :class:`slice` of events.
'''
if isinstance(index, slice):
start = self.normalize_index(index.start or 0)
stop = self.normalize_index((index.stop or self.__len__()) - 1)
step = index.step or 1
return [
readline.get_history_item(i)
for i in range(start, stop + 1, step)
]
else:
index = self.normalize_index(index)
return readline.get_history_item(index)
def run(self):
# Preserve existing history
if self.preserve_history:
old_history = [readline.get_history_item(index) for index in xrange(readline.get_current_history_length())]
readline.clear_history()
map(readline.add_history, self.history)
readline.set_completer(self.complete)
readline.parse_and_bind("bind ^I rl_complete")
while True:
cmdline = raw_input("%s > " % (self.prefix,))
self.last_wd_complete = ("", ())
if not cmdline:
continue
# Try to dispatch command
try:
self.execute(cmdline)
except SystemExit, e:
print "Exiting shell: %s" % (e.code,)
break
except UnknownCommand, e:
print "Command '%s' unknown." % (e,)
def history(self):
""" returns all the executed commands """
if not HAVE_READLINE:
return
for i in range(0, readline.get_current_history_length()):
yield readline.get_history_item(i)
def rl_autoindent():
"""Auto-indent upon typing a new line according to the contents of the
previous line. This function will be used as Readline's
pre-input-hook.
"""
hist_len = readline.get_current_history_length()
last_input = readline.get_history_item(hist_len)
try:
last_indent_index = last_input.rindex(" ")
except:
last_indent = 0
else:
last_indent = int(last_indent_index / 4) + 1
if len(last_input.strip()) > 1:
if last_input.count("(") > last_input.count(")"):
indent = ''.join([" " for n in range(last_indent + 2)])
elif last_input.count(")") > last_input.count("("):
indent = ''.join([" " for n in range(last_indent - 1)])
elif last_input.count("[") > last_input.count("]"):
indent = ''.join([" " for n in range(last_indent + 2)])
elif last_input.count("]") > last_input.count("["):
indent = ''.join([" " for n in range(last_indent - 1)])
elif last_input.count("{") > last_input.count("}"):
indent = ''.join([" " for n in range(last_indent + 2)])
elif last_input.count("}") > last_input.count("{"):
indent = ''.join([" " for n in range(last_indent - 1)])
elif last_input[-1] == ":":
indent = ''.join([" " for n in range(last_indent + 1)])
else:
indent = ''.join([" " for n in range(last_indent)])
readline.insert_text(indent)
def remote_log_history():
import readline
from time import time
import requests
import os
import json
import base64
cnt = readline.get_current_history_length()
for i in xrange(cnt):
cmd = readline.get_history_item(i + 1)
data = {}
data['ts'] = time()
data['cmd'] = base64.b64encode(cmd.encode('ascii'))
data['optout'] = None
if 'STATSOPTOUT' in os.environ:
data['optout'] = os.environ['STATSOPTOUT']
data['src'] = {}
data['src']['user'] = os.environ['USER']
if 'SESSIP' in os.environ:
data['src']['ip'] = os.environ['SESSIP']
pid = os.getpid()
ppid = os.getppid()
sessid = 'SESSID'
if 'SESSID' in os.environ:
sessid = os.environ['SESSID']
data['src']['session'] = '%s.%s.%s.py' % (pid, ppid, sessid)
url = 'http://ctf.local:9999/cmd'
# print('request: %s' % json.dumps(data))
try:
requests.post(url, data=json.dumps(data), timeout=2.0)
except: # ConnectionError, HTTPError, Timeout, TooManyRedirects
pass
def wrapper(*args, **kwargs):
try:
import readline
handle_readline = True
except ImportError:
handle_readline = False
if handle_readline:
# backup & reset readline completer
old_readline_completer = readline.get_completer()
readline.set_completer((lambda x: x))
# backup & reset readline history
old_readline_history = []
hist_sz = readline.get_current_history_length()
for i in range(1, hist_sz + 1):
line = readline.get_history_item(i)
old_readline_history.append(line)
readline.clear_history()
try:
retval = function(*args, **kwargs)
finally:
if handle_readline:
# restore old readline completer
readline.set_completer(old_readline_completer)
# restore old readline history
readline.clear_history()
for line in old_readline_history:
readline.add_history(line)
return retval
def __str__(self):
try:
_ = readline.get_history_item(readline.get_current_history_length())
if _ not in [h[-1], None, h]: h.append(_);
except NameError:
pass
return self.str % len(h);
def __str__(self):
global h
h = History()
for x in range(0,readline.get_current_history_length()-1):
#print "length %d %s" % (x,readline.get_history_item(x))
h.append(readline.get_history_item(x))
return self.str % readline.get_current_history_length()
def save(self, filename, pos = None, end = None):
"""write history number from pos to end into filename file"""
length = get_current_history_length()
if length > 1:
if not pos:
pos = 1
elif pos >= length - 1:
pos = length - 1
elif pos < 1:
pos = length + pos - 1
if not end:
end = length
elif end >= length:
end = length
if end < 0:
end = length + end
else:
end = end + 1
fp = open(filename, 'w')
write = fp.write
if pos < end:
map(lambda x: write('%s\n' % x),
imap(get_history_item, xrange(pos, end)))
else:
write('%s\n' % get_history_item(pos))
fp.close()
def builtin_history(args):
print "\033[2J\033[1;1H" # First character clears screen, second places cursor at top-left
print "HISTORY"
print "-------"
for i in range(1, int(readline.get_current_history_length())):
print "{}. {}".format(i, readline.get_history_item(i))
print ""
def remove_history_item(line_number, initial_history_length=None):
"""
Function to remove an item from the readline history
since readline.remove_history_item() is not working
Args:
line_number (int): History line that will removed
initial_history_length (int): The history length recorded at the start of the Pybash session,
used for history management. If the removed line was prior to the initial history length,
then this needs to be adjusted.
Returns:
int: If initial_history_length was provided, the adjusted initial history length is returned
If not, then None is returned
"""
# Get all history items except for the one at line_number
hist_len = readline.get_current_history_length()
new_history = [
readline.get_history_item(i) for i in range(1, hist_len)
if not i == line_number
]
# Replace history
readline.clear_history()
for l in new_history:
readline.add_history(l)
# If initial_history_length was specified, check to see if it needs to be adjusted
if initial_history_length:
if line_number < initial_history_length:
return initial_history_length - 1
else:
return initial_history_length
else:
return
def __history_try_search(cls, text):
history_range = range(readline.get_current_history_length(), 1, -1)
for i in history_range:
item = readline.get_history_item(i)
if item.startswith(text):
return item
return ''
def run(self):
# Preserve existing history
if self.preserve_history:
old_history = [
readline.get_history_item(index)
for index in xrange(readline.get_current_history_length())
]
old_history = filter(lambda x: x is not None, old_history)
readline.clear_history()
map(readline.add_history, self.history)
old_completer = readline.get_completer()
readline.set_completer(self.complete)
readline.parse_and_bind("bind ^I rl_complete")
while True:
cmdline = raw_input("%s > " % (self.prefix, ))
self.last_wd_complete = ("", ())
if not cmdline:
continue
# Try to dispatch command
try:
self.execute(cmdline)
except SystemExit, e:
print "Exiting shell: %s" % (e.code, )
break
except UnknownCommand, e:
print "Command '%s' unknown." % (e, )
def hist():
"""Fetches command line history. Returns dict of all lines."""
history_dict = {}
# create history_list
for i in range(readline.get_current_history_length()):
history_dict[i+1] = (readline.get_history_item(i+1))
return history_dict
def get_history(max_entries):
"""Get the most recently used shell commands."""
num_entries = readline.get_current_history_length()
return [
readline.get_history_item(index + 1)
for index in range(max(num_entries - max_entries, 0), num_entries)
]
def history(command):
"""print the line of history"""
exit_code = 0
if len(command) == 1:
for i in range(1, readline.get_current_history_length() + 1):
print("%3d %s" % (i, readline.get_history_item(i)))
return exit_code
def get_history_item (self, index):
length = readline.get_current_history_length()
if index > length:
print format_text("please select an index between {0} and {1}".format(0, length))
return None
return readline.get_history_item(index)
def run(self, argc, argv):
option = argv[0]
if option == "on":
self.local_storage.set("history", True)
self.global_storage.set("history", True)
self.output_information("HatSploit history: on")
elif option == "off":
self.local_storage.set("history", False)
self.global_storage.set("history", False)
self.output_information("HatSploit history: off")
elif option in ['-c', '--clear']:
readline.clear_history()
with open(self.history, 'w') as history:
history.write("")
elif option in ['-l', '--list']:
using_history = self.local_storage.get("history")
if using_history:
if readline.get_current_history_length() > 0:
self.output_information("HatSploit history:")
history_file = open(self.history, 'r')
history = [x.strip() for x in history_file.readlines()]
history_file.close()
for line in history:
self.output_empty(" * " + line)
for index in range(1, readline.get_current_history_length()):
self.output_empty(" * " + readline.get_history_item(index))
else:
self.output_warning("HatSploit history empty.")
else:
self.output_warning("No history detected.")
else:
self.output_usage(self.details['Usage'])
def _SaveHistory(self):
"""Save readline history then clear history."""
self._saved_history = []
for idx in xrange(1, readline.get_current_history_length()+1):
self._saved_history.append(readline.get_history_item(idx))
for idx in xrange(readline.get_current_history_length()):
readline.remove_history_item(0)
def last_command(self):
""" returns the last executed command """
if not HAVE_READLINE:
return ""
cur_size = readline.get_current_history_length()
return readline.get_history_item(cur_size - 1)
def print_history (self):
length = readline.get_current_history_length()
for i in xrange(1, length + 1):
cmd = readline.get_history_item(i)
print "{:<5} {:}".format(i, cmd)
def print_history (self):
length = readline.get_current_history_length()
for i in range(1, length + 1):
cmd = readline.get_history_item(i)
print("{:<5} {:}".format(i, cmd))
def get_history_item (self, index):
length = readline.get_current_history_length()
if index > length:
print(format_text("please select an index between {0} and {1}".format(0, length)))
return None
return readline.get_history_item(index)
def getblocks_from_history(object, lstrip=False):# gettype=False):
"""extract code blocks from a code object using stored history"""
import readline, inspect, types
lbuf = readline.get_current_history_length()
code = [readline.get_history_item(i)+'\n' for i in range(1,lbuf)]
lnum = 0
codeblocks = []
#objtypes = []
while lnum < len(code):#-1:
if code[lnum].lstrip().startswith('def '):
block = inspect.getblock(code[lnum:])
lnum += len(block)
if block[0].lstrip().startswith('def %s(' % object.func_name):
if lstrip: block[0] = block[0].lstrip()
codeblocks.append(block)
# obtypes.append(types.FunctionType)
elif 'lambda ' in code[lnum]:
block = inspect.getblock(code[lnum:])
lnum += len(block)
lhs,rhs = block[0].split('lambda ',1)[-1].split(":", 1) #FIXME: bad
try: #FIXME: unsafe
_ = eval("lambda %s : %s" % (lhs, rhs), globals(), locals())
except: pass
if _.func_code.co_code == object.func_code.co_code:
if lstrip: block[0] = block[0].lstrip()
codeblocks.append(block)
# obtypes.append('<lambda>')
else:
lnum +=1
#if gettype: return codeblocks, objtypes
return codeblocks #XXX: danger... gets methods and closures w/o containers
def getline(frame):
"""
get the current logic line from the frame
"""
lineno = frame.f_lineno
filename = frame.f_code.co_filename
if filename == "<stdin>":
try:
his_length = readline.get_current_history_length()
code_string = readline.get_history_item(his_length)
except NameError:
raise Exception("watchpoints does not support REPL on Windows")
elif filename.startswith("<ipython-input"):
return inspect.getsource(frame)
else:
with open(filename, "r", encoding="utf-8") as f:
lines = f.readlines()
if sys.version_info.minor <= 7:
# For python 3.6 and 3.7, f_lineno does not return correct position
# when it's multiline code
while "(" not in lines[lineno - 1]:
lineno -= 1
linesio = StringIO("".join(lines[lineno - 1:]))
lst = []
code_string = ""
for toknum, tokval, _, _, _ in generate_tokens(linesio.readline):
if toknum == NEWLINE:
code_string = " ".join(lst)
break
elif toknum not in (COMMENT, NL, INDENT):
lst.append(tokval)
return code_string
def save(self, filename, pos=None, end=None):
"""write history number from pos to end into filename file"""
length = get_current_history_length()
if length > 1:
if not pos:
pos = 1
elif pos >= length - 1:
pos = length - 1
elif pos < 1:
pos = length + pos - 1
if not end:
end = length
elif end >= length:
end = length
if end < 0:
end = length + end
else:
end = end + 1
fp = open(filename, 'w')
write = fp.write
if pos < end:
map(lambda x: write('%s\n' % x),
imap(get_history_item, xrange(pos, end)))
else:
write('%s\n' % get_history_item(pos))
fp.close()
def get_history_items():
"""迭代命令"""
return [
readline.get_history_item(i)
for i in range(1,
readline.get_current_history_length() + 1)
]
def __print_history(self):
hi_len = readline.get_current_history_length()
offset = hi_len - 10 if hi_len > 10 else 0
for i in range(offset, hi_len):
item = readline.get_history_item(i)
if item:
print(item)
def __init__(self, async_, console, client, save_console_history):
self.async_ = async_
self.lines = deque(maxlen=100)
self.generate_prompt = console.generate_prompt
self.save_console_history = save_console_history
self.ac = client.get_console_methods()
self.ac.update({
'quit': self.action_quit,
'q': self.action_quit,
'exit': self.action_quit,
'help': self.action_help,
'?': self.action_help
})
# fetch readline history and add relevants
for i in range(1, readline.get_current_history_length()):
cmd = readline.get_history_item(i)
if cmd.strip() and cmd.split()[0] in self.ac:
self.lines.appendleft(CmdLine(cmd))
# new line
self.lines.appendleft(CmdLine(''))
self.line_index = 0
self.last_status = ''
def getblocks(object, lstrip=False):# gettype=False):
"""extract code blocks from a code object using stored history"""
import readline, inspect #, types
lbuf = readline.get_current_history_length()
code = [readline.get_history_item(i)+'\n' for i in range(1,lbuf)]
lnum = 0
codeblocks = []
#objtypes = []
try:
if PYTHON3:
fname = object.__name__
ocode = object.__code__
else:
fname = object.func_name
ocode = object.func_code
cname = ''
except AttributeError:
fname = ''
ocode = lambda :'__this_is_a_big_dummy_object__'
ocode.co_code = '__this_is_a_big_dummy_co_code__'
#try: inspect.getmro(object) #XXX: ensure that it's a class
if hasattr(object, '__name__'): cname = object.__name__ # class
else: cname = object.__class__.__name__ # instance
while lnum < len(code):#-1:
if fname and code[lnum].lstrip().startswith('def '):
# functions and methods
block = inspect.getblock(code[lnum:])
lnum += len(block)
if block[0].lstrip().startswith('def %s(' % fname):
if lstrip: block[0] = block[0].lstrip()
codeblocks.append(block)
# obtypes.append(types.FunctionType)
elif cname and code[lnum].lstrip().startswith('class '):
# classes and instances
block = inspect.getblock(code[lnum:])
lnum += len(block)
_cname = ('class %s(' % cname, 'class %s:' % cname)
if block[0].lstrip().startswith(_cname):
if lstrip: block[0] = block[0].lstrip()
codeblocks.append(block)
elif fname and 'lambda ' in code[lnum]:
# lambdas
block = inspect.getblock(code[lnum:])
lnum += len(block)
lhs,rhs = block[0].split('lambda ',1)[-1].split(":", 1) #FIXME: bad
try: #FIXME: unsafe
_ = eval("lambda %s : %s" % (lhs, rhs), globals(), locals())
except: _ = lambda : "__this_is_a_big_dummy_function__"
if PYTHON3: _ = _.__code__
else: _ = _.func_code
if _.co_code == ocode.co_code:
if lstrip: block[0] = block[0].lstrip()
codeblocks.append(block)
# obtypes.append('<lambda>')
#XXX: would be nice to grab constructor for instance, but yikes.
else:
lnum +=1
#if gettype: return codeblocks, objtypes
return codeblocks #XXX: danger... gets methods and closures w/o containers
def run_command(command, cursor):
args = command.strip().split()
command = args.pop(0).lower()
if command == CMD_QUIT:
shutdown()
elif command == CMD_SET_EXTENDED:
global var_extended
var_extended = bool(args[0].lower() == 'on')
elif command == CMD_SAVE_NEXT:
sys.stderr.write('NOT IMPLEMENTED\n')
elif command == CMD_SET_SAVE_FORMAT:
if len(args) and args[0].lower() in (VALID_OUTPUT_FORMATS + ['csv']):
global var_save_format
var_save_format = args[0].lower()
sys.stdout.write("SAVE_FORMAT = {0}\n".format(var_save_format))
elif command == CMD_SET_OUTPUT_FORMAT:
if len(args) and args[0].lower() in (VALID_OUTPUT_FORMATS + ['csv']):
global var_output_format
var_output_format = args[0].lower()
sys.stdout.write("OUTPUT_FORMAT = {0}\n".format(var_output_format))
elif command == CMD_SAVE_PREV:
path = '/tmp/osql_save'
if len(args):
path = ' '.join(args)
last = readline.get_current_history_length() - 1
sql = readline.get_history_item(last)
print sql
save_query_results(cursor, sql, path)
elif command == CMD_LIST_TABLES:
cursor.execute("SELECT TABLE_NAME, OWNER FROM ALL_TABLES")
rows = cursor.fetchall()
print tabulate(rows, ['Name', 'Owner'], tablefmt='psql')
elif command == CMD_LIST_VIEWS:
SQL = "SELECT VIEW_NAME, OWNER FROM ALL_VIEWS"
if len(args):
SQL += " WHERE VIEW_NAME LIKE '%{0}%'".format(args[0])
cursor.execute(SQL)
rows = cursor.fetchall()
if len(rows) > 1:
print tabulate(rows, ['Name', 'Owner'], tablefmt='psql')
else:
print tabulate(describe(cursor, args[0]),
['name', 'type', 'display_size', 'internal_size',
'precision', 'scale', 'null_ok'], tablefmt='psql')
else:
sys.stderr.write("Unknown command.\n")
def get_history_items():
"""
Get all history item
"""
return [
readline.get_history_item(i)
for i in xrange(1, readline.get_current_history_length() + 1)
]
def history(self):
"""CLI command to print history of previously-executed commands."""
n = readline.get_current_history_length()
for i in range(n):
print(readline.get_history_item(i))
return
def h(recent=25):
"""show command history
recent: number of recent command lines to show.
"""
length = readline.get_current_history_length()
start = 0 if length <= recent else (length - recent)
for x in xrange(start, readline.get_current_history_length()):
print(readline.get_history_item(x + 1))
def write_to_log(self):
if not os.path.isfile(log_file_name):
with open(log_file_name, 'w') as fp:
pass
with open(log_file_name, 'a') as fp:
if readline.get_current_history_length():
fp.write(str(datetime.now()) + '\t' + readline.get_history_item(readline.get_current_history_length()) + '\n')
