def print_command_list(self, com_obj):
"""
print the command list of the com_obj reference passed (could be root or even a sub_command reference)
:param com_obj: command object reference
:return:
"""
try:
com_array = []
for com in com_obj:
# if a short reference is present print (short)
# if the command is a ref, ignore it
if "ref" not in com_obj[com]:
com_array.append(com)
# sort the list of commands and print it
com_array.sort()
command_table_arr = []
for com in com_array:
com_t = [utils.green_bold(com)]
have_shorts = "short" in com_obj[com]
if have_shorts:
com_t.append(com_obj[com]["short"])
else:
com_t.append('')
com_t.append(self.print_usage(com_obj[com], only_get=True))
command_table_arr.append(com_t)
print(utils.titlify('help'))
print(
tabulate(command_table_arr, [
utils.white_bold_underline('command'),
utils.white_bold_underline('short'),
utils.white_bold_underline('usage')
],
tablefmt="simple"))
except Exception as e:
print(utils.error_format('print_command_list', str(e)))
def help(self, func_name, *args):
"""
print the help and command usage of the requested command (and sub_command too)
help command_to_get_help [sub_command_to_get_help1 sub_command_to_get_help2]
:param func_name:
:param args:
:return:
"""
# we need at least 1 command to get the help
if args:
try:
# h will keep the command dictionary iteration
# c will keep the deep of the sub_command iteration
h = None
c = 0
prev_h = None
# iterate for every command and sub_command in args
for arg in args:
c += 1
# keep a reference (useful for errors) of command\sub_command name
command = arg
# if we already fetched the first main command
if h:
# if we have a sub_command save the reference so we can iterate into it
if "sub_commands" in h:
if len(h["sub_commands"]) is not 0:
# save the parent command
prev_h = h
h = h["sub_commands"][arg]
else:
raise Exception
else:
raise Exception
# if is the first fetch of the main command just search it on the commands_map dict
# and save the reference. We will start the command root from here
else:
# if the requested command is a "ref" to another command, just keep the right reference
if "ref" in self.core_instance.commands_map[arg]:
h = self.core_instance.commands_map[
self.core_instance.commands_map[arg]["ref"]]
else:
h = self.core_instance.commands_map[arg]
# keep a reference to parent command
prev_h = h
if c > 0:
# if the sub_command is a reference to another associated sub_command
if "ref" in h:
h = prev_h['sub_commands'][h['ref']]
# print help and usage passing h, the command object reference
print(utils.titlify(command))
print(h["help"])
self.print_usage(h)
# if there are sub_commands print a list of them
if "sub_commands" in h:
self.print_command_list(h["sub_commands"])
except Exception as e:
print(utils.error_format(func_name, str(e)))
print("no help for command '" + command + "'" + ' found')
# if we have no args (so no commands) just print the commands list
else:
self.print_command_list(self.core_instance.commands_map)
def exec_command(self, command, args):
"""
the core method of commands exec, it tries to fetch the requested command,
bind to the right context and call the associated function
TODO:
:param command: requested command
:param args: arguments array
:return:
"""
# save the found command and sub_command array
complete_command_array = [command]
try:
if command == '':
return
if command in self.commands_map:
# if we found the command but has the "ref" property,
# so we need to reference to another object. Ex. short command q --references--> quit
if 'ref' in self.commands_map[command]:
com = self.commands_map[self.commands_map[command]['ref']]
else:
com = self.commands_map[command]
# if we have no arguments no sub_command exist, else save the first argument
last_function = False
if len(args) > 0:
possible_sub_command = args[0]
else:
possible_sub_command = None
# now iterate while we have a valid sub_command,
# when we don't find a valid sub_command exit and the new command will be the sub_command
# save the sub_command parent
prev_command = com
while last_function is False:
# if the sub command is a ref, catch the right command
if 'ref' in com:
com = prev_command['sub_commands'][com['ref']]
if 'sub_commands' in com and possible_sub_command:
if possible_sub_command in com['sub_commands']:
prev_command = com
com = com['sub_commands'][possible_sub_command]
# pop the found sub_command so we can iterate on the remanings arguments
complete_command_array.append(args.pop(0))
command = possible_sub_command
# if there are arguments left
if len(args) > 0:
# take the first args (the next sub_command)
possible_sub_command = args[0]
else:
last_function = True
else:
last_function = True
else:
last_function = True
# if the sub_command is a reference to another associated sub_command
if 'ref' in com:
com = prev_command['sub_commands'][com['ref']]
# if we have a function field just fetch the context and the function name,
# bind them and call the function passing the arguments
if 'function' in com:
if 'args' in com['function']:
args_check, args_error = utils.check_args(
com['function']['args'], args)
if args_check is False:
raise Exception(args_error)
context = self.context_map[com["function"]["context"]]
funct = com["function"]["f"]
call_method = getattr(context, funct)
# we pass the command name (could be useful for the called function)
# and possible arguments to the function
call_method(command, *args)
else:
# if we have no method implementation of the command
# print the help of the command
# passing all the arguments list to help function (including the command) in a unique array
self.exec_command('help', complete_command_array)
else:
print("command '" + command + "' not found")
except Exception as e:
if isinstance(e, UcError):
print(utils.titlify('uc error'))
print(str(e))
else:
print(utils.error_format('exec_command', str(e)))
self.exec_command('help', complete_command_array)