Dividing large program into subcommands with argparse

Question

I want to use six subcommands (using subparsers from the argparse library) to divide my large program into smaller independent programs, and be able to run them individually. In other words, I envision running six commands from the command line one after the other, where the results of each command feed in as arguments of the next one. (Or if that is not possible with argparse, then at least some way of running each of the six parts independently).

I had no problem with one parser, but when trying to understand how to use subparsers for this task I found the documentation too confusing.

Currently my code is something like

import argparse
from my_functions import (func_a, func_b, func_c, func_d, func_e, func_f)

parser = argparse.ArgumentParser()  # Top level parser
subparsers = parser.add_subparsers()

parser_a = subparsers.add_parser('parser_a', help='parser_a_help')
parser_a.set_defaults(func=func_a)
parser_a.add_argument('a_arg', type=int)

parser_b = subparsers.add_parser('parser_b', help='parser_b_help')
           parser_b.set_defaults(func=func_b)
           parser_b.add_argument('b_arg', type=int)

parser_c = subparsers.add_parser('parser_c', help='parser_c_help')
           parser_c.set_defaults(func=func_c)
           parser_c.add_argument('c_arg', type=int)

parser_d = subparsers.add_parser('parser_d', help='parser_d_help')
           parser_d.set_defaults(func=func_d)
           parser_d.add_argument('d_arg', type=int)

parser_e = subparsers.add_parser('parser_e', help='parser_e_help')
           parser_e.set_defaults(func=func_e)
           parser_e.add_argument('e_arg', type=int)

parser_f = subparsers.add_parser('parser_f', help='parser_f_help')
           parser_f.set_defaults(func=func_f)
           parser_f.add_argument('f_arg', type=int)

# Parse arguments

args = parser.parse_args()
args.func(args)

def main(a_arg, b_arg, c_arg, d_arg, e_arg, f_arg):
    #Do stuff with these args

if __name__ == "__main__":
   main(args.a_arg, args.b_arg, args.c_arg, args.d_arg, args.e_arg, args.f_arg)

So the behavior I want is that on the command line I can type

$ python my_function.py parser_a 3

$ python my_function.py parser_b 5

$ python my_function.py parser_c 8

$ python my_function.py parser_d 150

$ python my_function.py parser_e 42

$ python my_function.py parser_f 2

So that if there's a problem in one subcommand I can run that one independently for debugging.

Any help understanding the logic of what I should be doing would be greatly appreciated. I'm not even sure if the behavior I want is the behavior that I should want.