def test_command_build_argument_help_text(self): def sample_sdk_method_with_weird_docstring(param_a, param_b, param_c): # pylint: disable=unused-argument """ An operation with nothing good. :param dict param_a: :param param_b: The name of nothing. :param param_c: The name of nothing2. """ command_table.clear() setattr(sys.modules[__name__], sample_sdk_method_with_weird_docstring.__name__, sample_sdk_method_with_weird_docstring) #pylint: disable=line-too-long cli_command(None, 'test command foo', '{}#{}'.format(__name__, sample_sdk_method_with_weird_docstring.__name__), None) #pylint: disable=line-too-long command_table['test command foo'].load_arguments() _update_command_definitions(command_table) command_metadata = command_table['test command foo'] self.assertEqual(len(command_metadata.arguments), 3, 'We expected exactly 3 arguments') some_expected_arguments = { 'param_a': CliArgumentType(dest='param_a', required=True, help=''), 'param_b': CliArgumentType(dest='param_b', required=True, help='The name of nothing.'), 'param_c': CliArgumentType(dest='param_c', required=True, help='The name of nothing2.') } for probe in some_expected_arguments: existing = next(arg for arg in command_metadata.arguments if arg == probe) self.assertDictContainsSubset(some_expected_arguments[existing].settings, command_metadata.arguments[existing].options) command_table.clear()
def test_register_cli_argument(self): command_table.clear() cli_command( None, 'test register sample-vm-get', '{}#Test_command_registration.sample_vm_get'.format(__name__)) register_cli_argument( 'test register sample-vm-get', 'vm_name', CliArgumentType(options_list=('--wonky-name', '-n'), metavar='VMNAME', help='Completely WONKY name...', required=False)) command_table['test register sample-vm-get'].load_arguments() _update_command_definitions(command_table) self.assertEqual(len(command_table), 1, 'We expect exactly one command in the command table') command_metadata = command_table['test register sample-vm-get'] self.assertEqual(len(command_metadata.arguments), 4, 'We expected exactly 4 arguments') some_expected_arguments = { 'resource_group_name': CliArgumentType(dest='resource_group_name', required=True), 'vm_name': CliArgumentType(dest='vm_name', required=False), } for probe in some_expected_arguments: existing = next(arg for arg in command_metadata.arguments if arg == probe) self.assertDictContainsSubset( some_expected_arguments[existing].settings, command_metadata.arguments[existing].options) self.assertEqual(command_metadata.arguments['vm_name'].options_list, ('--wonky-name', '-n'))
def test_override_using_register_cli_argument(self): def sample_sdk_method(param_a): # pylint: disable=unused-argument pass def test_validator_completer(): pass command_table.clear() setattr(sys.modules[__name__], sample_sdk_method.__name__, sample_sdk_method) cli_command(None, 'override_using_register_cli_argument foo', '{}#{}'.format(__name__, sample_sdk_method.__name__), None) register_cli_argument('override_using_register_cli_argument', 'param_a', options_list=('--overridden', '-r'), validator=test_validator_completer, completer=test_validator_completer, required=False) command_table[ 'override_using_register_cli_argument foo'].load_arguments() _update_command_definitions(command_table) command_metadata = command_table[ 'override_using_register_cli_argument foo'] self.assertEqual(len(command_metadata.arguments), 1, 'We expected exactly 1 arguments') actual_arg = command_metadata.arguments['param_a'] self.assertEqual(actual_arg.options_list, ('--overridden', '-r')) self.assertEqual(actual_arg.validator, test_validator_completer) self.assertEqual(actual_arg.completer, test_validator_completer) self.assertFalse(actual_arg.options['required']) command_table.clear()
def test_register_extra_cli_argument(self): command_table.clear() cli_command(None, 'test command sample-vm-get', '{}#Test_command_registration.sample_vm_get'.format(__name__), None) register_extra_cli_argument( 'test command sample-vm-get', 'added_param', options_list=('--added-param',), metavar='ADDED', help='Just added this right now!', required=True ) command_table['test command sample-vm-get'].load_arguments() _update_command_definitions(command_table) self.assertEqual(len(command_table), 1, 'We expect exactly one command in the command table') command_metadata = command_table['test command sample-vm-get'] self.assertEqual(len(command_metadata.arguments), 5, 'We expected exactly 5 arguments') some_expected_arguments = { 'added_param': CliArgumentType(dest='added_param', required=True) } for probe in some_expected_arguments: existing = next(arg for arg in command_metadata.arguments if arg == probe) self.assertDictContainsSubset(some_expected_arguments[existing].settings, command_metadata.arguments[existing].options) command_table.clear()
def test_help_long_description_from_docstring(self): """ Verifies that the first sentence of a docstring is extracted as the short description. Verifies that line breaks in the long summary are removed and leaves the text wrapping to the help system. """ def test_handler(): """Short Description. Long description with\nline break.""" pass setattr(sys.modules[__name__], test_handler.__name__, test_handler) cli_command(None, "test", "{}#{}".format(__name__, test_handler.__name__)) _update_command_definitions(command_table) config = Configuration([]) app = Application(config) with self.assertRaises(SystemExit): app.execute("test -h".split()) self.assertEqual( True, io.getvalue().startswith( "\nCommand\n az test: Short Description.\n Long description with line break." ), ) # pylint: disable=line-too-long
def test_command_build_argument_help_text(self): def sample_sdk_method_with_weird_docstring(param_a, param_b, param_c): # pylint: disable=unused-argument """ An operation with nothing good. :param dict param_a: :param param_b: The name of nothing. :param param_c: The name of nothing2. """ command_table.clear() setattr(sys.modules[__name__], sample_sdk_method_with_weird_docstring.__name__, sample_sdk_method_with_weird_docstring) #pylint: disable=line-too-long cli_command(None, 'test command foo', '{}#{}'.format(__name__, sample_sdk_method_with_weird_docstring.__name__), None) #pylint: disable=line-too-long command_table['test command foo'].load_arguments() _update_command_definitions(command_table) command_metadata = command_table['test command foo'] self.assertEqual(len(command_metadata.arguments), 3, 'We expected exactly 3 arguments') some_expected_arguments = { 'param_a': CliArgumentType(dest='param_a', required=True, help=''), 'param_b': CliArgumentType(dest='param_b', required=True, help='The name of nothing.'), 'param_c': CliArgumentType(dest='param_c', required=True, help='The name of nothing2.') } for probe in some_expected_arguments: existing = next(arg for arg in command_metadata.arguments if arg == probe) self.assertDictContainsSubset(some_expected_arguments[existing].settings, command_metadata.arguments[existing].options) command_table.clear()
def test_override_using_register_cli_argument(self): def sample_sdk_method(param_a): # pylint: disable=unused-argument pass def test_validator_completer(): pass command_table.clear() setattr(sys.modules[__name__], sample_sdk_method.__name__, sample_sdk_method) cli_command(None, 'override_using_register_cli_argument foo', '{}#{}'.format(__name__, sample_sdk_method.__name__), None) register_cli_argument('override_using_register_cli_argument', 'param_a', options_list=('--overridden', '-r'), validator=test_validator_completer, completer=test_validator_completer, required=False) command_table['override_using_register_cli_argument foo'].load_arguments() _update_command_definitions(command_table) command_metadata = command_table['override_using_register_cli_argument foo'] self.assertEqual(len(command_metadata.arguments), 1, 'We expected exactly 1 arguments') actual_arg = command_metadata.arguments['param_a'] self.assertEqual(actual_arg.options_list, ('--overridden', '-r')) self.assertEqual(actual_arg.validator, test_validator_completer) self.assertEqual(actual_arg.completer, test_validator_completer) self.assertFalse(actual_arg.options['required']) command_table.clear()
def test_register_cli_argument(self): command_table.clear() cli_command(None, 'test register sample-vm-get', '{}#Test_command_registration.sample_vm_get'.format(__name__)) register_cli_argument('test register sample-vm-get', 'vm_name', CliArgumentType( options_list=('--wonky-name', '-n'), metavar='VMNAME', help='Completely WONKY name...', required=False )) command_table['test register sample-vm-get'].load_arguments() _update_command_definitions(command_table) self.assertEqual(len(command_table), 1, 'We expect exactly one command in the command table') command_metadata = command_table['test register sample-vm-get'] self.assertEqual(len(command_metadata.arguments), 4, 'We expected exactly 4 arguments') some_expected_arguments = { 'resource_group_name': CliArgumentType(dest='resource_group_name', required=True), 'vm_name': CliArgumentType(dest='vm_name', required=False), } for probe in some_expected_arguments: existing = next(arg for arg in command_metadata.arguments if arg == probe) self.assertDictContainsSubset(some_expected_arguments[existing].settings, command_metadata.arguments[existing].options) self.assertEqual(command_metadata.arguments['vm_name'].options_list, ('--wonky-name', '-n'))
def test_register_extra_cli_argument(self): command_table.clear() cli_command( None, 'test command sample-vm-get', '{}#Test_command_registration.sample_vm_get'.format(__name__), None) register_extra_cli_argument('test command sample-vm-get', 'added_param', options_list=('--added-param', ), metavar='ADDED', help='Just added this right now!', required=True) command_table['test command sample-vm-get'].load_arguments() _update_command_definitions(command_table) self.assertEqual(len(command_table), 1, 'We expect exactly one command in the command table') command_metadata = command_table['test command sample-vm-get'] self.assertEqual(len(command_metadata.arguments), 5, 'We expected exactly 5 arguments') some_expected_arguments = { 'added_param': CliArgumentType(dest='added_param', required=True) } for probe in some_expected_arguments: existing = next(arg for arg in command_metadata.arguments if arg == probe) self.assertDictContainsSubset( some_expected_arguments[existing].settings, command_metadata.arguments[existing].options) command_table.clear()
def test_register_cli_argument_with_overrides(self): command_table.clear() global_vm_name_type = CliArgumentType( options_list=('--foo', '-f'), metavar='FOO', help='foo help' ) derived_vm_name_type = CliArgumentType(base_type=global_vm_name_type, help='first modification') cli_command('test vm-get', Test_command_registration.sample_vm_get, None) cli_command('test command vm-get-1', Test_command_registration.sample_vm_get, None) cli_command('test command vm-get-2', Test_command_registration.sample_vm_get, None) register_cli_argument('test', 'vm_name', global_vm_name_type) register_cli_argument('test command', 'vm_name', derived_vm_name_type) register_cli_argument('test command vm-get-2', 'vm_name', derived_vm_name_type, help='second modification') _update_command_definitions(command_table) self.assertEqual(len(command_table), 3, 'We expect exactly three commands in the command table') command1 = command_table['test vm-get'].arguments['vm_name'] command2 = command_table['test command vm-get-1'].arguments['vm_name'] command3 = command_table['test command vm-get-2'].arguments['vm_name'] self.assertTrue(command1.options['help'] == 'foo help') self.assertTrue(command2.options['help'] == 'first modification') self.assertTrue(command3.options['help'] == 'second modification') command_table.clear()
def dump_no_help(modules): cmd_table = APPLICATION.configuration.get_command_table() exit_val = 0 for cmd in cmd_table: cmd_table[cmd].load_arguments() for mod in modules: try: import_module('azure.cli.command_modules.' + mod).load_params(mod) except Exception as ex: print("EXCEPTION: " + str(mod)) _update_command_definitions(cmd_table) command_list = [] subgroups_list = [] parameters = {} for cmd in cmd_table: if not cmd_table[cmd].description and cmd not in helps: command_list.append(cmd) exit_val = 1 group_name = " ".join(cmd.split()[:-1]) if group_name not in helps: exit_val = 1 if group_name not in subgroups_list: subgroups_list.append(group_name) param_list = [] for key in cmd_table[cmd].arguments: if not cmd_table[cmd].arguments[key].type.settings.get('help'): exit_val = 1 param_list.append(cmd_table[cmd].arguments[key].name) if param_list: parameters[cmd] = param_list for cmd in helps: diction_help = yaml.load(helps[cmd]) if "short-summary" in diction_help and "type" in diction_help: if diction_help["type"] == "command" and cmd in command_list: command_list.remove(cmd) elif diction_help["type"] == "group" and cmd in subgroups_list: subgroups_list.remove(cmd) if "parameters" in diction_help: for param in diction_help["parameters"]: if "short-summary" in param and param["name"].split( )[0] in parameters: parameters.pop(cmd, None) data = { "subgroups": subgroups_list, "commands": command_list, "parameters": parameters } print(json.dumps(data, indent=2, sort_keys=True)) return exit_val
def dump_no_help(modules): cmd_table = APPLICATION.configuration.get_command_table() exit_val = 0 for cmd in cmd_table: cmd_table[cmd].load_arguments() for mod in modules: try: import_module('azure.cli.command_modules.' + mod).load_params(mod) except Exception as ex: print("EXCEPTION: " + str(mod)) _update_command_definitions(cmd_table) command_list = [] subgroups_list = [] parameters = {} for cmd in cmd_table: if not cmd_table[cmd].description and cmd not in helps: command_list.append(cmd) exit_val = 1 group_name = " ".join(cmd.split()[:-1]) if group_name not in helps: exit_val = 1 if group_name not in subgroups_list: subgroups_list.append(group_name) param_list = [] for key in cmd_table[cmd].arguments: if not cmd_table[cmd].arguments[key].type.settings.get('help'): exit_val = 1 param_list.append(cmd_table[cmd].arguments[key].name) if param_list: parameters[cmd] = param_list for cmd in helps: diction_help = yaml.load(helps[cmd]) if "short-summary" in diction_help and "type" in diction_help: if diction_help["type"] == "command" and cmd in command_list: command_list.remove(cmd) elif diction_help["type"] == "group" and cmd in subgroups_list: subgroups_list.remove(cmd) if "parameters" in diction_help: for param in diction_help["parameters"]: if "short-summary" in param and param["name"].split()[0] in parameters: parameters.pop(cmd, None) data = { "subgroups" : subgroups_list, "commands" : command_list, "parameters" : parameters } print(json.dumps(data, indent=2, sort_keys=True)) return exit_val
def test_register_cli_argument_with_overrides(self): command_table.clear() global_vm_name_type = CliArgumentType(options_list=('--foo', '-f'), metavar='FOO', help='foo help') derived_vm_name_type = CliArgumentType(base_type=global_vm_name_type, help='first modification') cli_command( None, 'test vm-get', '{}#Test_command_registration.sample_vm_get'.format(__name__), None) cli_command( None, 'test command vm-get-1', '{}#Test_command_registration.sample_vm_get'.format(__name__), None) cli_command( None, 'test command vm-get-2', '{}#Test_command_registration.sample_vm_get'.format(__name__), None) register_cli_argument('test', 'vm_name', global_vm_name_type) register_cli_argument('test command', 'vm_name', derived_vm_name_type) register_cli_argument('test command vm-get-2', 'vm_name', derived_vm_name_type, help='second modification') command_table['test vm-get'].load_arguments() command_table['test command vm-get-1'].load_arguments() command_table['test command vm-get-2'].load_arguments() _update_command_definitions(command_table) self.assertEqual( len(command_table), 3, 'We expect exactly three commands in the command table') command1 = command_table['test vm-get'].arguments['vm_name'] command2 = command_table['test command vm-get-1'].arguments['vm_name'] command3 = command_table['test command vm-get-2'].arguments['vm_name'] self.assertTrue(command1.options['help'] == 'foo help') self.assertTrue(command2.options['help'] == 'first modification') self.assertTrue(command3.options['help'] == 'second modification') command_table.clear()
def set_up_command_table(self, required_arg=False): command_table.clear() module_name = __name__ + '.' + self._testMethodName cli_command(module_name, 'test sample-vm-list', '{}#TestCommandWithConfiguredDefaults.sample_vm_list'.format(__name__)) register_cli_argument('test sample-vm-list', 'resource_group_name', CliArgumentType(options_list=('--resource-group-name', '-g'), configured_default='group', required=required_arg)) command_table['test sample-vm-list'].load_arguments() _update_command_definitions(command_table) self.argv = 'az test sample-vm-list'.split() config = Configuration(self.argv) config.get_command_table = lambda: command_table self.application = Application(config)
def test_help_long_description_from_docstring(self): """ Verifies that the first sentence of a docstring is extracted as the short description. Verifies that line breaks in the long summary are removed and leaves the text wrapping to the help system. """ def test_handler(): """Short Description. Long description with\nline break.""" pass cli_command('test', test_handler) _update_command_definitions(command_table) config = Configuration([]) app = Application(config) with self.assertRaises(SystemExit): app.execute('test -h'.split()) self.assertEqual(True, io.getvalue().startswith('\nCommand\n az test: Short Description.\n Long description with line break.')) # pylint: disable=line-too-long
def install_modules(): for cmd in CMD_TABLE: CMD_TABLE[cmd].load_arguments() try: mods_ns_pkg = import_module('azure.cli.command_modules') installed_command_modules = [ modname for _, modname, _ in pkgutil.iter_modules(mods_ns_pkg.__path__) ] except ImportError: pass for mod in installed_command_modules: try: import_module('azure.cli.command_modules.' + mod).load_params(mod) except Exception: # pylint: disable=broad-except print("Error loading: {}".format(mod)) _update_command_definitions(CMD_TABLE)
def set_up_command_table(self, required_arg=False): command_table.clear() module_name = __name__ + '.' + self._testMethodName cli_command(module_name, 'test sample-vm-list', '{}#TestCommandWithConfiguredDefaults.sample_vm_list'.format(__name__)) register_cli_argument('test sample-vm-list', 'resource_group_name', CliArgumentType(options_list=('--resource-group-name', '-g'), configured_default='group', required=required_arg)) command_table['test sample-vm-list'].load_arguments() _update_command_definitions(command_table) self.argv = 'az test sample-vm-list'.split() config = Configuration() config.get_command_table = lambda argv: command_table self.application = Application(config)
def install_modules(): installed_command_modules = [] for cmd in CMD_TABLE: try: CMD_TABLE[cmd].load_arguments() except (ImportError, ValueError): pass mods_ns_pkg = import_module('azure.cli.command_modules') for _, modname, _ in pkgutil.iter_modules(mods_ns_pkg.__path__): if modname not in BLACKLISTED_MODS: installed_command_modules.append(modname) for mod in installed_command_modules: try: mod = import_module('azure.cli.command_modules.' + mod) mod.load_params(mod) mod.load_commands() except Exception: # pylint: disable=broad-except print("Error loading: {}".format(mod)) _update_command_definitions(CMD_TABLE)
def install_modules(self): installed_command_modules = [] for cmd in self.command_table: try: self.command_table[cmd].load_arguments() except (ImportError, ValueError): pass mods_ns_pkg = import_module('azure.cli.command_modules') for _, modname, _ in pkgutil.iter_modules(mods_ns_pkg.__path__): if modname not in BLACKLISTED_MODS: installed_command_modules.append(modname) for mod in installed_command_modules: try: mod = import_module('azure.cli.command_modules.' + mod) mod.load_params(mod) mod.load_commands() except Exception: # pylint: disable=broad-except print("Error loading: {}".format(mod)) _update_command_definitions(self.command_table)
def _install_modules(command_table): for cmd in command_table: command_table[cmd].load_arguments() try: mods_ns_pkg = import_module('azure.cli.command_modules') installed_command_modules = [ modname for _, modname, _ in pkgutil.iter_modules(mods_ns_pkg.__path__) if modname not in BLACKLISTED_MODS ] except ImportError: pass for mod in installed_command_modules: try: mod = import_module('azure.cli.command_modules.' + mod) mod.load_params(mod) mod.load_commands() except Exception: # pylint: disable=broad-except print("Error loading: {}".format(mod), file=stderr) traceback.print_exc(file=stderr) _update_command_definitions(command_table)
def dump_no_help(modules): APPLICATION.initialize(Configuration()) cmd_table = APPLICATION.configuration.get_command_table() exit_val = 0 for cmd in cmd_table: cmd_table[cmd].load_arguments() for mod in modules: try: import_module('azure.cli.command_modules.' + mod).load_params(mod) except Exception as ex: print("EXCEPTION: " + str(mod)) _update_command_definitions(cmd_table) add_id_parameters(cmd_table) with open(WHITE_DATA_FILE, 'r') as white: white_data = json.load(white) white_list_commands = set(white_data.get('commands', [])) white_list_subgroups = set(white_data.get('subgroups', [])) white_list_parameters = white_data.get('parameters', {}) command_list = set() subgroups_list = set() parameters = {} for cmd in cmd_table: if not cmd_table[cmd].description and cmd not in helps and cmd not in white_list_commands: command_list.add(cmd) exit_val = 1 group_name = " ".join(cmd.split()[:-1]) if group_name not in helps: if group_name not in subgroups_list and group_name not in white_list_subgroups and group_name: exit_val = 1 subgroups_list.add(group_name) param_list = set() for key in cmd_table[cmd].arguments: name = cmd_table[cmd].arguments[key].name if not cmd_table[cmd].arguments[key].type.settings.get('help') and \ name not in white_list_parameters.get(cmd, []): exit_val = 1 param_list.add(name) if param_list: parameters[cmd] = param_list for cmd in helps: diction_help = yaml.load(helps[cmd]) if "short-summary" in diction_help and "type" in diction_help: if diction_help["type"] == "command" and cmd in command_list: command_list.remove(cmd) elif diction_help["type"] == "group" and cmd in subgroups_list: subgroups_list.remove(cmd) if "parameters" in diction_help: for param in diction_help["parameters"]: if "short-summary" in param and param["name"].split()[0] in parameters: parameters.pop(cmd, None) data = { "subgroups": subgroups_list, "commands": command_list, "parameters": parameters } return exit_val, data
def build_command_table(): import azure.cli.core.commands as commands cmd_table = commands.get_command_table() for cmd in cmd_table: cmd_table[cmd].load_arguments() _update_command_definitions(cmd_table) data = {} for cmd in cmd_table: com_descip = {} param_descrip = {} com_descip['short-summary'] = cmd_table[cmd].description() \ if callable(cmd_table[cmd].description) \ else cmd_table[cmd].description or '' com_descip['examples'] = '' for key in cmd_table[cmd].arguments: required = '' help_desc = '' if cmd_table[cmd].arguments[key].type.settings.get('required'): required = '[REQUIRED]' if cmd_table[cmd].arguments[key].type.settings.get('help'): help_desc = cmd_table[cmd].arguments[key].type.settings.get('help') name_options = [] for name in cmd_table[cmd].arguments[key].options_list: name_options.append(name) options = { 'name': name_options, 'required': required, 'help': help_desc } param_descrip[cmd_table[cmd].arguments[key].options_list[0]] = options com_descip['parameters'] = param_descrip data[cmd] = com_descip for cmd in helps: diction_help = yaml.load(helps[cmd]) if cmd not in data: data[cmd] = { 'short-summary': diction_help.get( 'short-summary', ''), 'long-summary': diction_help.get('long-summary', ''), 'parameters': {} } else: data[cmd]['short-summary'] = diction_help.get('short-summary', data[cmd].get('short-summary', '')) data[cmd]['long-summary'] = diction_help.get("long-summary", '') data[cmd]['parameters'] = {} if 'parameters' in diction_help: for param in diction_help["parameters"]: if param['name'].split()[0] not in data[cmd]['parameters']: options = { 'name': name_options, 'required': required, 'help': help_desc } data[cmd]['parameters'] = { param["name"].split()[0]: options } if 'short-summary' in param: data[cmd]['parameters'][param['name'].split()[0]]['help'] \ = param['short-summary'] if 'examples' in diction_help: string_example = '' for example in diction_help['examples']: string_example += example.get('name', '') + '\n' + example.get('text', '') + '\n' data[cmd]['examples'] = string_example return data
def dump_no_help(modules): APPLICATION.initialize(Configuration()) cmd_table = APPLICATION.configuration.get_command_table() exit_val = 0 for cmd in cmd_table: cmd_table[cmd].load_arguments() for mod in modules: try: import_module('azure.cli.command_modules.' + mod).load_params(mod) except Exception as ex: print("EXCEPTION: {} for module {}".format(ex, str(mod))) _update_command_definitions(cmd_table) add_id_parameters(cmd_table) with open(WHITE_DATA_FILE, 'r') as white: white_data = json.load(white) white_list_commands = set(white_data.get('commands', [])) white_list_subgroups = set(white_data.get('subgroups', [])) white_list_parameters = white_data.get('parameters', {}) command_list = set() subgroups_list = set() parameters = {} for cmd in cmd_table: if not cmd_table[ cmd].description and cmd not in helps and cmd not in white_list_commands: command_list.add(cmd) exit_val = 1 group_name = " ".join(cmd.split()[:-1]) if group_name not in helps: if group_name not in subgroups_list and group_name not in white_list_subgroups and group_name: exit_val = 1 subgroups_list.add(group_name) param_list = set() for key in cmd_table[cmd].arguments: name = cmd_table[cmd].arguments[key].name if not cmd_table[cmd].arguments[key].type.settings.get( 'help') and name not in white_list_parameters.get(cmd, []): exit_val = 1 param_list.add(name) if param_list: parameters[cmd] = param_list for cmd in helps: diction_help = yaml.load(helps[cmd]) if "short-summary" in diction_help and "type" in diction_help: if diction_help["type"] == "command" and cmd in command_list: command_list.remove(cmd) elif diction_help["type"] == "group" and cmd in subgroups_list: subgroups_list.remove(cmd) if "parameters" in diction_help: for param in diction_help["parameters"]: if "short-summary" in param and param["name"].split( )[0] in parameters: parameters.pop(cmd, None) data = { "subgroups": subgroups_list, "commands": command_list, "parameters": parameters } return exit_val, data
def dump_command_table(): """ dumps the command table """ global CMD_TABLE cmd_table = CMD_TABLE command_file = config.CONFIGURATION.get_help_files() for cmd in cmd_table: cmd_table[cmd].load_arguments() try: mods_ns_pkg = import_module('azure.cli.command_modules') installed_command_modules = [ modname for _, modname, _ in pkgutil.iter_modules(mods_ns_pkg.__path__) ] except ImportError: pass for mod in installed_command_modules: try: import_module('azure.cli.command_modules.' + mod).load_params(mod) except Exception as ex: print("EXCPETION: " + ex.message) _update_command_definitions(cmd_table) data = {} for cmd in cmd_table: com_descip = {} param_descrip = {} com_descip['help'] = cmd_table[cmd].description com_descip['examples'] = "" for key in cmd_table[cmd].arguments: required = "" help_desc = "" if cmd_table[cmd].arguments[key].type.settings.get('required'): required = "[REQUIRED]" if cmd_table[cmd].arguments[key].type.settings.get('help'): help_desc = cmd_table[cmd].arguments[key].type.settings.get( 'help') name_options = [] for name in cmd_table[cmd].arguments[key].options_list: name_options.append(name) options = { 'name': name_options, 'required': required, 'help': help_desc } param_descrip[ cmd_table[cmd].arguments[key].options_list[0]] = options com_descip['parameters'] = param_descrip data[cmd] = com_descip for cmd in helps: diction_help = yaml.load(helps[cmd]) if "short-summary" in diction_help: if cmd in data: data[cmd]['help'] = diction_help["short-summary"] else: data[cmd] = { 'help': diction_help["short-summary"], 'parameters': {} } if "parameters" in diction_help: for param in diction_help["parameters"]: if param["name"].split()[0] not in data[cmd]['parameters']: options = { 'name': name_options, 'required': required, 'help': help_desc } data[cmd]['parameters'] = { param["name"].split()[0]: options } if "short-summary" in param: data[cmd]['parameters'][param["name"].split()[0]]['help']\ = param["short-summary"] # if "choices" in param: # print("choices") if "examples" in diction_help: examples = [] for example in diction_help["examples"]: examples.append([example['name'], example['text']]) data[cmd]['examples'] = examples with open(os.path.join(get_cache_dir(), command_file), 'w') as help_file: json.dump(data, help_file)