helper Namespace Reference

Classes
class	Tutorial

Functions
def	parse_lhs (args)
def	parse_rhs (helper, args)
def	main ()

Variables
	NPROC = multiprocessing.cpu_count()

Function Documentation

main()

def helper.main

(

)

Write custom helper on the fly to trick prefix commands

def main():
    """Write custom helper on the fly to trick prefix commands"""
 
    helper_expl_args, helper_pos_args, rhs_args = parse_lhs(sys.argv[1:])
 
    cmd_args = parse_rhs(helper_pos_args, rhs_args)
 
    if helper_expl_args.verbose:
        print(cmd_args)
 
    # print extensions if requested
    if cmd_args.input_ext or cmd_args.output_ext:
        if cmd_args.input_ext:
            print(" ".join(helper_expl_args.input_ext))
        if cmd_args.output_ext:
            print(" ".join(helper_expl_args.output_ext))
        sys.exit(1)
 
    exp_nargs = len(helper_pos_args) - 1
    got_nargs = len(cmd_args.positional)
    if got_nargs != exp_nargs:
        raise ValueError(
            f"Expected {exp_nargs} argument(s), got {got_nargs} argument(s)."
        )
 
    if helper_expl_args.verbose:
        sys.exit(1)
 
    if cmd_args.print_positional:
        # print the positional arguments
        print(" ".join(cmd_args.positional))
 
 

parse_lhs()

def helper.parse_lhs

(

args

)

Parses arguments until double hyphen.

def parse_lhs(args):
    """Parses arguments until double hyphen."""
 
    main_parser = ArgumentParser(add_help=False)
 
    main_parser.add_argument("-h", "--help", action="store_true")
    main_parser.add_argument("-t", "--tutorial", nargs="?", action=Tutorial)
    main_parser.add_argument("-v", "--verbose", action="store_true")
    main_parser.add_argument("-i", "--input_ext", nargs=1, default=[], action="extend")
    main_parser.add_argument("-o", "--output_ext", nargs=1, default=[], action="extend")
 
    # \todo `-i/o` when `multiple inputs
 
    # custom will be in args
    expl_args, pos_args = main_parser.parse_known_intermixed_args(sys.argv[1:])
 
    if len(sys.argv) == 1 or expl_args.help:
        print(
            "helper exec [input(s)] [output(s)] [args] [-i .ext] [-o .ext] [-j] [-h] [-v] -- [exec options]"
        )
        sys.exit(0)
 
    if not "--" in pos_args:
        raise ValueError("Expecting values after double-hyphen")
 
    sep = pos_args.index("--")
    helper_pos_args = pos_args[:sep]
    cmd_pos_args = pos_args[sep + 1 :]
 
    if expl_args.verbose:
        print("Explicit arguments: " + " ".join(helper_pos_args))
        print("Positional arguments: " + " ".join(cmd_pos_args))
 
    return expl_args, helper_pos_args, cmd_pos_args
 
 

parse_rhs()

def helper.parse_rhs	(		helper,
			args
	)

Parses arguments following the double hyphen.

def parse_rhs(helper, args):
    """Parses arguments following the double hyphen."""
 
    cmd_parser = ArgumentParser(add_help=False)
    cmd_parser.add_argument("positional", nargs="*", type=str)
    cmd_parser.add_argument("-h", "--help", action="store_true")
    cmd_parser.add_argument("-i", "--input_ext", action="store_true")
    cmd_parser.add_argument("-o", "--output_ext", action="store_true")
    cmd_parser.add_argument(
        "-%", "--prefix", nargs=1, type=str, default="", help=argparse.SUPPRESS
    )  # \todo Handle metainfo
    cmd_parser.add_argument(
        "-?", "--print-positional", action="store_true", help=argparse.SUPPRESS
    )
    cmd_args = cmd_parser.parse_intermixed_args(args)
 
    # print helper
    if cmd_args.help or len(args) == 0:
        print(" ".join(helper))
        # \note The detail about positional arguments are not required
        #       by the prefix commands. Some details about explicit
        #       arguments would be needed to implement -j.
        sys.exit(1)  # needed to make the calling script end too
 
    return cmd_args
 
 

Variable Documentation

NPROC

NPROC = multiprocessing.cpu_count()