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_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_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_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):
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 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_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_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 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 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 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
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 = {}
f = open(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"' % (attr_name, module_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, 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)
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 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
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])
file_dependency = mod.__file__
if file_dependency.endswith('.pyc'):
file_dependency = file_dependency[:-1]
env = self.state.document.settings.env
if not hasattr(env, 'argparse_usages'):
env.argparse_usages = []
env.argparse_usages.append({
'docname': env.docname,
'lineno': self.lineno,
'dependency_file': file_dependency,
'dependency_mtime': os.stat(file_dependency).st_mtime,
})
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']))
if 'nosubcommands' in self.options:
subcommands = None
else:
subcommands = print_subcommand_list(result, nested_content)
items.append(print_command_args_and_opts(
print_arg_list(result, nested_content),
print_opt_list(result, nested_content),
subcommands
))
if 'epilog' in result:
items.append(self._nested_parse_paragraph(result['epilog']))
return items
