def test_primitive_set_default(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DCPrimitive, DCPrimitive(dl={4, 5}))
dc: DCPrimitive = parser.parse_args([]).root
self.assertSetEqual(dc.l, set())
self.assertSetEqual(dc.dl, {4, 5})
def test_primitive_list_default(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DCPrimitve, DCPrimitve(dl=[4, 5]))
dc: DCPrimitve = parser.parse_args([]).root
self.assertListEqual(dc.l, [])
self.assertListEqual(dc.dl, [4, 5])
def test_ssnake(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", Root)
root: Root = parser.parse_args(["--ssc.p1", "5", "--ssc.c.p2", "7", "--root.sc.p1", "2"]).root
self.assertEqual(5, root.ssc.p1)
self.assertEqual(7, root.ssc.c.p2)
self.assertEqual(2, root.sc.p1)
def test_data_class_list_no_subclass(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DC)
with self.assertRaises(TypeError):
dc: DC = parser.parse_args([
"--root.l",
"test.test_dataclass_list:SubSub",
]).root
def test_invalid_selection(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg", Level1)
with self.assertRaises(TypeError):
# Error that Level1 is not subclass of Level2 (type of arg.l)
args = parser.parse_args(args=[
"--arg.p1", "0", "--arg.l", "test.test_data_class:Level1b"
])
def test_invalid_choice(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg", Level1)
with self.assertRaises(InvalidChoiceError):
# Error that Level1 is not subclass of Level2 (type of arg.l)
args = parser.parse_args(args=[
"--arg.p1", "0", "--arg.l.lvl3",
"test.test_data_class:Level3base"
])
def parse_args(args=None):
parser = PAIArgumentParser()
parser.add_root_argument("root", CrossFoldTrainerParams, CrossFoldTrainerParams())
params: CrossFoldTrainerParams = parser.parse_args(args).root
# TODO: add the training args (omit those params, that are set by the cross fold training)
# setup_train_args(parser, omit=["files", "validation", "weights",
# "early_stopping_best_model_output_dir", "early_stopping_best_model_prefix",
# "output_dir"])
return params
def test_data_class_list_with_default(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DCWithDefault)
dc: DCWithDefault = parser.parse_args([
"--root.l.1.int_arg",
"-4",
]).root
self.assertListEqual([Sub(int_arg=-2), Sub(int_arg=-4)], dc.l)
def test_required_from_default(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg", Level1b, default=Level1b(p1=-13))
args = parser.parse_args(args=[])
dc = args.arg
self.assertIsInstance(dc, Level1b)
self.assertEqual(dc.p1, -13)
self.assertEqual(dc.p2, "")
def test_enum_list(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DifferentTypes)
dt: DifferentTypes = parser.parse_args([
"--root.int_enum_list",
"0",
"B",
]).root
self.assertEqual([IntEnumEx.A, IntEnumEx.B], dt.int_enum_list)
def test_single_dc(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg", Level1b)
args = parser.parse_args(args=["--arg.p1", "0", "--arg.p2", "test"])
dc = args.arg
self.assertIsInstance(dc, Level1b)
self.assertEqual(dc.p1, 0)
self.assertEqual(dc.p2, "test")
def test_dc_with_fixed_flat(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg", DCTestWithFixedFlat)
args = parser.parse_args(args=["--arg.p", "0", "asdf"])
dc = args.arg
self.assertIsInstance(dc.p, Level1b)
self.assertEqual(dc.p.p1, 0)
self.assertEqual(dc.p.p2, "asdf")
def test_three_dc(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg", DCTestMetaLevel1)
args = parser.parse_args(args=["--arg.p", "0", "--arg/sub+p", "0.5"])
self.assertIsInstance(args.arg, DCTestMetaLevel1)
self.assertIsInstance(args.arg.sub, DCTestMetaLevel2)
self.assertEqual(args.arg.p, 0)
self.assertEqual(args.arg.sub.p, "0.5")
def test_str_dataclass_dict_no_subclass(self):
parser = PAIArgumentParser()
parser.add_root_argument("dc", DC)
with self.assertRaises(TypeError):
dc: DC = parser.parse_args([
"--dc.str_dc",
"a=test.test_dict:Sub",
"b=test.test_dict:SubSub",
"c",
]).dc
def test_optionals(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", Base)
base: Base = parser.parse_args([]).root
self.assertIsNone(base.i1)
self.assertEqual(base.i2, -1)
self.assertIsInstance(base.sub1, Sub)
self.assertIsNone(base.sub1.f1)
self.assertIsNone(base.sub2)
def test_two_dc(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg", Level1)
args = parser.parse_args(args=["--arg.l.p1", "-13"])
dc = args.arg
self.assertIsInstance(dc, Level1)
self.assertIsInstance(dc.l, Level2)
self.assertEqual(dc.l.p1, -13)
self.assertIsInstance(dc.l.lvl3, Level3a)
def test_primitive_default(self):
parser = PAIArgumentParser()
parser.add_root_argument("dc", DC, DC(str_int={"daf": 1}))
dc: DC = parser.parse_args([
"--dc.int_str",
"2=qwer",
"3=rewq",
]).dc
self.assertDictEqual({"daf": 1}, dc.str_int)
self.assertDictEqual({2: "qwer", 3: "rewq"}, dc.int_str)
def test_two_dc_change(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg", Level1)
args = parser.parse_args(args=[
"--arg.l.p1", "-13", "--arg.l", "test.test_data_class:Level2a",
"--arg.l.p1a", "0.5"
])
dc = args.arg
r = Level1.from_json(dc.to_json())
self.assertEqual(r, dc)
def test_enum(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DifferentTypes)
dt: DifferentTypes = parser.parse_args([
"--root.int_enum",
"B",
"--root.str_enum",
"test2",
]).root
self.assertEqual(IntEnumEx.B, dt.int_enum)
self.assertEqual(StrEnumEx.B, dt.str_enum)
def test_primitive_list(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DCPrimitve)
dc: DCPrimitve = parser.parse_args([
"--root.l",
"0",
"1",
"0",
]).root
self.assertListEqual(dc.l, [0, 1, 0])
self.assertListEqual(dc.dl, [1, 2])
def test_primitive_set(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DCPrimitive)
dc: DCPrimitive = parser.parse_args([
"--root.l",
"0",
"1",
"0",
]).root
self.assertSetEqual(dc.l, {0, 1, 0})
self.assertSetEqual(dc.dl, {1, 2})
def test_setting_second_level(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg",
Level1,
default=Level1(p1=-1, l=Level2a(p1=-13)))
dc = parser.parse_args(args=["--arg.l.p1a", "-13"]).arg
self.assertIsInstance(dc, Level1)
self.assertIsInstance(dc.l, Level2a)
self.assertEqual(dc.p1, -1)
self.assertEqual(dc.l.p1, -13)
self.assertEqual(dc.l.p1a, -13)
def test_list(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DifferentTypes)
dt: DifferentTypes = parser.parse_args([
"--root.int_list",
"1",
"2",
"--root.str_list",
"test1",
"test2",
]).root
self.assertEqual([1, 2], dt.int_list)
self.assertEqual(["test1", "test2"], dt.str_list)
def test_optionals_args(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", Base)
base: Base = parser.parse_args([
"--root.i1", "2", "--root.i2", "None", "--root.sub2", "Sub",
"--root.sub1", "None"
]).root
self.assertEqual(base.i1, 2)
self.assertIsNone(base.i2)
self.assertIsInstance(base.sub2, Sub)
self.assertIsNone(base.sub2.f1)
self.assertIsNone(base.sub1)
def test_two_dc_change(self):
parser = PAIArgumentParser()
parser.add_root_argument("arg", Level1)
args = parser.parse_args(args=[
"--arg.l.p1", "-13", "--arg.l", "test.test_data_class:Level2a",
"--arg.l.p1a", "0.5"
])
dc = args.arg
self.assertIsInstance(dc, Level1)
self.assertIsInstance(dc.l, Level2a)
self.assertEqual(dc.l.p1, -13)
self.assertEqual(dc.l.p1a, 0.5)
def test_sub_parser(self):
parser = PAIArgumentParser()
sub_parser = parser.add_subparsers(dest="sub", required=True)
sub_parser1: PAIArgumentParser = sub_parser.add_parser("sub1")
sub_parser1.add_root_argument("root", Sub1)
sub_parser2: PAIArgumentParser = sub_parser.add_parser("sub2")
sub_parser2.add_root_argument("root", Sub2)
root = parser.parse_args(args=["sub2"]).root
self.assertIsInstance(root, Sub2)
self.assertEqual(root.q, 5)
def test_primitive(self):
parser = PAIArgumentParser()
parser.add_root_argument("dc", DC)
dc: DC = parser.parse_args([
"--dc.str_int",
"asdf=0",
"fdsa=1",
"--dc.int_str",
"2=qwer",
"3=rewq",
]).dc
self.assertDictEqual({"asdf": 0, "fdsa": 1}, dc.str_int)
self.assertDictEqual({2: "qwer", 3: "rewq"}, dc.int_str)
def test_data_class_list(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DC)
dc: DC = parser.parse_args([
"--root.l",
"test.test_dataclass_list:Sub",
"test.test_dataclass_list:Sub",
"--root.l.1.int_arg",
"-2",
"--root.l.0.sub_sub.int_arg",
"10",
]).root
self.assertListEqual(
[Sub(int_arg=-1, sub_sub=SubSub(int_arg=10)),
Sub(int_arg=-2)], dc.l)
def test_primitives(self):
parser = PAIArgumentParser()
parser.add_root_argument("root", DifferentTypes)
dt: DifferentTypes = parser.parse_args([
"--root.i",
"91",
"--root.f",
"1.2",
"--root.b",
"True",
"--root.oi",
"11",
]).root
self.assertEqual(91, dt.i)
self.assertEqual(1.2, dt.f)
self.assertEqual(True, dt.b)
self.assertEqual(11, dt.oi)
def test_str_dataclass_dict_default(self):
parser = PAIArgumentParser()
parser.add_root_argument(
"dc", DC, DC(str_dc={
"a": Sub(p=1),
"b": Sub2(x="foo")
}))
dc: DC = parser.parse_args([
"--dc.str_dc.a.p",
"5",
]).dc
self.assertListEqual(["a", "b"], list(dc.str_dc.keys()))
self.assertIsInstance(dc.str_dc["a"], Sub)
self.assertIsInstance(dc.str_dc["b"], Sub2)
self.assertEqual(dc.str_dc["a"].p, 5)
self.assertEqual(dc.str_dc["b"].x, "foo")
