def run(self):
module_name, attr_name = self.options["module"], self.options["func"]
parser_creator = getattr(__import__(module_name, fromlist=[attr_name]),
attr_name)
core_result = parse_parser(parser_creator())
core_result["action_groups"] = [
i for i in core_result["action_groups"] if i["title"] not in CUSTOM
]
content = []
for i in core_result["action_groups"]:
content.append(
self._build_table(i["options"], i["title"], i["description"]))
for key, name_to_class in CUSTOM.items():
section = n.section("", ids=["section-{}".format(key)])
title = n.title("", key)
section += title
self.state.document.note_implicit_target(title)
content.append(section)
results = {}
for name, class_n in name_to_class.items():
with self._run_parser(class_n, key, name):
cmd = ["--{}".format(key), name]
parser_result = parse_parser(parser_creator(cmd))
opt_group = next(i["options"]
for i in parser_result["action_groups"]
if i["title"] == key)
results[name] = opt_group
core_names = set.intersection(*list({tuple(i["name"])
for i in v}
for v in results.values()))
if core_names:
rows = [
i for i in next(iter(results.values()))
if tuple(i["name"]) in core_names
]
content.append(
self._build_table(
rows,
title="core",
description="options shared across all {}".format(
key)), )
for name, group in results.items():
rows = [i for i in group if tuple(i["name"]) not in core_names]
if rows:
content.append(
self._build_table(
rows,
title=name,
description="options specific to {} {}".format(
key, name)), )
return content
def test_parse_default():
parser = argparse.ArgumentParser()
parser.add_argument("--foo", default="123")
data = parse_parser(parser)
assert data["action_groups"][0]["options"] == [{"name": ["--foo"], "default": "123", "help": ""}]
def test_parse_nested():
parser = argparse.ArgumentParser()
parser.add_argument("foo", default=False, help="foo help")
parser.add_argument("bar", default=False)
subparsers = parser.add_subparsers()
subparser = subparsers.add_parser("install", help="install help", usage="program install [args]")
subparser.add_argument("ref", type=str, help="foo1 help")
subparser.add_argument("--upgrade", action="store_true", default=False, help="foo2 help")
data = parse_parser(parser)
assert data["args"] == [
{"name": "foo", "help": "foo help", "metavar": None},
{"name": "bar", "help": "", "metavar": None},
]
assert data["children"] == [
{
"name": "install",
"help": "install help",
"usage": "usage: program install [args]",
"bare_usage": "program install [args]",
"args": [{"name": "ref", "help": "foo1 help", "metavar": None}],
"action_groups": [
{
"description": None,
"title": "optional arguments",
"options": [{"default": False, "help": "foo2 help", "name": ["--upgrade"]}],
}
],
}
]
def write_argparse_rst(title_level):
program_root = "bam"
parser = bam.cli.create_argparse()
import sphinxarg.parser as sp
data = sp.parse_parser(parser)
# import pprint
# pprint.pprint(data)
with open(os.path.join(CURRENT_DIR, 'bam_cli_argparse.rst'),
'r',
encoding='utf-8') as f:
main_doc_split = f.read().split("\n")
for i, l in enumerate(main_doc_split):
l_strip = l.lstrip()
if l_strip.startswith(".. %%"):
# ".. %%(foo, bar)%%" --> ("foo", "bar")
subcommands = tuple(
[w.strip() for w in l_strip[3:].strip("%()").split(",")])
l = subcommands_as_rst(data["children"], [program_root],
subcommands, title_level)
main_doc_split[i] = "\n".join(l)
return main_doc_split
def test_parse_default_skip_default():
parser = argparse.ArgumentParser()
parser.add_argument("--foo", default="123")
data = parse_parser(parser, skip_default_values=True)
assert data["action_groups"][0]["options"] == [{"name": ["--foo"], "default": "==SUPPRESS==", "help": ""}]
def test_action_groups_with_subcommands():
"""
This is a somewhat overly complicated example incorporating both action
groups (with optional AND positional arguments) and subcommands (again
with both optional and positional arguments)
"""
parser = argparse.ArgumentParser('foo')
subparsers = parser.add_subparsers()
parserA = subparsers.add_parser('A', help='A subparser')
parserA.add_argument('baz', type=int, help='An integer')
parserB = subparsers.add_parser('B', help='B subparser')
parserB.add_argument('--barg', choices='XYZ', help='A list of choices')
parser.add_argument('--foo', help='foo help')
parser.add_argument('foo2', metavar='foo2 metavar', help='foo2 help')
grp1 = parser.add_argument_group('bar options')
grp1.add_argument('--bar', help='bar help')
grp1.add_argument('quux', help='quux help')
grp2 = parser.add_argument_group('bla options')
grp2.add_argument('--blah', help='blah help')
grp2.add_argument('sniggly', help='sniggly help')
data = parse_parser(parser)
assert data['action_groups'] == [
{'options': [{'default': None, 'name': ['foo2 metavar'], 'help': 'foo2 help'}], 'description': None, 'title': 'Positional Arguments'},
{'options': [{'default': None, 'name': ['--foo'], 'help': 'foo help'}], 'description': None, 'title': 'Named Arguments'},
{'options': [{'default': None, 'name': ['--bar'], 'help': 'bar help'}, {'default': None, 'name': ['quux'], 'help': 'quux help'}], 'description': None, 'title': 'bar options'},
{'options': [{'default': None, 'name': ['--blah'], 'help': 'blah help'}, {'default': None, 'name': ['sniggly'], 'help': 'sniggly help'}], 'description': None, 'title': 'bla options'}
]
assert data['children'] == [
{'usage': 'usage: foo A [-h] baz', 'action_groups': [{'options': [{'default': None, 'name': ['baz'], 'help': 'An integer'}], 'description': None, 'title': 'Positional Arguments'}], 'bare_usage': 'foo A [-h] baz', 'name': 'A', 'help': 'A subparser'},
{'usage': 'usage: foo B [-h] [--barg {X,Y,Z}]', 'action_groups': [{'options': [{'default': None, 'choices': 'XYZ', 'name': ['--barg'], 'help': 'A list of choices'}], 'description': None, 'title': 'Named Arguments'}], 'bare_usage': 'foo B [-h] [--barg {X,Y,Z}]', 'name': 'B', 'help': 'B subparser'}
]
def test_parse_arg_choices():
parser = argparse.ArgumentParser()
parser.add_argument("move", choices=["rock", "paper", "scissors"])
data = parse_parser(parser)
assert data["args"] == [{"name": "move", "help": "", "choices": ["rock", "paper", "scissors"], "metavar": None}]
def test_parse_groups():
parser = argparse.ArgumentParser()
parser.add_argument("--foo", action="store_true", default=False, help="foo help")
parser.add_argument("--bar", action="store_true", default=False)
optional = parser.add_argument_group("Group 1")
optional.add_argument("--option1", help="option #1")
optional.add_argument("--option2", help="option #2")
data = parse_parser(parser)
assert data["action_groups"] == [
{
"description": None,
"options": [
{"default": False, "help": "foo help", "name": ["--foo"]},
{"default": False, "help": "", "name": ["--bar"]},
],
"title": "optional arguments",
},
{
"description": None,
"options": [
{"default": None, "help": "option #1", "name": ["--option1"]},
{"default": None, "help": "option #2", "name": ["--option2"]},
],
"title": "Group 1",
},
]
def test_action_groups_with_subcommands():
"""
This is a somewhat overly complicated example incorporating both action
groups (with optional AND positional arguments) and subcommands (again
with both optional and positional arguments)
"""
parser = argparse.ArgumentParser('foo')
subparsers = parser.add_subparsers()
parserA = subparsers.add_parser('A', help='A subparser')
parserA.add_argument('baz', type=int, help='An integer')
parserB = subparsers.add_parser('B', help='B subparser')
parserB.add_argument('--barg', choices='XYZ', help='A list of choices')
parser.add_argument('--foo', help='foo help')
parser.add_argument('foo2', metavar='foo2 metavar', help='foo2 help')
grp1 = parser.add_argument_group('bar options')
grp1.add_argument('--bar', help='bar help')
grp1.add_argument('quux', help='quux help')
grp2 = parser.add_argument_group('bla options')
grp2.add_argument('--blah', help='blah help')
grp2.add_argument('sniggly', help='sniggly help')
data = parse_parser(parser)
assert data['action_groups'] == [
{'options': [{'default': None, 'name': ['foo2 metavar'], 'help': 'foo2 help'}], 'description': None, 'title': 'Positional Arguments'},
{'options': [{'default': None, 'name': ['--foo'], 'help': 'foo help'}], 'description': None, 'title': 'Named Arguments'},
{'options': [{'default': None, 'name': ['--bar'], 'help': 'bar help'}, {'default': None, 'name': ['quux'], 'help': 'quux help'}], 'description': None, 'title': 'bar options'},
{'options': [{'default': None, 'name': ['--blah'], 'help': 'blah help'}, {'default': None, 'name': ['sniggly'], 'help': 'sniggly help'}], 'description': None, 'title': 'bla options'}
]
assert data['children'] == [
{'usage': 'usage: foo A [-h] baz', 'action_groups': [{'options': [{'default': None, 'name': ['baz'], 'help': 'An integer'}], 'description': None, 'title': 'Positional Arguments'}], 'bare_usage': 'foo A [-h] baz', 'name': 'A', 'help': 'A subparser'},
{'usage': 'usage: foo B [-h] [--barg {X,Y,Z}]', 'action_groups': [{'options': [{'default': None, 'choices': 'XYZ', 'name': ['--barg'], 'help': 'A list of choices'}], 'description': None, 'title': 'Named Arguments'}], 'bare_usage': 'foo B [-h] [--barg {X,Y,Z}]', 'name': 'B', 'help': 'B subparser'}
]
def test_parse_nested_traversal():
parser = argparse.ArgumentParser()
subparsers1 = parser.add_subparsers()
subparser1 = subparsers1.add_parser('level1')
subparsers2 = subparser1.add_subparsers()
subparser2 = subparsers2.add_parser('level2')
subparsers3 = subparser2.add_subparsers()
subparser3 = subparsers3.add_parser('level3')
subparser3.add_argument('foo', help='foo help')
subparser3.add_argument('bar')
data = parse_parser(parser)
data3 = parser_navigate(data, 'level1 level2 level3')
assert data3['action_groups'][0]['options'] == [
{
'name': ['foo'],
'help': 'foo help',
'default': None
}, {
'name': ['bar'],
'help': '',
'default': None
}
]
data2 = parser_navigate(data, 'level1 level2')
assert data2['children'] == [
{
'name': 'level3',
'help': '',
'usage': 'usage: py.test level1 level2 level3 [-h] foo bar',
'bare_usage': 'py.test level1 level2 level3 [-h] foo bar',
'action_groups': [
{
'title': 'Positional Arguments',
'description': None,
'options': [
{
'default': None,
'name': ['foo'],
'help': 'foo help'
}, {
'name': ['bar'],
'help': '',
'default': None
}
]
}
]
}
]
assert data == parser_navigate(data, '')
def test_parse_nested():
parser = argparse.ArgumentParser()
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
subparsers = parser.add_subparsers()
subparser = subparsers.add_parser('install',
help='install help',
usage='program install [args]')
subparser.add_argument('ref', type=str, help='foo1 help')
subparser.add_argument('--upgrade',
action='store_true',
default=False,
help='foo2 help')
data = parse_parser(parser)
assert data['args'] == [
{
'name': 'foo',
'help': 'foo help',
'metavar': None
},
{
'name': 'bar',
'help': '',
'metavar': None
},
]
assert data['children'] == [{
'name':
'install',
'help':
'install help',
'usage':
'usage: program install [args]',
'bare_usage':
'program install [args]',
'args': [
{
'name': 'ref',
'help': 'foo1 help',
'metavar': None
},
],
'action_groups': [{
'description':
None,
'title':
'optional arguments',
'options': [{
'default': False,
'help': 'foo2 help',
'name': ['--upgrade']
}]
}]
}]
def run(self):
if 'module' in self.options and 'func' in self.options:
module_name = self.options['module']
attr_name = self.options['func']
elif 'ref' in self.options:
_parts = self.options['ref'].split('.')
module_name = '.'.join(_parts[0:-1])
attr_name = _parts[-1]
else:
raise self.error(':module: and :func: should be specified, or :ref:')
mod = __import__(module_name, globals(), locals(), [attr_name])
if not hasattr(mod, attr_name):
raise self.error('Module "%s" has no attribute "%s"\nIncorrect argparse :module: or :func: values?' % (module_name, attr_name))
func = getattr(mod, attr_name)
if isinstance(func, ArgumentParser):
parser = func
else:
parser = func()
if not 'path' in self.options:
self.options['path'] = ''
path = str(self.options['path'])
parser.prog = self.options['prog']
result = parse_parser(parser,
skip_default_values='nodefault' in self.options)
result = parser_navigate(result, path)
nested_content = nodes.paragraph()
self.state.nested_parse(self.content, self.content_offset, nested_content)
nested_content = nested_content.children
items = []
# add common content between
for item in nested_content:
if not isinstance(item, nodes.definition_list):
items.append(item)
if 'description' in result:
items.append(nodes.paragraph(text=result['description']))
items.append(nodes.literal_block(text=result['usage']))
items.append(print_command_args_and_opts(
print_arg_list(result, nested_content),
print_opt_list(result, nested_content),
print_subcommand_list(result, nested_content)
))
if 'epilog' in result:
items.append(nodes.paragraph(text=result['epilog']))
return items
def test_parse_nested_traversal():
parser = argparse.ArgumentParser()
subparsers1 = parser.add_subparsers()
subparser1 = subparsers1.add_parser('level1')
subparsers2 = subparser1.add_subparsers()
subparser2 = subparsers2.add_parser('level2')
subparsers3 = subparser2.add_subparsers()
subparser3 = subparsers3.add_parser('level3')
subparser3.add_argument('foo', help='foo help')
subparser3.add_argument('bar')
data = parse_parser(parser)
data3 = parser_navigate(data, 'level1 level2 level3')
assert data3['action_groups'][0]['options'] == [
{
'name': ['foo'],
'help': 'foo help',
'default': None
}, {
'name': ['bar'],
'help': '',
'default': None
}
]
data2 = parser_navigate(data, 'level1 level2')
assert data2['children'] == [
{
'name': 'level3',
'help': '',
'usage': 'usage: py.test level1 level2 level3 [-h] foo bar',
'bare_usage': 'py.test level1 level2 level3 [-h] foo bar',
'action_groups': [
{
'title': 'Positional Arguments',
'description': None,
'options': [
{
'default': None,
'name': ['foo'],
'help': 'foo help'
}, {
'name': ['bar'],
'help': '',
'default': None
}
]
}
]
}
]
assert data == parser_navigate(data, '')
def test_parse_nested_with_alias():
parser = argparse.ArgumentParser()
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
subparsers = parser.add_subparsers()
subparser = subparsers.add_parser('install', aliases=['i'], help='install help')
subparser.add_argument('ref', type=str, help='foo1 help')
subparser.add_argument('--upgrade', action='store_true', default=False, help='foo2 help')
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'name': ['foo'],
'help': 'foo help',
'default': False
}, {
'name': ['bar'],
'help': '',
'default': False
}
]
assert data['children'] == [
{
'name': 'install (i)',
'identifier': 'install',
'help': 'install help',
'usage': 'usage: py.test install [-h] [--upgrade] ref',
'bare_usage': 'py.test install [-h] [--upgrade] ref',
'action_groups': [
{
'title': 'Positional Arguments',
'description': None,
'options': [
{
'name': ['ref'],
'help': 'foo1 help',
'default': None
}
]
},
{
'description': None,
'title': 'Named Arguments',
'options': [
{
'name': ['--upgrade'],
'default': False,
'help': 'foo2 help'
}
]
}
]
}
]
def test_parse_nested_with_alias():
parser = argparse.ArgumentParser()
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
subparsers = parser.add_subparsers()
subparser = subparsers.add_parser('install', aliases=['i'], help='install help')
subparser.add_argument('ref', type=str, help='foo1 help')
subparser.add_argument('--upgrade', action='store_true', default=False, help='foo2 help')
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'name': ['foo'],
'help': 'foo help',
'default': False
}, {
'name': ['bar'],
'help': '',
'default': False
}
]
assert data['children'] == [
{
'name': 'install (i)',
'identifier': 'install',
'help': 'install help',
'usage': 'usage: py.test install [-h] [--upgrade] ref',
'bare_usage': 'py.test install [-h] [--upgrade] ref',
'action_groups': [
{
'title': 'Positional Arguments',
'description': None,
'options': [
{
'name': ['ref'],
'help': 'foo1 help',
'default': None
}
]
},
{
'description': None,
'title': 'Named Arguments',
'options': [
{
'name': ['--upgrade'],
'default': False,
'help': 'foo2 help'
}
]
}
]
}
]
def test_parse_nested_traversal():
parser = argparse.ArgumentParser()
subparsers1 = parser.add_subparsers()
subparser1 = subparsers1.add_parser('level1')
subparsers2 = subparser1.add_subparsers()
subparser2 = subparsers2.add_parser('level2')
subparsers3 = subparser2.add_subparsers()
subparser3 = subparsers3.add_parser('level3')
subparser3.add_argument('foo', help='foo help')
subparser3.add_argument('bar')
data = parse_parser(parser)
data3 = parser_navigate(data, 'level1 level2 level3')
assert data3['args'] == [
{
'name': 'foo',
'help': 'foo help',
'metavar': None
},
{
'name': 'bar',
'help': '',
'metavar': None
},
]
data2 = parser_navigate(data, 'level1 level2')
assert data2['children'] == [{
'name':
'level3',
'help':
'',
'usage':
'usage: py.test level1 level2 level3 [-h] foo bar',
'bare_usage':
'py.test level1 level2 level3 [-h] foo bar',
'args': [
{
'name': 'foo',
'help': 'foo help',
'metavar': None
},
{
'name': 'bar',
'help': '',
'metavar': None
},
],
}]
assert data == parser_navigate(data, '')
def test_parse_opt_choices():
parser = argparse.ArgumentParser()
parser.add_argument("--move", choices=["rock", "paper", "scissors"])
data = parse_parser(parser)
assert data["action_groups"][0]["options"] == [
{"name": ["--move"], "default": None, "help": "", "choices": ["rock", "paper", "scissors"]}
]
def run(self):
if 'module' in self.options and 'func' in self.options:
module_name = self.options['module']
attr_name = self.options['func']
elif 'ref' in self.options:
_parts = self.options['ref'].split('.')
module_name = '.'.join(_parts[0:-1])
attr_name = _parts[-1]
else:
raise self.error(
':module: and :func: should be specified, or :ref:')
mod = __import__(module_name, globals(), locals(), [attr_name])
if not hasattr(mod, attr_name):
raise self.error(
('Module "%s" has no attribute "%s"\n'
'Incorrect argparse :module: or :func: values?') %
(module_name, attr_name))
func = getattr(mod, attr_name)
if isinstance(func, ArgumentParser):
parser = func
elif 'passparser' in self.options:
parser = ArgumentParser()
func(parser)
else:
parser = func()
if 'path' not in self.options:
self.options['path'] = ''
path = str(self.options['path'])
if 'prog' in self.options:
parser.prog = self.options['prog']
result = parse_parser(parser,
skip_default_values='nodefault' in self.options)
result = parser_navigate(result, path)
if 'manpage' in self.options:
return self._construct_manpage_specific_structure(result)
nested_content = nodes.paragraph()
self.state.nested_parse(self.content, self.content_offset,
nested_content)
nested_content = nested_content.children
items = []
# add common content between
for item in nested_content:
if not isinstance(item, nodes.definition_list):
items.append(item)
if 'description' in result:
items.append(self._nested_parse_paragraph(result['description']))
items.append(nodes.literal_block(text=result['usage']))
items.append(
print_command_args_and_opts(
print_arg_list(result, nested_content),
print_opt_list(result, nested_content),
print_subcommand_list(result, nested_content)))
if 'epilog' in result:
items.append(self._nested_parse_paragraph(result['epilog']))
return items
def test_parse_nested_traversal():
parser = argparse.ArgumentParser()
subparsers1 = parser.add_subparsers()
subparser1 = subparsers1.add_parser('level1')
subparsers2 = subparser1.add_subparsers()
subparser2 = subparsers2.add_parser('level2')
subparsers3 = subparser2.add_subparsers()
subparser3 = subparsers3.add_parser('level3')
subparser3.add_argument('foo', help='foo help')
subparser3.add_argument('bar')
data = parse_parser(parser)
data3 = parser_navigate(data, 'level1 level2 level3')
assert data3['args'] == [
{
'name': 'foo',
'help': 'foo help',
'metavar': None
}, {
'name': 'bar',
'help': '',
'metavar': None
}
]
data2 = parser_navigate(data, 'level1 level2')
assert data2['children'] == [
{
'name': 'level3',
'help': '',
'usage': 'usage: py.test level1 level2 level3 [-h] foo bar',
'bare_usage': 'py.test level1 level2 level3 [-h] foo bar',
'args': [
{
'name': 'foo',
'help': 'foo help',
'metavar': None
},
{
'name': 'bar',
'help': '',
'metavar': None
}
]
}
]
assert data == parser_navigate(data, '')
def test_fill_in_description_epilog():
"""
Ensure that %(prog)s gets filled in inside description and epilog.
"""
parser = argparse.ArgumentParser(prog='test_fill_in_description',
description='Welcome to %(prog)s',
epilog='%(prog)s salutes you')
data = parse_parser(parser)
assert data['description'] == 'Welcome to test_fill_in_description'
assert data['epilog'] == 'test_fill_in_description salutes you'
def test_parse_positional():
parser = argparse.ArgumentParser()
parser.add_argument("foo", default=False, help="foo help")
parser.add_argument("bar", default=False)
data = parse_parser(parser)
assert data["args"] == [
{"name": "foo", "help": "foo help", "metavar": None},
{"name": "bar", "help": "", "metavar": None},
]
def test_parse_default():
parser = argparse.ArgumentParser()
parser.add_argument('--foo', default='123')
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [{
'name': ['--foo'],
'default': '"123"',
'help': ''
}]
def test_parse_default_skip_default():
parser = argparse.ArgumentParser()
parser.add_argument('--foo', default='123')
data = parse_parser(parser, skip_default_values=True)
assert data['action_groups'][0]['options'] == [{
'name': ['--foo'],
'default': '==SUPPRESS==',
'help': ''
}]
def test_parse_options():
parser = argparse.ArgumentParser()
parser.add_argument("--foo", action="store_true", default=False, help="foo help")
parser.add_argument("--bar", action="store_true", default=False)
data = parse_parser(parser)
assert data["action_groups"][0]["options"] == [
{"name": ["--foo"], "default": False, "help": "foo help"},
{"name": ["--bar"], "default": False, "help": ""},
]
def test_parse_arg_choices():
parser = argparse.ArgumentParser()
parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
data = parse_parser(parser)
assert data['args'] == [{
'name': 'move',
'help': '',
'choices': ['rock', 'paper', 'scissors'],
'metavar': None
}]
def test_parse_nested():
parser = argparse.ArgumentParser()
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
subparsers = parser.add_subparsers()
subparser = subparsers.add_parser('install', help='install help')
subparser.add_argument('ref', type=str, help='foo1 help')
subparser.add_argument('--upgrade', action='store_true', default=False, help='foo2 help')
data = parse_parser(parser)
assert data['args'] == [
{
'name': 'foo',
'help': 'foo help',
'metavar': None
}, {
'name': 'bar',
'help': '',
'metavar': None
}
]
assert data['children'] == [
{
'name': 'install',
'help': 'install help',
'usage': 'usage: py.test install [-h] [--upgrade] ref',
'bare_usage': 'py.test install [-h] [--upgrade] ref',
'args': [
{
'name': 'ref',
'help': 'foo1 help',
'metavar': None
},
],
'action_groups': [
{
'description': None,
'title': 'optional arguments',
'options': [
{
'name': ['--upgrade'],
'default': False,
'help': 'foo2 help'
},
]
}
]
}
]
def test_parse_default_skip_default():
parser = argparse.ArgumentParser()
parser.add_argument('--foo', default='123')
data = parse_parser(parser, skip_default_values=True)
assert data['action_groups'][0]['options'] == [
{
'name': ['--foo'],
'default': '==SUPPRESS==',
'help': ''
}
]
def test_parse_default():
parser = argparse.ArgumentParser()
parser.add_argument('--foo', default='123')
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'name': ['--foo'],
'default': '"123"',
'help': ''
}
]
def test_parse_arg_choices():
parser = argparse.ArgumentParser()
parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
data = parse_parser(parser)
assert data['args'] == [
{
'name': 'move',
'help': '',
'choices': ['rock', 'paper', 'scissors']
}
]
def test_parse_nested():
parser = argparse.ArgumentParser()
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
subparsers = parser.add_subparsers()
subparser = subparsers.add_parser('install', help='install help')
subparser.add_argument('ref', type=str, help='foo1 help')
subparser.add_argument('--upgrade',
action='store_true',
default=False,
help='foo2 help')
data = parse_parser(parser)
assert data['args'] == [
{
'name': 'foo',
'help': 'foo help'
},
{
'name': 'bar',
'help': ''
},
]
assert data['children'] == [
{
'name':
'install',
'help':
'install help',
'usage':
'usage: py.test install [-h] [--upgrade] ref\n',
'args': [
{
'name': 'ref',
'help': 'foo1 help'
},
],
'options': [
{
'name': ['--upgrade'],
'default': False,
'help': 'foo2 help'
},
]
},
]
def test_parse_opt_choices():
parser = argparse.ArgumentParser()
parser.add_argument('--move', choices=['rock', 'paper', 'scissors'])
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'name': ['--move'],
'default': None,
'help': '',
'choices': ['rock', 'paper', 'scissors']
}
]
def test_parse_opt_choices():
parser = argparse.ArgumentParser()
parser.add_argument('--move', choices=['rock', 'paper', 'scissors'])
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'name': ['--move'],
'default': None,
'help': '',
'choices': ['rock', 'paper', 'scissors']
}
]
def test_fill_in_default_prog():
"""
Ensure that %(default)s and %(prog)s are getting properly filled in inside help=''
"""
parser = argparse.ArgumentParser(prog='test_fill_in_default_prog')
parser.add_argument('bar', default='foo', help='%(prog)s (default: %(default)s)')
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'default': '"foo"',
'name': ['bar'],
'help': 'test_fill_in_default_prog (default: "foo")'
}
]
def test_parse_description():
parser = argparse.ArgumentParser(description="described", epilog="epilogged")
parser.add_argument("foo", default=False, help="foo help")
parser.add_argument("bar", default=False)
data = parse_parser(parser)
assert data["description"] == "described"
assert data["epilog"] == "epilogged"
assert data["args"] == [
{"name": "foo", "help": "foo help", "metavar": None},
{"name": "bar", "help": "", "metavar": None},
]
def test_fill_in_default_prog():
"""
Ensure that %(default)s and %(prog)s are getting properly filled in inside help=''
"""
parser = argparse.ArgumentParser(prog='test_fill_in_default_prog')
parser.add_argument('bar', default='foo', help='%(prog)s (default: %(default)s)')
data = parse_parser(parser)
assert data['args'] == [
{
'metavar': None,
'name': 'bar',
'help': 'test_fill_in_default_prog (default: foo)'
}
]
def test_fill_in_default_prog():
"""
Ensure that %(default)s and %(prog)s are getting properly filled in inside help=''
"""
parser = argparse.ArgumentParser(prog='test_fill_in_default_prog')
parser.add_argument('bar', default='foo', help='%(prog)s (default: %(default)s)')
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'default': '"foo"',
'name': ['bar'],
'help': 'test_fill_in_default_prog (default: "foo")'
}
]
def test_aliased_traversal():
parser = argparse.ArgumentParser()
subparsers1 = parser.add_subparsers()
subparsers1.add_parser('level1', aliases=['l1'])
data = parse_parser(parser)
data2 = parser_navigate(data, 'level1')
assert(data2 == {
'bare_usage': 'py.test level1 [-h]',
'help': '',
'usage': 'usage: py.test level1 [-h]',
'name': 'level1 (l1)',
'identifier': 'level1'})
def test_parse_positional():
parser = argparse.ArgumentParser()
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
data = parse_parser(parser)
assert data['args'] == [
{
'name': 'foo',
'help': 'foo help'
}, {
'name': 'bar',
'help': ''
},
]
def test_parse_positional():
parser = argparse.ArgumentParser()
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [{
'name': ['foo'],
'help': 'foo help',
'default': False
}, {
'name': ['bar'],
'help': '',
'default': False
}]
def test_string_quoting():
"""
If an optional argument has a string type and a default, then the default should be in quotes.
This prevents things like '--optLSFConf=-q short' when '--optLSFConf="-q short"' is correct.
"""
parser = argparse.ArgumentParser(prog='test_string_quoting_prog')
parser.add_argument('--bar', default='foo bar', help='%(prog)s (default: %(default)s)')
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'default': '"foo bar"',
'name': ['--bar'],
'help': 'test_string_quoting_prog (default: "foo bar")'
}
]
def test_aliased_traversal():
parser = argparse.ArgumentParser()
subparsers1 = parser.add_subparsers()
subparsers1.add_parser('level1', aliases=['l1'])
data = parse_parser(parser)
data2 = parser_navigate(data, 'level1')
assert(data2 == {
'bare_usage': 'py.test level1 [-h]',
'help': '',
'usage': 'usage: py.test level1 [-h]',
'name': 'level1 (l1)',
'identifier': 'level1'})
def test_string_quoting():
"""
If an optional argument has a string type and a default, then the default should be in quotes.
This prevents things like '--optLSFConf=-q short' when '--optLSFConf="-q short"' is correct.
"""
parser = argparse.ArgumentParser(prog='test_string_quoting_prog')
parser.add_argument('--bar', default='foo bar', help='%(prog)s (default: %(default)s)')
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'default': '"foo bar"',
'name': ['--bar'],
'help': 'test_string_quoting_prog (default: "foo bar")'
}
]
def test_parse_positional():
parser = argparse.ArgumentParser()
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
data = parse_parser(parser)
assert data['args'] == [
{
'name': 'foo',
'help': 'foo help'
},
{
'name': 'bar',
'help': ''
},
]
def run(self):
mod = __import__(self.options['module'], globals(), locals(),
[self.options['func']])
func = getattr(mod, self.options['func'])
parser = func()
if not 'path' in self.options:
self.options['path'] = ''
path = str(self.options['path'])
parser.prog = self.options['prog']
result = parse_parser(parser,
skip_default_values='nodefault' in self.options)
result = parser_navigate(result, path)
nested_content = nodes.paragraph()
self.state.nested_parse(self.content, self.content_offset,
nested_content)
nested_content = nested_content.children
items = []
# add common content between
for item in nested_content:
if not isinstance(item, nodes.definition_list):
items.append(item)
if 'description' in result:
items.append(nodes.paragraph(text=result['description']))
items.append(nodes.literal_block(text=result['usage']))
items.append(
print_command_args_and_opts(
print_arg_list(result, nested_content),
print_opt_list(result, nested_content),
print_subcommand_list(result, nested_content)))
if 'epilog' in result:
items.append(nodes.paragraph(text=result['epilog']))
return items
def test_parse_options():
parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_true', default=False, help='foo help')
parser.add_argument('--bar', action='store_true', default=False)
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'name': ['--foo'],
'default': False,
'help': 'foo help'
}, {
'name': ['--bar'],
'default': False,
'help': ''
}
]
def test_parse_positional():
parser = argparse.ArgumentParser()
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'name': ['foo'],
'help': 'foo help',
'default': False
}, {
'name': ['bar'],
'help': '',
'default': False
}
]
def test_parse_options():
parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_true', default=False, help='foo help')
parser.add_argument('--bar', action='store_true', default=False)
data = parse_parser(parser)
assert data['action_groups'][0]['options'] == [
{
'name': ['--foo'],
'default': False,
'help': 'foo help'
}, {
'name': ['--bar'],
'default': False,
'help': ''
}
]
def run(self):
mod = __import__(self.options['module'], globals(), locals(), self.options['module'].split('.')[-1:])
func = get_ref(mod, self.options['func'])
parser = func()
if not 'path' in self.options:
self.options['path'] = ''
path = str(self.options['path'])
parser.prog = self.options['prog']
result = parse_parser(parser,
skip_default_values='nodefault' in self.options)
result = parser_navigate(result, path)
nested_content = nodes.paragraph()
self.state.nested_parse(self.content, self.content_offset, nested_content)
nested_content = nested_content.children
items = []
# add common content between
for item in nested_content:
if not isinstance(item, nodes.definition_list):
items.append(item)
if 'description' in result:
items.append(nodes.paragraph(text=result['description']))
items.append(nodes.literal_block(text=result['usage']))
items.append(print_command_args_and_opts(
print_arg_list(result, nested_content),
print_opt_list(result, nested_content),
print_subcommand_list(result, nested_content)
))
if 'epilog' in result:
items.append(nodes.paragraph(text=result['epilog']))
return items
def test_parse_description():
parser = argparse.ArgumentParser(description='described', epilog='epilogged')
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
data = parse_parser(parser)
assert data['description'] == 'described'
assert data['epilog'] == 'epilogged'
assert data['args'] == [
{
'name': 'foo',
'help': 'foo help'
}, {
'name': 'bar',
'help': ''
},
]
def test_parse_groups():
parser = argparse.ArgumentParser()
parser.add_argument('--foo',
action='store_true',
default=False,
help='foo help')
parser.add_argument('--bar', action='store_true', default=False)
optional = parser.add_argument_group('Group 1')
optional.add_argument("--option1", help='option #1')
optional.add_argument("--option2", help='option #2')
data = parse_parser(parser)
assert data['action_groups'] == [{
'description':
None,
'options': [{
'default': False,
'help': 'foo help',
'name': ['--foo']
}, {
'default': False,
'help': '',
'name': ['--bar']
}],
'title':
'Optional Arguments'
}, {
'description':
None,
'options': [{
'default': None,
'help': 'option #1',
'name': ['--option1']
}, {
'default': None,
'help': 'option #2',
'name': ['--option2']
}],
'title':
'Group 1'
}]
def test_parse_description():
parser = argparse.ArgumentParser(description='described',
epilog='epilogged')
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
data = parse_parser(parser)
assert data['description'] == 'described'
assert data['epilog'] == 'epilogged'
assert data['action_groups'][0]['options'] == [{
'name': ['foo'],
'help': 'foo help',
'default': False
}, {
'name': ['bar'],
'help': '',
'default': False
}]
def test_parse_description():
parser = argparse.ArgumentParser(description='described', epilog='epilogged')
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
data = parse_parser(parser)
assert data['description'] == 'described'
assert data['epilog'] == 'epilogged'
assert data['args'] == [
{
'name': 'foo',
'help': 'foo help',
'metavar': None
}, {
'name': 'bar',
'help': '',
'metavar': None
},
]
def test_parse_description():
parser = argparse.ArgumentParser(description='described', epilog='epilogged')
parser.add_argument('foo', default=False, help='foo help')
parser.add_argument('bar', default=False)
data = parse_parser(parser)
assert data['description'] == 'described'
assert data['epilog'] == 'epilogged'
assert data['action_groups'][0]['options'] == [
{
'name': ['foo'],
'help': 'foo help',
'default': False
}, {
'name': ['bar'],
'help': '',
'default': False
}
]
def test_parse_nested_traversal():
parser = argparse.ArgumentParser()
subparsers1 = parser.add_subparsers()
subparser1 = subparsers1.add_parser("level1")
subparsers2 = subparser1.add_subparsers()
subparser2 = subparsers2.add_parser("level2")
subparsers3 = subparser2.add_subparsers()
subparser3 = subparsers3.add_parser("level3")
subparser3.add_argument("foo", help="foo help")
subparser3.add_argument("bar")
data = parse_parser(parser)
data3 = parser_navigate(data, "level1 level2 level3")
assert data3["args"] == [
{"name": "foo", "help": "foo help", "metavar": None},
{"name": "bar", "help": "", "metavar": None},
]
data2 = parser_navigate(data, "level1 level2")
assert data2["children"] == [
{
"name": "level3",
"help": "",
"usage": "usage: py.test level1 level2 level3 [-h] foo bar",
"bare_usage": "py.test level1 level2 level3 [-h] foo bar",
"args": [
{"name": "foo", "help": "foo help", "metavar": None},
{"name": "bar", "help": "", "metavar": None},
],
}
]
assert data == parser_navigate(data, "")
def run(self):
module_name, attr_name, prog = self.options['module'], self.options[
'func'], self.options['prog']
parser = getattr(__import__(module_name, fromlist=[attr_name]),
attr_name)()
result = parse_parser(parser)
table = nodes.table()
t_group = nodes.tgroup(cols=4)
t_group += nodes.colspec(colwidth=1.5)
t_group += nodes.colspec(colwidth=1.5)
t_group += nodes.colspec(colwidth=8)
# header
t_group += nodes.thead(
'',
nodes.row(
'', *[
nodes.entry('', nodes.line(text=c))
for c in ["name", "default", "help"]
]))
# rows
t_body = nodes.tbody()
for option in chain.from_iterable(g['options']
for g in result['action_groups']):
names, default, help_text, choice = option['name'], option[
'default'], option['help'], option.get('choices')
refs, name_nodes = [], []
ref = nodes.paragraph('', '')
first = True
for name in names:
if not first:
ref.append(nodes.Text(', '))
else:
first = False
ref_key = '{} {}'.format(prog, name)
ref_node = nodes.reference('', '', refid=ref_key)
ref_node += nodes.literal(text=name)
ref += ref_node
refs.append(ref_key)
help_body = nodes.paragraph('', '', nodes.Text(help_text))
if choice is not None:
help_body += nodes.Text('; one of: ')
help_body += nodes.literal(text=', '.join(choice))
if default is None:
default_body = nodes.paragraph('', text='')
else:
if default and default[0] == '"' and default[-1] == '"':
default = default[1:-1]
default_body = nodes.literal(text=default)
t_body += nodes.row('',
nodes.entry('', ref),
nodes.entry('', default_body),
nodes.entry('', help_body),
ids=refs)
t_group += t_body
table += t_group
return [nodes.literal_block(text=result['usage']), table]
def run(self):
if 'module' in self.options and 'func' in self.options:
module_name = self.options['module']
attr_name = self.options['func']
elif 'ref' in self.options:
_parts = self.options['ref'].split('.')
module_name = '.'.join(_parts[0:-1])
attr_name = _parts[-1]
elif 'filename' in self.options and 'func' in self.options:
mod = {}
try:
f = open(self.options['filename'])
except IOError:
# try open with abspath
f = open(os.path.abspath(self.options['filename']))
code = compile(f.read(), self.options['filename'], 'exec')
exec(code, mod)
attr_name = self.options['func']
func = mod[attr_name]
else:
raise self.error(
':module: and :func: should be specified, or :ref:, or :filename: and :func:'
)
# Skip this if we're dealing with a local file, since it obviously can't be imported
if 'filename' not in self.options:
try:
mod = __import__(module_name, globals(), locals(), [attr_name])
except:
raise self.error('Failed to import "%s" from "%s".\n%s' %
(attr_name, module_name, sys.exc_info()[1]))
if not hasattr(mod, attr_name):
raise self.error(
('Module "%s" has no attribute "%s"\n'
'Incorrect argparse :module: or :func: values?') %
(module_name, attr_name))
func = getattr(mod, attr_name)
if isinstance(func, ArgumentParser):
parser = func
elif 'passparser' in self.options:
parser = ArgumentParser()
func(parser)
else:
parser = func()
if 'path' not in self.options:
self.options['path'] = ''
path = str(self.options['path'])
if 'prog' in self.options:
parser.prog = self.options['prog']
result = parse_parser(parser,
skip_default_values='nodefault' in self.options,
skip_default_const_values='nodefaultconst'
in self.options)
result = parser_navigate(result, path)
if 'manpage' in self.options:
return self._construct_manpage_specific_structure(result)
# Handle nested content, where markdown needs to be preprocessed
items = []
nested_content = nodes.paragraph()
if 'markdown' in self.options:
from sphinxarg.markdown import parseMarkDownBlock
items.extend(parseMarkDownBlock('\n'.join(self.content) + '\n'))
else:
self.state.nested_parse(self.content, self.content_offset,
nested_content)
nested_content = nested_content.children
# add common content between
for item in nested_content:
if not isinstance(item, nodes.definition_list):
items.append(item)
markDownHelp = False
if 'markdownhelp' in self.options:
markDownHelp = True
if 'description' in result and 'nodescription' not in self.options:
if markDownHelp:
items.extend(renderList([result['description']], True))
else:
items.append(
self._nested_parse_paragraph(result['description']))
items.append(nodes.literal_block(text=result['usage']))
items.extend(
print_action_groups(result,
nested_content,
markDownHelp,
settings=self.state.document.settings))
if 'nosubcommands' not in self.options:
items.extend(
print_subcommands(result,
nested_content,
markDownHelp,
settings=self.state.document.settings))
if 'epilog' in result and 'noepilog' not in self.options:
items.append(self._nested_parse_paragraph(result['epilog']))
# Traverse the returned nodes, modifying the title IDs as necessary to avoid repeats
ensureUniqueIDs(items)
return items
