def get_args_parser():
parser = ArgumentParser(prog='baseline tracker')
parser.add_argument('--checkpoint', type=str, default="",
help="checkpoint model for inference")
parser.add_argument('--search_size', type=int, default=255,
help="size of the template image")
postprocess_parser = ArgumentParser(prog='post process')
postprocess_parser.add_argument('--score_threshold', type=float, default=0.05,
help='the lower score threshold to identify a target (score_target > threshold) ')
postprocess_parser.add_argument('--window_steps', type=int, default=3,
help='the pyramid factor to gradually reduce the widow effect')
postprocess_parser.add_argument('--window_factor', type=float, default=0.4,
help='the factor of the hanning window for heatmap post process')
postprocess_parser.add_argument('--tracking_size_penalty_k', type=float, default=0.04,
help='the factor to penalize the change of size')
postprocess_parser.add_argument('--tracking_size_lpf', type=float, default=0.8,
help='the factor of the lpf for size tracking')
postprocess_parser.add_argument('--multi_frame', type=bool, default=False,
help="(Deprecated) use multi frame for encoder (template images)")
parser.add_argument('--postprocess', action=ActionParser(parser=postprocess_parser))
# TrTr
parser.add_argument('--model', action=ActionParser(parser=trtr_args_parser()))
return parser
def test_subcommand_with_subclass_default_override_lightning_issue_10859(
self):
class Arch:
def __init__(self, a: int = 1):
pass
class ArchB(Arch):
def __init__(self, a: int = 2, b: int = 3):
pass
class ArchC(Arch):
def __init__(self, a: int = 4, c: int = 5):
pass
parser = ArgumentParser(error_handler=None)
parser_subcommands = parser.add_subcommands()
subparser = ArgumentParser()
subparser.add_argument('--arch', type=Arch)
with mock_module(Arch, ArchB, ArchC) as module:
default = {'class_path': f'{module}.ArchB'}
value = {
'class_path': f'{module}.ArchC',
'init_args': {
'a': 10,
'c': 11
}
}
subparser.set_defaults(arch=default)
parser_subcommands.add_subcommand('fit', subparser)
cfg = parser.parse_args(['fit', f'--arch={json.dumps(value)}'])
self.assertEqual(cfg.fit.arch.as_dict(), value)
def test_ActionParser_required(self):
p1 = ArgumentParser()
p1.add_argument('--op1', required=True)
p2 = ArgumentParser(error_handler=None)
p2.add_argument('--op2', action=ActionParser(parser=p1))
p2.parse_args(['--op2.op1=1'])
self.assertRaises(ParserError, lambda: p2.parse_args([]))
def get_parser():
"""Returns the argument parser object for the command line tool."""
## validate parser ##
parser_validate = ModuleArchitecture.get_config_parser()
parser_validate.description = 'Command for checking the validity of neural network module architecture files.'
parser_validate.set_defaults(propagators='default')
parser_validate.add_argument(
'jsonnet_paths',
action=ActionPath(mode='fr'),
nargs='+',
help=
'Path(s) to neural network module architecture file(s) in jsonnet narchi format.'
)
## render parser ##
parser_render = ModuleArchitectureRenderer.get_config_parser()
parser_render.description = 'Command for rendering a neural network module architecture file.'
parser_render.set_defaults(propagators='default')
parser_render.add_argument(
'jsonnet_path',
action=ActionPath(mode='fr'),
help=
'Path to a neural network module architecture file in jsonnet narchi format.'
)
parser_render.add_argument(
'out_file',
nargs='?',
action=ActionPath(mode='fc'),
help=
'Path where to write the architecture diagram (with a valid extension for pygraphviz draw). If '
'unset a pdf is saved to the output directory.')
## schema parser ##
parser_schema = ArgumentParser(
description='Prints a schema as a pretty json.')
parser_schema.add_argument(
'schema',
nargs='?',
default='narchi',
choices=[x for x in schemas.keys() if x is not None],
help='Which of the available schemas to print.')
## global parser ##
parser = ArgumentParser(description=__doc__, version=__version__)
parser.add_argument(
'--stack_trace',
type=bool,
default=False,
help='Whether to print stack trace when there are errors.')
parser.parser_validate = parser_validate
parser.parser_render = parser_render
parser.parser_schema = parser_schema
subcommands = parser.add_subcommands()
subcommands.add_subcommand('validate', parser_validate)
subcommands.add_subcommand('render', parser_render)
subcommands.add_subcommand('schema', parser_schema)
return parser
def test_ActionParser_conflict(self):
parser_lv2 = ArgumentParser()
parser_lv2.add_argument('--op')
parser = ArgumentParser(error_handler=None)
parser.add_argument('--inner.op')
self.assertRaises(
ValueError,
lambda: parser.add_argument('--inner',
action=ActionParser(parser_lv2)))
def test_ActionPath_dump(self):
parser = ArgumentParser()
parser.add_argument('--path', action=ActionPath(mode='fc'))
cfg = parser.parse_string('path: path')
self.assertEqual(parser.dump(cfg), 'path: path\n')
parser = ArgumentParser()
parser.add_argument('--paths', nargs='+', action=ActionPath(mode='fc'))
cfg = parser.parse_args(['--paths', 'path1', 'path2'])
self.assertEqual(parser.dump(cfg), 'paths:\n- path1\n- path2\n')
def test_ActionYesNo(self):
parser = example_parser()
defaults = parser.get_defaults()
self.assertEqual(False, defaults.bools.def_false)
self.assertEqual(True, defaults.bools.def_true)
self.assertEqual(
True,
parser.parse_args(['--bools.def_false']).bools.def_false)
self.assertEqual(
False,
parser.parse_args(['--no_bools.def_false']).bools.def_false)
self.assertEqual(
True,
parser.parse_args(['--bools.def_true']).bools.def_true)
self.assertEqual(
False,
parser.parse_args(['--no_bools.def_true']).bools.def_true)
self.assertEqual(
True,
parser.parse_args(['--bools.def_false=true']).bools.def_false)
self.assertEqual(
False,
parser.parse_args(['--bools.def_false=false']).bools.def_false)
self.assertEqual(
True,
parser.parse_args(['--bools.def_false=yes']).bools.def_false)
self.assertEqual(
False,
parser.parse_args(['--bools.def_false=no']).bools.def_false)
self.assertEqual(
True,
parser.parse_args(['--no_bools.def_true=no']).bools.def_true)
self.assertRaises(ParserError,
lambda: parser.parse_args(['--bools.def_true nope']))
parser = ArgumentParser()
parser.add_argument('--val', action=ActionYesNo)
self.assertEqual(True, parser.parse_args(['--val']).val)
self.assertEqual(False, parser.parse_args(['--no_val']).val)
parser = ArgumentParser()
parser.add_argument('--with-val',
action=ActionYesNo(yes_prefix='with-',
no_prefix='without-'))
self.assertEqual(True, parser.parse_args(['--with-val']).with_val)
self.assertEqual(False, parser.parse_args(['--without-val']).with_val)
parser = ArgumentParser()
self.assertRaises(
ValueError,
lambda: parser.add_argument('--val',
action=ActionYesNo(yes_prefix='yes_')))
self.assertRaises(
ValueError, lambda: parser.add_argument('pos', action=ActionYesNo))
self.assertRaises(
ValueError, lambda: parser.add_argument(
'--val', nargs='?', action=ActionYesNo(no_prefix=None)))
def test_parser_mode_subparsers(self):
subparser = ArgumentParser()
parser = ArgumentParser()
subcommands = parser.add_subcommands()
subcommands.add_subcommand('sub', subparser)
with unittest.mock.patch.dict('jsonargparse.loaders_dumpers.loaders'):
set_loader('custom', yaml.safe_load)
parser.parser_mode = 'custom'
self.assertEqual('custom', parser.parser_mode)
self.assertEqual('custom', subparser.parser_mode)
def test_ActionParser_failures(self):
parser_lv2 = ArgumentParser()
parser_lv2.add_argument('--op')
parser = ArgumentParser(error_handler=None)
parser.add_argument('--inner', action=ActionParser(parser=parser_lv2))
self.assertRaises(
ValueError,
lambda: parser.add_argument('--mistake',
action=ActionParser(parser=parser)))
self.assertRaises(ParserError,
lambda: parser.parse_args(['--inner=1']))
def test_default_help_formatter(self):
parser = ArgumentParser(prog='app', default_env=True)
parser.add_argument('--cfg',
help='Config in yaml/json.',
action=ActionConfigFile)
parser.add_argument('--v1',
help='Option v1.',
default='v1',
required=True)
parser.add_argument('--v2', type=int, help='Option v2.')
parser.add_argument('--g1.v3', help='Option v3.', default='v3')
parser.add_argument('--v4', choices=['A', 'B'], help='Option v4.')
parser2 = ArgumentParser()
parser2.add_argument('--v4')
parser.add_argument('--g2', action=ActionParser(parser=parser2))
parser.add_argument('--v5',
action=ActionYesNo,
default=True,
help='Option v5.')
out = StringIO()
parser.print_help(out)
outval = out.getvalue()
self.assertIn('--print_config', outval)
self.assertIn('--cfg CFG', outval)
self.assertIn('APP_CFG', outval)
self.assertIn('Config in yaml/json.', outval)
self.assertIn('--v1 V1', outval)
self.assertIn('APP_V1', outval)
self.assertIn('Option v1. (required, default: v1)', outval)
self.assertIn('--v2 V2', outval)
self.assertIn('APP_V2', outval)
self.assertIn('Option v2. (type: int, default: null)', outval)
self.assertIn('--g1.v3 V3', outval)
self.assertIn('APP_G1__V3', outval)
self.assertIn('Option v3. (default: v3)', outval)
self.assertIn('--v4 {A,B}', outval)
self.assertIn('APP_V4', outval)
self.assertIn('Option v4. (default: null)', outval)
self.assertIn('--g2.v4 V4', outval)
self.assertIn('APP_G2__V4', outval)
self.assertIn('--v5, --no_v5', outval)
self.assertIn('APP_V5', outval)
self.assertIn('Option v5. (type: bool, default: True)', outval)
def test_list_path(self):
parser = ArgumentParser()
parser.add_argument('--paths', type=List[Path_fc])
cfg = parser.parse_args(['--paths=["file1", "file2"]'])
self.assertEqual(['file1', 'file2'], cfg.paths)
self.assertIsInstance(cfg.paths[0], Path)
self.assertIsInstance(cfg.paths[1], Path)
def test_dump_skip_default(self):
class MyCalendar(Calendar):
def __init__(self, *args, param: str = '0', **kwargs):
super().__init__(*args, **kwargs)
with mock_module(MyCalendar) as module:
parser = ArgumentParser()
parser.add_argument('--g1.op1', default=123)
parser.add_argument('--g1.op2', default='abc')
parser.add_argument('--g2.op1', default=4.5)
parser.add_argument('--g2.op2',
type=Calendar,
default=lazy_instance(Calendar,
firstweekday=2))
cfg = parser.get_defaults()
dump = parser.dump(cfg, skip_default=True)
self.assertEqual(dump, '{}\n')
cfg.g2.op2.class_path = f'{module}.MyCalendar'
dump = parser.dump(cfg, skip_default=True)
self.assertEqual(
dump,
'g2:\n op2:\n class_path: jsonargparse_tests.MyCalendar\n init_args:\n firstweekday: 2\n'
)
cfg.g2.op2.init_args.firstweekday = 0
dump = parser.dump(cfg, skip_default=True)
self.assertEqual(
dump,
'g2:\n op2:\n class_path: jsonargparse_tests.MyCalendar\n')
def test_nargs_questionmark(self):
parser = ArgumentParser(error_handler=None)
parser.add_argument('p1')
parser.add_argument('p2', nargs='?', type=OpenUnitInterval)
self.assertIsNone(parser.parse_args(['a']).p2)
self.assertEqual(0.5, parser.parse_args(['a', '0.5']).p2)
self.assertRaises(ParserError, lambda: parser.parse_args(['a', 'b']))
def test_class_type_subclass_nested_help(self):
class Class:
def __init__(self, cal: Calendar, p1: int = 0):
self.cal = cal
parser = ArgumentParser()
parser.add_argument('--op', type=Class)
for pattern in [r'[\s=]', r'\s']:
with self.subTest('" "' if '=' in pattern else '"="'), mock_module(
Class) as module:
out = StringIO()
args = re.split(
pattern,
f'--op.help={module}.Class --op.init_args.cal.help=TextCalendar'
)
with redirect_stdout(out), self.assertRaises(SystemExit):
parser.parse_args(args)
self.assertIn('--op.init_args.cal.init_args.firstweekday',
out.getvalue())
with self.subTest('invalid'), mock_module(Class) as module:
err = StringIO()
with redirect_stderr(err), self.assertRaises(SystemExit):
parser.parse_args(
[f'--op.help={module}.Class', '--op.init_args.p1=1'])
self.assertIn('Expected a nested --*.help option', err.getvalue())
def test_ActionJsonnet(self):
parser = ArgumentParser(default_meta=False, error_handler=None)
parser.add_argument('--input.ext_vars', action=ActionJsonnetExtVars())
parser.add_argument('--input.jsonnet',
action=ActionJsonnet(
ext_vars='input.ext_vars',
schema=json.dumps(example_schema)))
cfg2 = parser.parse_args([
'--input.ext_vars', '{"param": 123}', '--input.jsonnet',
example_2_jsonnet
])
self.assertEqual(123, cfg2.input.jsonnet['param'])
self.assertEqual(9, len(cfg2.input.jsonnet['records']))
self.assertEqual('#8', cfg2.input.jsonnet['records'][-2]['ref'])
self.assertEqual(15.5, cfg2.input.jsonnet['records'][-2]['val'])
cfg1 = parser.parse_args(['--input.jsonnet', example_1_jsonnet])
self.assertEqual(cfg1.input.jsonnet['records'],
cfg2.input.jsonnet['records'])
self.assertRaises(
ParserError, lambda: parser.parse_args([
'--input.ext_vars', '{"param": "a"}', '--input.jsonnet',
example_2_jsonnet
]))
self.assertRaises(
ParserError,
lambda: parser.parse_args(['--input.jsonnet', example_2_jsonnet]))
self.assertRaises(ValueError, lambda: ActionJsonnet(ext_vars=2))
self.assertRaises(
ValueError,
lambda: ActionJsonnet(schema='.' + json.dumps(example_schema)))
def test_enum(self):
class MyEnum(Enum):
A = 1
B = 2
C = 3
parser = ArgumentParser(error_handler=None)
parser.add_argument('--enum',
type=MyEnum,
default=MyEnum.C,
help='Description')
for val in ['A', 'B', 'C']:
self.assertEqual(MyEnum[val],
parser.parse_args(['--enum=' + val]).enum)
for val in ['X', 'b', 2]:
self.assertRaises(
ParserError, lambda: parser.parse_args(['--enum=' + str(val)]))
cfg = parser.parse_args(['--enum=C'], with_meta=False)
self.assertEqual('enum: C\n', parser.dump(cfg))
help_str = StringIO()
parser.print_help(help_str)
self.assertIn('Description (type: MyEnum, default: C)',
help_str.getvalue())
def test_list(self):
for list_type in [Iterable, List, Sequence]:
with self.subTest(str(list_type)):
parser = ArgumentParser()
parser.add_argument('--list', type=list_type[int])
cfg = parser.parse_args(['--list=[1, 2]'])
self.assertEqual([1, 2], cfg.list)
def test_ActionJsonnet_save(self):
parser = ArgumentParser(error_handler=None)
parser.add_argument('--ext_vars', action=ActionJsonnetExtVars())
parser.add_argument('--jsonnet',
action=ActionJsonnet(ext_vars='ext_vars'))
parser.add_argument('--cfg', action=ActionConfigFile)
jsonnet_file = os.path.join(self.tmpdir, 'example.jsonnet')
with open(jsonnet_file, 'w') as output_file:
output_file.write(example_2_jsonnet)
outdir = os.path.join(self.tmpdir, 'output')
outyaml = os.path.join(outdir, 'main.yaml')
outjsonnet = os.path.join(outdir, 'example.jsonnet')
os.mkdir(outdir)
cfg = parser.parse_args(
['--ext_vars', '{"param": 123}', '--jsonnet', jsonnet_file])
self.assertEqual(str(cfg.jsonnet['__path__']), jsonnet_file)
parser.save(cfg, outyaml)
cfg2 = parser.parse_args(['--cfg', outyaml])
cfg2.cfg = None
self.assertTrue(os.path.isfile(outyaml))
self.assertTrue(os.path.isfile(outjsonnet))
self.assertEqual(strip_meta(cfg), strip_meta(cfg2))
os.unlink(outyaml)
os.unlink(outjsonnet)
parser.save(strip_meta(cfg), outyaml)
cfg3 = parser.parse_args(['--cfg', outyaml])
cfg3.cfg = None
self.assertTrue(os.path.isfile(outyaml))
self.assertTrue(not os.path.isfile(outjsonnet))
self.assertEqual(strip_meta(cfg), strip_meta(cfg3))
def test_class_type_with_default_config_files(self):
config = {
'class_path': 'calendar.Calendar',
'init_args': {
'firstweekday': 3
},
}
config_path = os.path.join(self.tmpdir, 'config.yaml')
with open(config_path, 'w') as f:
json.dump({'data': {'cal': config}}, f)
class MyClass:
def __init__(self, cal: Optional[Calendar] = None, val: int = 2):
self.cal = cal
parser = ArgumentParser(error_handler=None,
default_config_files=[config_path])
parser.add_argument('--op', default='from default')
parser.add_class_arguments(MyClass, 'data')
cfg = parser.get_defaults()
self.assertEqual(config_path, str(cfg['__default_config__']))
self.assertEqual(cfg.data.cal.as_dict(), config)
dump = parser.dump(cfg)
self.assertIn('class_path: calendar.Calendar\n', dump)
self.assertIn('firstweekday: 3\n', dump)
cfg = parser.parse_args([])
self.assertEqual(cfg.data.cal.as_dict(), config)
cfg = parser.parse_args(['--data.cal.class_path=calendar.Calendar'],
defaults=False)
self.assertEqual(cfg.data.cal,
Namespace(class_path='calendar.Calendar'))
def get_parser_lv2():
parser_lv2 = ArgumentParser(description='parser_lv2 description')
parser_lv2.add_argument('--a1', help='lv2_a1 help')
group_lv2 = parser_lv2.add_argument_group(
description='group_lv2 description')
group_lv2.add_argument('--a2', help='lv2_a2 help')
return parser_lv2
def test_class_path_override_with_default_config_files(self):
class MyCalendar(Calendar):
def __init__(self, *args, param: str = '0', **kwargs):
super().__init__(*args, **kwargs)
with mock_module(MyCalendar) as module:
config = {
'class_path': f'{module}.MyCalendar',
'init_args': {
'firstweekday': 2,
'param': '1'
},
}
config_path = os.path.join(self.tmpdir, 'config.yaml')
with open(config_path, 'w') as f:
json.dump({'cal': config}, f)
parser = ArgumentParser(error_handler=None,
default_config_files=[config_path])
parser.add_argument('--cal', type=Optional[Calendar])
cfg = parser.instantiate_classes(parser.get_defaults())
self.assertIsInstance(cfg['cal'], MyCalendar)
cfg = parser.parse_args([
'--cal={"class_path": "calendar.Calendar", "init_args": {"firstweekday": 3}}'
])
self.assertEqual(type(parser.instantiate_classes(cfg)['cal']),
Calendar)
def get_args_parser():
parser = ArgumentParser(prog='benchmark dataset evaluation')
parser.add_argument('--tracker_path',
'-p',
type=str,
default='results',
help='tracker result path')
parser.add_argument('--dataset',
'-d',
type=str,
default='VOT2018',
choices=('VOT2018', 'VOT2019', 'VOT2020', 'OTB', 'UAV',
'NFS', 'TrackingNet', 'LaSOT', 'GOT-10k'),
help='the name of benchmark')
parser.add_argument('--num',
'-n',
default=1,
type=int,
help='number of thread to eval')
parser.add_argument('--tracker_prefix',
'-t',
default='',
type=str,
help='tracker name')
parser.add_argument('--draw_plot', action='store_true')
parser.add_argument('--bold_trackers', default=[], nargs='+')
parser.add_argument('--show_video_level',
'-s',
dest='show_video_level',
action='store_true')
parser.set_defaults(show_video_level=False)
return parser
def test_dict_union(self):
class MyEnum(Enum):
ab = 1
parser = ArgumentParser(error_handler=None)
parser.add_argument('--dict1',
type=Dict[int, Optional[Union[float, MyEnum]]])
parser.add_argument('--dict2', type=Dict[str, Union[bool, Path_fc]])
cfg = parser.parse_args(
['--dict1={"2":4.5, "6":"ab"}', '--dict2={"a":true, "b":"f"}'])
self.assertEqual({2: 4.5, 6: MyEnum.ab}, cfg['dict1'])
self.assertEqual({'a': True, 'b': 'f'}, cfg['dict2'])
self.assertIsInstance(cfg['dict2']['b'], Path)
self.assertEqual({5: None},
parser.parse_args(['--dict1={"5":null}'])['dict1'])
self.assertRaises(ParserError,
lambda: parser.parse_args(['--dict1=["a", "b"]']))
cfg = yaml.safe_load(parser.dump(cfg))
self.assertEqual(
{
'dict1': {
'2': 4.5,
'6': 'ab'
},
'dict2': {
'a': True,
'b': 'f'
}
}, cfg)
def parse_args():
"""Parse command-line arguments."""
parser = ArgumentParser()
parser.add_argument("data_dir", type=str)
parser.add_argument("--n_workers", type=int, default=8)
parser.add_argument("--save_dir", type=str, default=".")
parser.add_argument("--comment", type=str)
parser.add_argument("--frames_per_sample", type=int, default=40)
parser.add_argument("--frames_per_slice", type=int, default=8)
parser.add_argument("--bits", type=int, default=9)
parser.add_argument("--conditioning_channels", type=int, default=128)
parser.add_argument("--embedding_dim", type=int, default=256)
parser.add_argument("--rnn_channels", type=int, default=896)
parser.add_argument("--fc_channels", type=int, default=512)
parser.add_argument("--batch_size", type=int, default=32)
parser.add_argument("--n_steps", type=int, default=100000)
parser.add_argument("--valid_every", type=int, default=1000)
parser.add_argument("--valid_ratio", type=float, default=0.1)
parser.add_argument("--save_every", type=int, default=10000)
parser.add_argument("--learning_rate", type=float, default=4e-4)
parser.add_argument("--decay_every", type=int, default=20000)
parser.add_argument("--decay_gamma", type=float, default=0.5)
parser.add_argument("--training_config", action=ActionConfigFile)
return parser.parse_args()
def test_ActionParser_nested_dash_names(self):
p1 = ArgumentParser(error_handler=None)
p1.add_argument('--op1-like')
p2 = ArgumentParser(error_handler=None)
p2.add_argument('--op2-like', action=ActionParser(parser=p1))
self.assertEqual(
p2.parse_args(['--op2-like.op1-like=a']).op2_like.op1_like, 'a')
p3 = ArgumentParser(error_handler=None)
p3.add_argument('--op3', action=ActionParser(parser=p2))
self.assertEqual(
p3.parse_args(['--op3.op2-like.op1-like=b']).op3.op2_like.op1_like,
'b')
def _test_typehint_non_parameterized_types(self, type):
parser = ArgumentParser(error_handler=None)
ActionTypeHint.is_supported_typehint(type, full=True)
parser.add_argument('--type', type=type)
cfg = parser.parse_args(['--type=uuid.UUID'])
self.assertEqual(cfg.type, uuid.UUID)
self.assertEqual(parser.dump(cfg), 'type: uuid.UUID\n')
def test_ActionYesNo_parse_env(self):
parser = example_parser()
self.assertEqual(
True,
parser.parse_env({
'APP_BOOLS__DEF_FALSE': 'true'
}).bools.def_false)
self.assertEqual(
True,
parser.parse_env({
'APP_BOOLS__DEF_FALSE': 'yes'
}).bools.def_false)
self.assertEqual(
False,
parser.parse_env({
'APP_BOOLS__DEF_TRUE': 'false'
}).bools.def_true)
self.assertEqual(
False,
parser.parse_env({
'APP_BOOLS__DEF_TRUE': 'no'
}).bools.def_true)
parser = ArgumentParser(default_env=True, env_prefix='APP')
parser.add_argument('--op', action=ActionYesNo, default=False)
self.assertEqual(True, parser.parse_env({'APP_OP': 'true'}).op)
def test_class_type_subclass_given_by_name_issue_84(self):
class LocalCalendar(Calendar):
pass
parser = ArgumentParser()
parser.add_argument('--op', type=Union[Calendar, GzipFile, None])
cfg = parser.parse_args(['--op=TextCalendar'])
self.assertEqual(cfg.op.class_path, 'calendar.TextCalendar')
out = StringIO()
parser.print_help(out)
for class_path in [
'calendar.Calendar', 'calendar.TextCalendar', 'gzip.GzipFile'
]:
self.assertIn(class_path, out.getvalue())
self.assertNotIn('LocalCalendar', out.getvalue())
class HTMLCalendar(Calendar):
pass
with mock_module(HTMLCalendar) as module:
err = StringIO()
with redirect_stderr(err), self.assertRaises(SystemExit):
parser.parse_args(['--op.help=HTMLCalendar'])
self.assertIn('Give the full class path to avoid ambiguity',
err.getvalue())
self.assertIn(f'{module}.HTMLCalendar', err.getvalue())
def add_subcommand_from_function(self,
subcommands,
function,
function_name=None):
subcommand = ArgumentParser()
if get_kwarg_name(function) == "data_module_kwargs":
datamodule_function = class_from_function(
function, return_type=self.local_datamodule_class)
subcommand.add_class_arguments(
datamodule_function,
fail_untyped=False,
skip={
"self",
"train_dataset",
"val_dataset",
"test_dataset",
"predict_dataset",
"train_input",
"val_input",
"test_input",
"predict_input",
"input",
"input_transform",
},
)
else:
datamodule_function = class_from_function(
drop_kwargs(function), return_type=self.local_datamodule_class)
subcommand.add_class_arguments(datamodule_function,
fail_untyped=False)
subcommand_name = function_name or function.__name__
subcommands.add_subcommand(subcommand_name, subcommand)
self._subcommand_builders[subcommand_name] = function
def test_bool(self):
parser = ArgumentParser(prog='app',
default_env=True,
error_handler=None)
parser.add_argument('--val', type=bool)
self.assertEqual(None, parser.get_defaults().val)
self.assertEqual(True, parser.parse_args(['--val', 'true']).val)
self.assertEqual(True, parser.parse_args(['--val', 'TRUE']).val)
self.assertEqual(False, parser.parse_args(['--val', 'false']).val)
self.assertEqual(False, parser.parse_args(['--val', 'FALSE']).val)
self.assertRaises(ParserError,
lambda: parser.parse_args(['--val', '1']))
os.environ['APP_VAL'] = 'true'
self.assertEqual(True, parser.parse_args([]).val)
os.environ['APP_VAL'] = 'True'
self.assertEqual(True, parser.parse_args([]).val)
os.environ['APP_VAL'] = 'false'
self.assertEqual(False, parser.parse_args([]).val)
os.environ['APP_VAL'] = 'False'
self.assertEqual(False, parser.parse_args([]).val)
os.environ['APP_VAL'] = '2'
self.assertRaises(ParserError,
lambda: parser.parse_args(['--val', 'a']))
del os.environ['APP_VAL']
