Lines Matching refs:parser
142 """Adds parser tests using the class attributes.
148 failures -- a list of args lists that should cause the parser
161 # default parser signature is empty
170 def no_groups(parser, argument_signatures):
171 """Add all arguments directly to the parser"""
173 parser.add_argument(*sig.args, **sig.kwargs)
175 def one_group(parser, argument_signatures):
176 """Add all arguments under a single group in the parser"""
177 group = parser.add_argument_group('foo')
181 def many_groups(parser, argument_signatures):
182 """Add each argument in its own group to the parser"""
184 group = parser.add_argument_group('foo:%i' % i)
190 def listargs(parser, args):
192 return parser.parse_args(args)
194 def sysargs(parser, args):
199 return parser.parse_args()
229 parser = tester.parser_class(*args, **kwargs)
230 self._add_arguments(parser, tester.argument_signatures)
231 return parser
234 parser = self._get_parser(tester)
238 raises(ArgumentParserError, parser.parse_args, args)
241 parser = self._get_parser(tester)
245 result_ns = self._parse_args(parser, args)
1307 """Test actions with a parser-level default of SUPPRESS"""
1327 """Test actions with a parser-level default of 42"""
1638 parser = argparse.ArgumentParser()
1639 parser.register('type', 'my_type', get_my_type)
1640 parser.add_argument('-x', type='my_type')
1641 parser.add_argument('y', type='my_type')
1643 self.assertEqual(parser.parse_args('1'.split()),
1645 self.assertEqual(parser.parse_args('-x 1 42'.split()),
1658 def __call__(self, parser, namespace, value, option_string=None):
1681 def __call__(self, parser, namespace, value, option_string=None):
1725 def __call__(self, parser, namespace, values, option_string=None):
1730 parser = argparse.ArgumentParser()
1731 parser.register('action', 'my_action', self.MyAction)
1732 parser.add_argument('badger', action='my_action')
1734 self.assertEqual(parser.parse_args(['1']), NS(badger='foo[1]'))
1735 self.assertEqual(parser.parse_args(['42']), NS(badger='foo[42]'))
1749 # create a parser with a subparsers argument
1751 parser = ErrorRaisingArgumentParser(
1753 parser.add_argument(
1756 parser = ErrorRaisingArgumentParser(
1758 parser.add_argument(
1760 parser.add_argument(
1764 subparsers = parser.add_subparsers(help='command help')
1765 self.assertArgumentParserError(parser.add_subparsers)
1767 # add first sub-parser
1775 # add second sub-parser
1783 # add third sub-parser
1791 # return the main parser
1792 return parser
1796 self.parser = self._get_parser()
1804 self.assertArgumentParserError(self.parser.parse_args, args)
1809 self.parser.parse_args('0.5 1 b -w 7'.split()),
1813 self.parser.parse_args('0.25 --foo 2 -y 2 3j -- -1j'.split()),
1817 self.parser.parse_args('--foo 0.125 1 c'.split()),
1821 self.parser.parse_args('-1.5 3 11 -- a --foo 7 -- b'.split()),
1827 self.parser.parse_known_args('0.5 1 b -w 7'.split()),
1831 self.parser.parse_known_args('0.5 -p 1 b -w 7'.split()),
1835 self.parser.parse_known_args('0.5 1 b -w 7 -p'.split()),
1839 self.parser.parse_known_args('0.5 1 b -q -rs -w 7'.split()),
1843 self.parser.parse_known_args('0.5 -W 1 b -X Y -w 7 Z'.split()),
1848 parser = ErrorRaisingArgumentParser()
1849 parser.add_argument('--foo', action='store_true')
1850 subparsers = parser.add_subparsers(dest='bar')
1854 parser.parse_args('1 2'.split()))
1857 self.assertEqual(self.parser.format_usage(),
1859 self.assertEqual(self.parser.format_help(), textwrap.dedent('''\
1875 parser = self._get_parser(prefix_chars='+:-')
1876 self.assertEqual(parser.format_usage(),
1878 self.assertEqual(parser.format_help(), textwrap.dedent('''\
1894 parser = self._get_parser(prefix_chars='+:/')
1895 self.assertEqual(parser.format_usage(),
1897 self.assertEqual(parser.format_help(), textwrap.dedent('''\
1933 parser = ErrorRaisingArgumentParser(prog='PROG',
1935 parser.add_argument('--foo', action='store_true', help='foo help')
1936 parser.add_argument('bar', help='bar help')
1937 subparsers = parser.add_subparsers(title='subcommands',
1942 self.assertEqual(parser.format_usage(),
1944 self.assertEqual(parser.format_help(), textwrap.dedent('''\
1964 self.parser.parse_args(args_str.split())
2008 parser = ErrorRaisingArgumentParser()
2009 parser.add_argument('foo')
2010 group = parser.add_argument_group('g')
2012 parser.add_argument('baz')
2014 result = parser.parse_args('1 2 3'.split())
2018 parser = ErrorRaisingArgumentParser()
2019 group = parser.add_argument_group('xxx')
2021 parser.add_argument('bar')
2022 parser.add_argument('baz')
2024 result = parser.parse_args('1 2 3'.split())
2028 parser = ErrorRaisingArgumentParser()
2029 group = parser.add_argument_group('xxx')
2030 parser.add_argument('foo')
2032 parser.add_argument('baz')
2033 group = parser.add_argument_group('yyy')
2036 result = parser.parse_args('1 2 3 4'.split())
2040 # Parent parser tests
2078 parser = ErrorRaisingArgumentParser(parents=[self.wxyz_parent])
2079 self.assertEqual(parser.parse_args('-y 1 2 --w 3'.split()),
2084 parser = ErrorRaisingArgumentParser(parents=[self.ab_mutex_parent])
2085 self._test_mutex_ab(parser.parse_args)
2089 parser = ErrorRaisingArgumentParser(add_help=False, parents=parents)
2090 parser = ErrorRaisingArgumentParser(parents=[parser])
2091 self._test_mutex_ab(parser.parse_args)
2105 parser = ErrorRaisingArgumentParser(parents=parents)
2106 self.assertEqual(parser.parse_args('--d 1 --w 2 3 4'.split()),
2111 parser = ErrorRaisingArgumentParser(parents=parents)
2112 self.assertEqual(parser.parse_args('-a --w 2 3'.split()),
2115 parser.parse_args, '-a --w 2 3 -b'.split())
2117 parser.parse_args, '-a -b --w 2 3'.split())
2133 parser = ErrorRaisingArgumentParser(parents=parents)
2134 self.assertEqual(parser.parse_args('1 2'.split()),
2138 parser = ErrorRaisingArgumentParser()
2139 subparsers = parser.add_subparsers()
2142 self.assertEqual(parser.parse_args('bar -b 1 --d 2 3 4'.split()),
2146 parser = ErrorRaisingArgumentParser()
2147 subparsers = parser.add_subparsers()
2155 self.assertEqual(parser.parse_args('foo -a 4'.split()),
2157 self.assertEqual(parser.parse_args('bar -b --w 2 3 4'.split()),
2160 parser.parse_args, 'foo -a -b 4'.split())
2162 parser.parse_args, 'bar -b -a 4'.split())
2166 parser = ErrorRaisingArgumentParser(parents=parents)
2167 parser_help = parser.format_help()
2196 parser = ErrorRaisingArgumentParser(parents=[parent])
2198 self.assertRaises(ArgumentParserError, parser.parse_args,
2201 parser_help = parser.format_help()
2225 parser = ErrorRaisingArgumentParser()
2227 raises(TypeError, parser.add_mutually_exclusive_group, title='foo')
2230 parser = ErrorRaisingArgumentParser()
2231 group = parser.add_mutually_exclusive_group()
2238 raises(ValueError, add_argument, 'bar', nargs=argparse.PARSER)
2241 parser = ErrorRaisingArgumentParser(prog='PROG')
2242 group1 = parser.add_mutually_exclusive_group()
2245 group2 = parser.add_mutually_exclusive_group()
2258 self.assertEqual(parser.format_help(), textwrap.dedent(expected))
2311 parser = ErrorRaisingArgumentParser(prog='PROG')
2312 group = parser.add_mutually_exclusive_group(required=required)
2315 return parser
2346 parser = ErrorRaisingArgumentParser(prog='PROG')
2347 parser.add_argument('--abcde', help='abcde help')
2348 parser.add_argument('--fghij', help='fghij help')
2349 group = parser.add_mutually_exclusive_group(required=required)
2352 return parser
2389 parser = ErrorRaisingArgumentParser(prog='PROG')
2390 group = parser.add_mutually_exclusive_group(required=required)
2393 return parser
2422 parser = ErrorRaisingArgumentParser(prog='PROG')
2423 group = parser.add_mutually_exclusive_group(required=required)
2428 return parser
2458 parser = ErrorRaisingArgumentParser(prog='PROG')
2459 group = parser.add_mutually_exclusive_group(required=required)
2463 return parser
2503 parser = ErrorRaisingArgumentParser(prog='PROG')
2504 parser.add_argument('-x', action='store_true', help='x help')
2505 group = parser.add_mutually_exclusive_group(required=required)
2508 parser.add_argument('-y', action='store_true', help='y help')
2510 return parser
2545 parser = ErrorRaisingArgumentParser(prog='PROG')
2546 titled_group = parser.add_argument_group(
2552 return parser
2585 parser = ErrorRaisingArgumentParser(prog='PROG')
2586 parser.add_argument('x', help='x help')
2587 parser.add_argument('-y', action='store_true', help='y help')
2588 group = parser.add_mutually_exclusive_group(required=required)
2592 return parser
2624 # Mutually exclusive group in parent parser tests
2631 parser = ErrorRaisingArgumentParser(
2633 return parser
2682 parser = ErrorRaisingArgumentParser()
2683 parser.set_defaults(x='foo')
2684 parser.set_defaults(y='bar', z=1)
2686 parser.parse_args([]))
2688 parser.parse_args([], NS()))
2690 parser.parse_args([], NS(x='baz')))
2692 parser.parse_args([], NS(x='baz', z=2)))
2695 parser = ErrorRaisingArgumentParser()
2696 parser.set_defaults(x='foo', y='bar')
2697 parser.add_argument('-x', default='xfoox')
2699 parser.parse_args([]))
2701 parser.parse_args([], NS()))
2703 parser.parse_args([], NS(x='baz')))
2705 parser.parse_args('-x 1'.split()))
2707 parser.parse_args('-x 1'.split(), NS()))
2709 parser.parse_args('-x 1'.split(), NS(x='baz')))
2712 parser = ErrorRaisingArgumentParser()
2713 parser.set_defaults(x='foo')
2714 subparsers = parser.add_subparsers()
2718 parser.parse_args('a'.split()))
2723 parser = ErrorRaisingArgumentParser(parents=[parent])
2724 self.assertEqual(NS(x='foo'), parser.parse_args([]))
2727 parser = ErrorRaisingArgumentParser()
2728 parser.set_defaults(w='W', x='X', y='Y', z='Z')
2729 parser.add_argument('-w')
2730 parser.add_argument('-x', default='XX')
2731 parser.add_argument('y', nargs='?')
2732 parser.add_argument('z', nargs='?', default='ZZ')
2736 parser.parse_args([]))
2739 parser.set_defaults(w='WW', x='X', y='YY', z='Z')
2741 parser.parse_args([]))
2744 parser = ErrorRaisingArgumentParser()
2745 parser.set_defaults(w='W', x='X', y='Y', z='Z')
2746 group = parser.add_argument_group('foo')
2755 parser.parse_args([]))
2758 parser.set_defaults(w='WW', x='X', y='YY', z='Z')
2760 parser.parse_args([]))
2769 parser = ErrorRaisingArgumentParser()
2770 self.assertEqual(None, parser.get_default("foo"))
2771 self.assertEqual(None, parser.get_default("bar"))
2773 parser.add_argument("--foo")
2774 self.assertEqual(None, parser.get_default("foo"))
2775 self.assertEqual(None, parser.get_default("bar"))
2777 parser.add_argument("--bar", type=int, default=42)
2778 self.assertEqual(None, parser.get_default("foo"))
2779 self.assertEqual(42, parser.get_default("bar"))
2781 parser.set_defaults(foo="badger")
2782 self.assertEqual("badger", parser.get_default("foo"))
2783 self.assertEqual(42, parser.get_default("bar"))
2836 parser = argparse.ArgumentParser(
2840 parser.add_argument(*argument_sig.args,
2844 group = parser.add_argument_group(*group_sig.args,
2851 subparsers = parser.add_subparsers()
2855 return parser
2870 parser = self._get_parser(tester)
2871 format = getattr(parser, 'format_%s' % self.func_suffix)
2875 parser = self._get_parser(tester)
2876 print_ = getattr(parser, 'print_%s' % self.func_suffix)
2887 parser = self._get_parser(tester)
2888 print_ = getattr(parser, 'print_%s' % self.func_suffix)
4027 parser = argparse.ArgumentParser()
4028 self.assertRaises(TypeError, parser.add_argument,
4032 parser = argparse.ArgumentParser()
4033 self.assertRaises(ValueError, parser.add_argument,
4059 parser = argparse.ArgumentParser()
4061 parser.add_argument("--foo", action="store-true")
4069 parser = argparse.ArgumentParser()
4070 parser.add_argument(dest='foo')
4072 parser.add_argument('bar', dest='baz')
4146 parser = argparse.ArgumentParser()
4147 self.assertRaises(Success, parser.add_argument, '--spam',
4149 self.assertRaises(Success, parser.add_argument, 'spam',
4159 parser = argparse.ArgumentParser()
4160 action = parser.add_argument('--foo')
4162 action = parser.add_argument('-b', '--bar')
4164 action = parser.add_argument('-x', '-y')
4168 parser = argparse.ArgumentParser()
4169 action = parser.add_argument('--foo', nargs='?', const=42,
4193 parser = argparse.ArgumentParser()
4194 parser.add_argument('-x')
4196 parser.add_argument, '-x')
4197 parser.add_argument('--spam')
4199 parser.add_argument, '--spam')
4203 parser = get_parser(prog='PROG', conflict_handler='resolve')
4205 parser.add_argument('-x', help='OLD X')
4206 parser.add_argument('-x', help='NEW X')
4207 self.assertEqual(parser.format_help(), textwrap.dedent('''\
4215 parser.add_argument('--spam', metavar='OLD_SPAM')
4216 parser.add_argument('--spam', metavar='NEW_SPAM')
4217 self.assertEqual(parser.format_help(), textwrap.dedent('''\
4242 def assertPrintHelpExit(self, parser, args_str):
4244 parser.format_help(),
4245 self._get_error(parser.parse_args, args_str.split()).stdout)
4247 def assertPrintVersionExit(self, parser, args_str):
4249 parser.format_version(),
4250 self._get_error(parser.parse_args, args_str.split()).stderr)
4252 def assertArgumentParserError(self, parser, *args):
4253 self.assertRaises(ArgumentParserError, parser.parse_args, args)
4256 parser = ErrorRaisingArgumentParser(version='1.0')
4257 self.assertPrintHelpExit(parser, '-h')
4258 self.assertPrintHelpExit(parser, '--help')
4259 self.assertPrintVersionExit(parser, '-v')
4260 self.assertPrintVersionExit(parser, '--version')
4263 parser = ErrorRaisingArgumentParser(prog='PPP', version='%(prog)s 3.5')
4264 msg = self._get_error(parser.parse_args, ['-v']).stderr
4268 parser = ErrorRaisingArgumentParser(add_help=False, version='1.0')
4269 self.assertArgumentParserError(parser, '-h')
4270 self.assertArgumentParserError(parser, '--help')
4271 self.assertPrintVersionExit(parser, '-v')
4272 self.assertPrintVersionExit(parser, '--version')
4275 parser = ErrorRaisingArgumentParser(prog='XXX')
4276 parser.add_argument('-V', action='version', version='%(prog)s 3.7')
4277 msg = self._get_error(parser.parse_args, ['-V']).stderr
4281 parser = ErrorRaisingArgumentParser(add_help=False)
4282 self.assertArgumentParserError(parser, '-h')
4283 self.assertArgumentParserError(parser, '--help')
4284 self.assertArgumentParserError(parser, '-v')
4285 self.assertArgumentParserError(parser, '--version')
4288 parser = ErrorRaisingArgumentParser()
4289 parser.add_argument('-x', action='help')
4290 parser.add_argument('-y', action='version')
4291 self.assertPrintHelpExit(parser, '-x')
4292 self.assertPrintVersionExit(parser, '-y')
4293 self.assertArgumentParserError(parser, '-v')
4294 self.assertArgumentParserError(parser, '--version')
4297 parser = ErrorRaisingArgumentParser(version='1.0')
4298 parser.add_argument('-x', action='store_true')
4299 parser.add_argument('y')
4307 self.assertPrintHelpExit(parser, format % '-h')
4308 self.assertPrintHelpExit(parser, format % '--help')
4309 self.assertPrintVersionExit(parser, format % '-v')
4310 self.assertPrintVersionExit(parser, format % '--version')
4362 parser = argparse.ArgumentParser(prog='PROG')
4367 self.assertStringEqual(parser, string)
4440 parser = ErrorRaisingArgumentParser(prog='PROG', add_help=False)
4441 parser.add_argument('x', type=spam)
4443 parser.parse_args(['XXX'])
4462 parser = argparse.ArgumentParser()
4463 parser.add_argument('--foo', type=spam, default='bar')
4464 args = parser.parse_args('--foo spam!'.split())
4478 parser = argparse.ArgumentParser()
4479 parser.add_argument('--foo', type=spam, default=0)
4480 args = parser.parse_args([])
4488 parser = argparse.ArgumentParser()
4489 parser.add_argument('--foo', type=spam, default='0')
4490 args = parser.parse_args([])
4498 parser = argparse.ArgumentParser()
4499 parser.add_argument('--test', type=extend, default='*')
4500 args = parser.parse_args([])
4510 parser = argparse.ArgumentParser()
4511 parser
4513 args = parser.parse_args([])
4523 parser = argparse.ArgumentParser()
4524 parser.parse_args(())
4527 parser = argparse.ArgumentParser()
4528 parser.parse_args([])
4531 parser = argparse.ArgumentParser()
4532 parser.add_argument('x')
4533 parser.parse_args(('x',))
4536 parser = argparse.ArgumentParser()
4537 parser.add_argument('x')
4538 parser.parse_args(['x'])
4541 parser = argparse.ArgumentParser()
4542 parser.add_argument('--foo')
4543 args, extras = parser.parse_known_args('--foo F --bar --baz'.split())
4548 parser = argparse.ArgumentParser()
4549 parser.add_argument('-v', nargs='?', const=1, type=int)
4550 parser.add_argument('--spam', action='store_false')
4551 parser.add_argument('badger')
4554 args, extras = parser.parse_known_args(argv)
4567 parser = argparse.ArgumentParser()
4568 parser.add_argument("--foo", nargs=nargs, metavar=metavar)
4571 parser = argparse.ArgumentParser()
4573 parser.add_argument("--foo", nargs=nargs, metavar=metavar)
