def testCompletionWithSubparser(self): """Verify that completion also works with sub parsers.""" parser = CompletingArgumentParser(prog="subfoo", add_help=False) parser.add_argument("pos") parser.add_argument("--foo", action="store_true") subparsers = parser.add_subparsers() bar = subparsers.add_parser("bar", add_help=False) bar.add_argument("fooz") bar.add_argument("-b", "--baz", action="store_true") foobar = subparsers.add_parser("foobar") foobar.add_argument("--foobar", action="store_true") subparsers2 = foobar.add_subparsers() foobarbaz = subparsers2.add_parser("foobarbaz", add_help=False) foobarbaz.add_argument("--test", action="store_true") self.performCompletion(parser, ["-"], {"--foo"}) self.performCompletion(parser, ["b"], {"bar"}) self.performCompletion(parser, ["bar", ""], {"-b", "--baz"}) self.performCompletion(parser, ["bar", "hallo", ""], {"-b", "--baz"}) self.performCompletion(parser, ["positional", "bar", "hallo", ""], {"-b", "--baz"}) self.performCompletion(parser, ["foobar", ""], {"foobarbaz", "-h", "--foobar", "--help"}) self.performCompletion(parser, ["--foo", "foobar", ""], {"foobarbaz", "-h", "--foobar", "--help"}) self.performCompletion(parser, ["foobar", "--f"], {"--foobar"}) self.performCompletion(parser, ["foobar", "f"], {"foobarbaz"}) self.performCompletion(parser, ["foobar", "--foobar", "foobarbaz", ""], {"--test"}) self.performCompletion(parser, ["--foo", "foobar", "foobarbaz", ""], {"--test"})
def doTest(known_only=False): """Perform the completion test.""" k = {"known_only": known_only} parser = CompletingArgumentParser(prog="foo", add_help=False) parser.add_argument("--foo", action="store_true") self.performCompletion(parser, ["-"], {"--foo"}, **k) parser.add_argument("-b", "--bar", action="store_true") self.performCompletion(parser, ["-"], {"--foo", "-b", "--bar"}, **k) self.performCompletion(parser, ["--"], {"--foo", "--bar"}, **k) self.performCompletion(parser, ["-b"], {"-b"}, **k) self.performCompletion(parser, ["-b", "--foo", "-b"], {"-b"}, **k) self.performCompletion(parser, ["-b", "--foo", ""], {"--foo", "-b", "--bar"}, **k) # Also verify that an error is reported if there is no matching # completion. self.performCompletion(parser, ["--var"], set(), exit_code=1, **k) self.performCompletion(parser, ["-z"], set(), exit_code=1, **k) self.performCompletion(parser, ["-b", "-a"], set(), exit_code=1, **k)
def testCompleteAfterPositional(self): """Verify that a single keyword argument following a positional argument can be completed.""" parser = CompletingArgumentParser(add_help=False) parser.add_argument("positional") parser.add_argument("--foo", action="store_true") self.performCompletion(parser, ["foobar", ""], {"--foo"})
def testHelpCompletion(self): """Verify that the -h/--help arguments can be completed properly.""" parser = CompletingArgumentParser(prog="foo") parser.add_argument("--foo", action="store_true") self.performCompletion(parser, ["-"], {"-h", "--foo", "--help"}) self.performCompletion(parser, ["--h"], {"--help"})
def testCompleteWithCompleter(self): """Verify that the 'completer' argument works as expected.""" def localFileCompleter(parser, values, word): """A completer for files in the current working directory.""" for value in listdir(): if value.startswith(word): yield value def doTest(parser, args): """Perform the completion test.""" with TemporaryDirectory() as dir_,\ NamedTemporaryFile(dir=dir_) as f1,\ NamedTemporaryFile(dir=dir_) as f2,\ NamedTemporaryFile(dir=dir_) as f3,\ NamedTemporaryFile(dir=dir_) as f4,\ NamedTemporaryFile(dir=dir_) as f5: all_files = set(map(basename, {f1.name, f2.name, f3.name, f4.name, f5.name})) old_cwd = getcwd() chdir(dir_) try: self.performCompletion(parser, args + [""], all_files | {"-h", "--help"}) self.performCompletion(parser, args + ["no-file", ""], all_files | {"-h", "--help"}) finally: chdir(old_cwd) parser = CompletingArgumentParser(prog="completer") parser.add_argument("test", completer=localFileCompleter, nargs="+") doTest(parser, []) parser = CompletingArgumentParser(prog="subcompleter") subparsers = parser.add_subparsers() subparser = subparsers.add_parser("subparser") subparser.add_argument("test", completer=localFileCompleter, nargs="+") doTest(parser, ["subparser"])
def testNoArgumentInNamespace(self): """Verify that the completion leaves no argument in the resulting namespace.""" parser = CompletingArgumentParser(prog="test") parser.add_argument("--test", action="store_true") namespace = parser.parse_args(["--test"]) self.assertEqual(vars(namespace), {"test": True})
def testCompleteChoicesForKeyword(self): """Verify that auto completion works if choices are given.""" parser = CompletingArgumentParser(prog="choices") parser.add_argument("--move", choices=("rock", "paper", "scissors")) self.performCompletion(parser, ["--move", ""], {"rock", "paper", "scissors"}) self.performCompletion(parser, ["--move", "p"], {"paper"})
def testCompleteSinglePositionalMax(self): """Verify that parser-level positionals can be exhausted.""" parser = CompletingArgumentParser(prog="posLimited") parser.add_argument("positionals", nargs="?") self.performCompletion(parser, ["-"], {"-h", "--help"}) self.performCompletion(parser, ["pos1", "--"], {"--help"}) self.performCompletion(parser, ["pos1", "pos2", ""], set(), exit_code=1)
def testCompleteAnyPositionals(self): """Verify that we can handle a '*' parser-level positional argument correctly.""" parser = CompletingArgumentParser(prog="posUnlimited") parser.add_argument("positionals", nargs="*") self.performCompletion(parser, ["-"], {"-h", "--help"}) self.performCompletion(parser, ["pos1", "--"], {"--help"}) self.performCompletion(parser, ["pos1", "pos2", ""], {"-h", "--help"})
def testCompleteFixedPositionals(self): """Verify that completion stops after exceeding the maximum parser-level positionals.""" parser = CompletingArgumentParser(prog="posFixed") parser.add_argument("positionals", nargs=3) self.performCompletion(parser, ["-"], {"-h", "--help"}) self.performCompletion(parser, ["pos1", "--"], {"--help"}) self.performCompletion(parser, ["pos1", "pos2", ""], {"-h", "--help"}) self.performCompletion(parser, ["pos1", "pos2", "pos3", ""], {"-h", "--help"}) self.performCompletion(parser, ["pos1", "pos2", "pos3", "pos4", ""], set(), exit_code=1)
def testNonStrChoice(self): """Verify that non-string choices can be completed.""" expected = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"} parser = CompletingArgumentParser(prog="nonStrChoices", add_help=False) parser.add_argument("addends", choices=range(10), nargs="+") self.performCompletion(parser, [""], expected) self.performCompletion(parser, ["1", ""], expected) self.performCompletion(parser, ["1", "9", ""], expected) self.performCompletion(parser, ["1337", "42", ""], expected)
def testKnownArgsParsing(self): """Verify that the parse_known_args method works as expected.""" parser = CompletingArgumentParser(prog="known") parser.add_argument("--foo", action="store_false", default=True) namespace, remainder = parser.parse_known_args(["-f"]) self.assertEqual(vars(namespace), {"foo": True}) self.assertEqual(remainder, ["-f"]) namespace, remainder = parser.parse_known_args(["--foo"]) self.assertEqual(vars(namespace), {"foo": False}) self.assertEqual(remainder, [])
def testCompleteKeywordWithCompleter(self): """Verify that the 'completer' argument works as expected for keyword arguments.""" def completeKeyword(parser, values, word): """A completer function.""" for choice in ("rock", "paper", "scissors"): if choice.startswith(word): yield choice parser = CompletingArgumentParser(prog="keywordcompleter") parser.add_argument("-k", "--keyword", completer=completeKeyword) self.performCompletion(parser, ["-k", ""], {"rock", "paper", "scissors"}) self.performCompletion(parser, ["--keyword", ""], {"rock", "paper", "scissors"}) self.performCompletion(parser, ["-h", "--keyword", "r"], {"rock"})
def testCompleteWithArgumentGroups(self): """Verify that argument groups are considered in completions.""" parser = CompletingArgumentParser(prog="withGroups", add_help=False) parser.add_argument("-t", action="store_true") group1 = parser.add_argument_group("test group 1") group1.add_argument("-f", "--foo", action="store_true") group1.add_argument("-h", "--help", action="store_true") group2 = parser.add_argument_group("test group 2") group2.add_argument("--bar", action="store_true") self.performCompletion(parser, ["-"], {"-f", "-h", "-t", "--bar", "--foo", "--help"}) self.performCompletion(parser, ["--"], {"--bar", "--foo", "--help"}) self.performCompletion(parser, ["-f"], {"-f"})
def testCompleterParserInvocation(self): """Verify that the parser argument in a completer can be used properly.""" def completeParser(parser, values, word): """Dummy completer simply parsing the given 'values' and returning the positional string.""" namespace, _ = parser.parse_known_args(values) yield namespace.positional positional = "pos!" parser = CompletingArgumentParser() parser.add_argument("positional") parser.add_argument("--foo", completer=completeParser) self.performCompletion(parser, [positional, "--foo", ""], {positional}) # Also verify that parser failures (due to a missing positional # argument) are handled correctly. self.performCompletion(parser, ["--foo", ""], set(), exit_code=1)
def testSubparsersCanCompleteSubCommands(self): """Verify that sub parsers can complete arguments themselves.""" root = CompletingArgumentParser(prog="root", add_help=False) root.add_argument("--rootopt", action="store_true") subparsers = root.add_subparsers() sub1 = subparsers.add_parser("sub1", add_help=False, help="Perform sub1.") sub1.add_argument("-s", "--sub1opt", action="store_true") sub2 = subparsers.add_parser("sub2", add_help=False) sub2.add_argument("-s", "--sub2opt", action="store_true") subparsers2 = sub2.add_subparsers() sub21 = subparsers2.add_parser("sub21", help="Perform sub21.") sub21.add_argument("--sub21opt", action="store_true") self.performCompletion(root, [""], {"--rootopt", "sub1", "sub2"}) self.performCompletion(sub1, [""], {"-s", "--sub1opt"}) self.performCompletion(sub1, ["--"], {"--sub1opt"}) self.performCompletion(sub2, [""], {"sub21", "-s", "--sub2opt"}) self.performCompletion(sub21, [""], {"-h", "--help", "--sub21opt"})
def testMultipleArguments(self): """Verify that options with arguments can be handled and completed.""" parser = CompletingArgumentParser() parser.add_argument("--test", nargs=1, type=str) parser.add_argument("-f", nargs="*", type=int) parser.add_argument("-b", "--bar", action="store_true") self.performCompletion(parser, ["--test", ""], set(), exit_code=1)
def testCompleteChoicesForPositional(self): """Verify that choice completion works for parser-level positionals.""" parser = CompletingArgumentParser(prog="choices", add_help=False) parser.add_argument("player") parser.add_argument("move", choices=("rock", "paper", "scissors")) parser.add_argument("--foo", action="store_true") self.performCompletion(parser, ["bar", "--foo", ""], {"rock", "paper", "scissors", "--foo"}) self.performCompletion(parser, ["--foo", ""], {"--foo"}) self.performCompletion(parser, ["--foo", "bar", "s"], {"scissors"})
def testCompleteAfterPositionals(self): """Verify that keyword arguments following positional arguments can be completed.""" parser = CompletingArgumentParser(add_help=False) parser.add_argument("positional1") parser.add_argument("positional2") parser.add_argument("--foo", action="store_true") parser.add_argument("-b", "--bar", action="store_true") self.performCompletion(parser, ["foobar", ""], {"-b", "--bar", "--foo"}) self.performCompletion(parser, ["-b", "foobar", "--"], {"--bar", "--foo"}) self.performCompletion(parser, ["foobar", "bazzer", ""], {"-b", "--bar", "--foo"}) self.performCompletion(parser, ["foobar", "--bar", "bazzer", ""], {"-b", "--bar", "--foo"}) self.performCompletion(parser, ["foobar", "--bar", "bazzer", "booh"], set(), exit_code=1)
sess.run(init_op) # Restore checkpoint tf_helpers.maching_variable_restore(sess, args.checkpoint) # trainer.saver.restore(sess, args.checkpoint) evaluator.evaluation_step(name="Evaluation") if __name__ == "__main__": parser = ArgumentParser(prog='eknog', description="Learning KG embeddings made easy.") subparsers = parser.add_subparsers() parser.add_argument('--debug', action='store_true', help="Activate Tensorflow-Debugging.") # Training Mode train_cmd = subparsers.add_parser( name="train", help="Train a model (new or continue from saved checkpoint)") train_cmd.set_defaults(func=train) train_cmd.add_argument('--model', '-m', type=str, default="TransE", help="Name of model.") train_cmd.add_argument('--dataset', '-d',
def testArgumentsWithAllActions(self): """Check that we can add arguments for all sorts of actions.""" parser = CompletingArgumentParser(add_help=False) parser.add_argument("store", action="store") parser.add_argument("store", action="store", nargs=42) parser.add_argument("store_const", action="store_const", const="foo") parser.add_argument("store_false", action="store_false") parser.add_argument("append", action="append") parser.add_argument("append_const", action="append_const", const="foo") parser.add_argument("count", action="count") parser.add_argument("--store", action="store", dest="store") parser.add_argument("--store2", action="store", nargs=3, dest="store2") parser.add_argument("--store_const", action="store_const", const="foo", dest="store_const") parser.add_argument("--store_false", action="store_false", dest="store_false") parser.add_argument("--append", action="append", dest="append") parser.add_argument("--append_const", action="append_const", const="foo", dest="append_const") parser.add_argument("--count", action="count", dest="count") parser.add_argument("--help", action="help") parser.add_argument("--version", action="version")